1 \input texinfo @c -*-texinfo-*-
2 @comment %**start of header (This is for running Texinfo on a region.)
4 @setfilename ../../info/calc.info
6 @settitle GNU Emacs Calc Manual
7 @documentencoding UTF-8
9 @comment %**end of header (This is for running Texinfo on a region.)
11 @include emacsver.texi
13 @c The following macros are used for conditional output for single lines.
15 @c `foo' will appear only in TeX output
17 @c `foo' will appear only in non-TeX output
19 @c @expr{expr} will typeset an expression;
20 @c $x$ in TeX, @samp{x} otherwise.
25 @alias infoline=comment
39 @alias texline=comment
40 @macro infoline{stuff}
59 % Suggested by Karl Berry <karl@@freefriends.org>
60 \gdef\!{\mskip-\thinmuskip}
63 @c Fix some other things specifically for this manual.
66 @mathcode`@:=`@: @c Make Calc fractions come out right in math mode
68 \gdef\coloneq{\mathrel{\mathord:\mathord=}}
70 \gdef\beforedisplay{\vskip-10pt}
71 \gdef\afterdisplay{\vskip-5pt}
72 \gdef\beforedisplayh{\vskip-25pt}
73 \gdef\afterdisplayh{\vskip-10pt}
75 @newdimen@kyvpos @kyvpos=0pt
76 @newdimen@kyhpos @kyhpos=0pt
77 @newcount@calcclubpenalty @calcclubpenalty=1000
80 @newtoks@calcoldeverypar @calcoldeverypar=@everypar
81 @everypar={@calceverypar@the@calcoldeverypar}
82 @ifx@ninett@undefinedzzz@font@ninett=cmtt9@fi
83 @catcode`@\=0 \catcode`\@=11
85 \catcode`\@=0 @catcode`@\=@active
91 This file documents Calc, the GNU Emacs calculator.
94 This file documents Calc, the GNU Emacs calculator, included with
95 GNU Emacs @value{EMACSVER}.
98 Copyright @copyright{} 1990--1991, 2001--2014 Free Software Foundation, Inc.
101 Permission is granted to copy, distribute and/or modify this document
102 under the terms of the GNU Free Documentation License, Version 1.3 or
103 any later version published by the Free Software Foundation; with the
104 Invariant Sections being just ``GNU GENERAL PUBLIC LICENSE'', with the
105 Front-Cover Texts being ``A GNU Manual,'' and with the Back-Cover
106 Texts as in (a) below. A copy of the license is included in the section
107 entitled ``GNU Free Documentation License.''
109 (a) The FSF's Back-Cover Text is: ``You have the freedom to copy and
110 modify this GNU manual.''
114 @dircategory Emacs misc features
116 * Calc: (calc). Advanced desk calculator and mathematical tool.
121 @center @titlefont{Calc Manual}
123 @center GNU Emacs Calc
126 @center Dave Gillespie
127 @center daveg@@synaptics.com
130 @vskip 0pt plus 1filll
143 @node Top, Getting Started, (dir), (dir)
144 @top The GNU Emacs Calculator
147 @dfn{Calc} is an advanced desk calculator and mathematical tool
148 written by Dave Gillespie that runs as part of the GNU Emacs environment.
150 This manual, also written (mostly) by Dave Gillespie, is divided into
151 three major parts: ``Getting Started,'' the ``Calc Tutorial,'' and the
152 ``Calc Reference.'' The Tutorial introduces all the major aspects of
153 Calculator use in an easy, hands-on way. The remainder of the manual is
154 a complete reference to the features of the Calculator.
158 For help in the Emacs Info system (which you are using to read this
159 file), type @kbd{?}. (You can also type @kbd{h} to run through a
160 longer Info tutorial.)
166 * Getting Started:: General description and overview.
168 * Interactive Tutorial::
170 * Tutorial:: A step-by-step introduction for beginners.
172 * Introduction:: Introduction to the Calc reference manual.
173 * Data Types:: Types of objects manipulated by Calc.
174 * Stack and Trail:: Manipulating the stack and trail buffers.
175 * Mode Settings:: Adjusting display format and other modes.
176 * Arithmetic:: Basic arithmetic functions.
177 * Scientific Functions:: Transcendentals and other scientific functions.
178 * Matrix Functions:: Operations on vectors and matrices.
179 * Algebra:: Manipulating expressions algebraically.
180 * Units:: Operations on numbers with units.
181 * Store and Recall:: Storing and recalling variables.
182 * Graphics:: Commands for making graphs of data.
183 * Kill and Yank:: Moving data into and out of Calc.
184 * Keypad Mode:: Operating Calc from a keypad.
185 * Embedded Mode:: Working with formulas embedded in a file.
186 * Programming:: Calc as a programmable calculator.
188 * Copying:: How you can copy and share Calc.
189 * GNU Free Documentation License:: The license for this documentation.
190 * Customizing Calc:: Customizing Calc.
191 * Reporting Bugs:: How to report bugs and make suggestions.
193 * Summary:: Summary of Calc commands and functions.
195 * Key Index:: The standard Calc key sequences.
196 * Command Index:: The interactive Calc commands.
197 * Function Index:: Functions (in algebraic formulas).
198 * Concept Index:: General concepts.
199 * Variable Index:: Variables used by Calc (both user and internal).
200 * Lisp Function Index:: Internal Lisp math functions.
204 @node Getting Started, Interactive Tutorial, Top, Top
207 @node Getting Started, Tutorial, Top, Top
209 @chapter Getting Started
211 This chapter provides a general overview of Calc, the GNU Emacs
212 Calculator: What it is, how to start it and how to exit from it,
213 and what are the various ways that it can be used.
217 * About This Manual::
218 * Notations Used in This Manual::
219 * Demonstration of Calc::
221 * History and Acknowledgments::
224 @node What is Calc, About This Manual, Getting Started, Getting Started
225 @section What is Calc?
228 @dfn{Calc} is an advanced calculator and mathematical tool that runs as
229 part of the GNU Emacs environment. Very roughly based on the HP-28/48
230 series of calculators, its many features include:
234 Choice of algebraic or RPN (stack-based) entry of calculations.
237 Arbitrary precision integers and floating-point numbers.
240 Arithmetic on rational numbers, complex numbers (rectangular and polar),
241 error forms with standard deviations, open and closed intervals, vectors
242 and matrices, dates and times, infinities, sets, quantities with units,
243 and algebraic formulas.
246 Mathematical operations such as logarithms and trigonometric functions.
249 Programmer's features (bitwise operations, non-decimal numbers).
252 Financial functions such as future value and internal rate of return.
255 Number theoretical features such as prime factorization and arithmetic
256 modulo @var{m} for any @var{m}.
259 Algebraic manipulation features, including symbolic calculus.
262 Moving data to and from regular editing buffers.
265 Embedded mode for manipulating Calc formulas and data directly
266 inside any editing buffer.
269 Graphics using GNUPLOT, a versatile (and free) plotting program.
272 Easy programming using keyboard macros, algebraic formulas,
273 algebraic rewrite rules, or extended Emacs Lisp.
276 Calc tries to include a little something for everyone; as a result it is
277 large and might be intimidating to the first-time user. If you plan to
278 use Calc only as a traditional desk calculator, all you really need to
279 read is the ``Getting Started'' chapter of this manual and possibly the
280 first few sections of the tutorial. As you become more comfortable with
281 the program you can learn its additional features. Calc does not
282 have the scope and depth of a fully-functional symbolic math package,
283 but Calc has the advantages of convenience, portability, and freedom.
285 @node About This Manual, Notations Used in This Manual, What is Calc, Getting Started
286 @section About This Manual
289 This document serves as a complete description of the GNU Emacs
290 Calculator. It works both as an introduction for novices and as
291 a reference for experienced users. While it helps to have some
292 experience with GNU Emacs in order to get the most out of Calc,
293 this manual ought to be readable even if you don't know or use Emacs
296 This manual is divided into three major parts: the ``Getting
297 Started'' chapter you are reading now, the Calc tutorial, and the Calc
300 @c This manual has been printed in two volumes, the @dfn{Tutorial} and the
301 @c @dfn{Reference}. Both volumes include a copy of the ``Getting Started''
304 If you are in a hurry to use Calc, there is a brief ``demonstration''
305 below which illustrates the major features of Calc in just a couple of
306 pages. If you don't have time to go through the full tutorial, this
307 will show you everything you need to know to begin.
308 @xref{Demonstration of Calc}.
310 The tutorial chapter walks you through the various parts of Calc
311 with lots of hands-on examples and explanations. If you are new
312 to Calc and you have some time, try going through at least the
313 beginning of the tutorial. The tutorial includes about 70 exercises
314 with answers. These exercises give you some guided practice with
315 Calc, as well as pointing out some interesting and unusual ways
318 The reference section discusses Calc in complete depth. You can read
319 the reference from start to finish if you want to learn every aspect
320 of Calc. Or, you can look in the table of contents or the Concept
321 Index to find the parts of the manual that discuss the things you
324 @c @cindex Marginal notes
325 Every Calc keyboard command is listed in the Calc Summary, and also
326 in the Key Index. Algebraic functions, @kbd{M-x} commands, and
327 variables also have their own indices.
329 @c @infoline In the printed manual, each
330 @c paragraph that is referenced in the Key or Function Index is marked
331 @c in the margin with its index entry.
333 @c [fix-ref Help Commands]
334 You can access this manual on-line at any time within Calc by pressing
335 the @kbd{h i} key sequence. Outside of the Calc window, you can press
336 @kbd{C-x * i} to read the manual on-line. From within Calc the command
337 @kbd{h t} will jump directly to the Tutorial; from outside of Calc the
338 command @kbd{C-x * t} will jump to the Tutorial and start Calc if
339 necessary. Pressing @kbd{h s} or @kbd{C-x * s} will take you directly
340 to the Calc Summary. Within Calc, you can also go to the part of the
341 manual describing any Calc key, function, or variable using
342 @w{@kbd{h k}}, @kbd{h f}, or @kbd{h v}, respectively. @xref{Help Commands}.
345 The Calc manual can be printed, but because the manual is so large, you
346 should only make a printed copy if you really need it. To print the
347 manual, you will need the @TeX{} typesetting program (this is a free
348 program by Donald Knuth at Stanford University) as well as the
349 @file{texindex} program and @file{texinfo.tex} file, both of which can
350 be obtained from the FSF as part of the @code{texinfo} package.
351 To print the Calc manual in one huge tome, you will need the
352 Emacs source, which contains the source code to this manual,
353 @file{calc.texi}. Change to the @file{doc/misc} subdirectory of the
354 Emacs source distribution, which contains source code for this manual,
355 and type @kbd{make calc.pdf}. (Don't worry if you get some ``overfull
356 box'' warnings while @TeX{} runs.) The result will be this entire
357 manual as a pdf file.
359 @c Printed copies of this manual are also available from the Free Software
362 @node Notations Used in This Manual, Demonstration of Calc, About This Manual, Getting Started
363 @section Notations Used in This Manual
366 This section describes the various notations that are used
367 throughout the Calc manual.
369 In keystroke sequences, uppercase letters mean you must hold down
370 the shift key while typing the letter. Keys pressed with Control
371 held down are shown as @kbd{C-x}. Keys pressed with Meta held down
372 are shown as @kbd{M-x}. Other notations are @key{RET} for the
373 Return key, @key{SPC} for the space bar, @key{TAB} for the Tab key,
374 @key{DEL} for the Delete key, and @key{LFD} for the Line-Feed key.
375 The @key{DEL} key is called Backspace on some keyboards, it is
376 whatever key you would use to correct a simple typing error when
377 regularly using Emacs.
379 (If you don't have the @key{LFD} or @key{TAB} keys on your keyboard,
380 the @kbd{C-j} and @kbd{C-i} keys are equivalent to them, respectively.
381 If you don't have a Meta key, look for Alt or Extend Char. You can
382 also press @key{ESC} or @kbd{C-[} first to get the same effect, so
383 that @kbd{M-x}, @kbd{@key{ESC} x}, and @kbd{C-[ x} are all equivalent.)
385 Sometimes the @key{RET} key is not shown when it is ``obvious''
386 that you must press @key{RET} to proceed. For example, the @key{RET}
387 is usually omitted in key sequences like @kbd{M-x calc-keypad @key{RET}}.
389 Commands are generally shown like this: @kbd{p} (@code{calc-precision})
390 or @kbd{C-x * k} (@code{calc-keypad}). This means that the command is
391 normally used by pressing the @kbd{p} key or @kbd{C-x * k} key sequence,
392 but it also has the full-name equivalent shown, e.g., @kbd{M-x calc-precision}.
394 Commands that correspond to functions in algebraic notation
395 are written: @kbd{C} (@code{calc-cos}) [@code{cos}]. This means
396 the @kbd{C} key is equivalent to @kbd{M-x calc-cos}, and that
397 the corresponding function in an algebraic-style formula would
398 be @samp{cos(@var{x})}.
400 A few commands don't have key equivalents: @code{calc-sincos}
403 @node Demonstration of Calc, Using Calc, Notations Used in This Manual, Getting Started
404 @section A Demonstration of Calc
407 @cindex Demonstration of Calc
408 This section will show some typical small problems being solved with
409 Calc. The focus is more on demonstration than explanation, but
410 everything you see here will be covered more thoroughly in the
413 To begin, start Emacs if necessary (usually the command @code{emacs}
414 does this), and type @kbd{C-x * c} to start the
415 Calculator. (You can also use @kbd{M-x calc} if this doesn't work.
416 @xref{Starting Calc}, for various ways of starting the Calculator.)
418 Be sure to type all the sample input exactly, especially noting the
419 difference between lower-case and upper-case letters. Remember,
420 @key{RET}, @key{TAB}, @key{DEL}, and @key{SPC} are the Return, Tab,
421 Delete, and Space keys.
423 @strong{RPN calculation.} In RPN, you type the input number(s) first,
424 then the command to operate on the numbers.
427 Type @kbd{2 @key{RET} 3 + Q} to compute
428 @texline @math{\sqrt{2+3} = 2.2360679775}.
429 @infoline the square root of 2+3, which is 2.2360679775.
432 Type @kbd{P 2 ^} to compute
433 @texline @math{\pi^2 = 9.86960440109}.
434 @infoline the value of `pi' squared, 9.86960440109.
437 Type @key{TAB} to exchange the order of these two results.
440 Type @kbd{- I H S} to subtract these results and compute the Inverse
441 Hyperbolic sine of the difference, 2.72996136574.
444 Type @key{DEL} to erase this result.
446 @strong{Algebraic calculation.} You can also enter calculations using
447 conventional ``algebraic'' notation. To enter an algebraic formula,
448 use the apostrophe key.
451 Type @kbd{' sqrt(2+3) @key{RET}} to compute
452 @texline @math{\sqrt{2+3}}.
453 @infoline the square root of 2+3.
456 Type @kbd{' pi^2 @key{RET}} to enter
457 @texline @math{\pi^2}.
458 @infoline `pi' squared.
459 To evaluate this symbolic formula as a number, type @kbd{=}.
462 Type @kbd{' arcsinh($ - $$) @key{RET}} to subtract the second-most-recent
463 result from the most-recent and compute the Inverse Hyperbolic sine.
465 @strong{Keypad mode.} If you are using the X window system, press
466 @w{@kbd{C-x * k}} to get Keypad mode. (If you don't use X, skip to
470 Click on the @key{2}, @key{ENTER}, @key{3}, @key{+}, and @key{SQRT}
471 ``buttons'' using your left mouse button.
474 Click on @key{PI}, @key{2}, and @tfn{y^x}.
477 Click on @key{INV}, then @key{ENTER} to swap the two results.
480 Click on @key{-}, @key{INV}, @key{HYP}, and @key{SIN}.
483 Click on @key{<-} to erase the result, then click @key{OFF} to turn
484 the Keypad Calculator off.
486 @strong{Grabbing data.} Type @kbd{C-x * x} if necessary to exit Calc.
487 Now select the following numbers as an Emacs region: ``Mark'' the
488 front of the list by typing @kbd{C-@key{SPC}} or @kbd{C-@@} there,
489 then move to the other end of the list. (Either get this list from
490 the on-line copy of this manual, accessed by @w{@kbd{C-x * i}}, or just
491 type these numbers into a scratch file.) Now type @kbd{C-x * g} to
492 ``grab'' these numbers into Calc.
503 The result @samp{[1.23, 1.97, 1.6, 2, 1.19, 1.08]} is a Calc ``vector.''
504 Type @w{@kbd{V R +}} to compute the sum of these numbers.
507 Type @kbd{U} to Undo this command, then type @kbd{V R *} to compute
508 the product of the numbers.
511 You can also grab data as a rectangular matrix. Place the cursor on
512 the upper-leftmost @samp{1} and set the mark, then move to just after
513 the lower-right @samp{8} and press @kbd{C-x * r}.
516 Type @kbd{v t} to transpose this
517 @texline @math{3\times2}
520 @texline @math{2\times3}
522 matrix. Type @w{@kbd{v u}} to unpack the rows into two separate
523 vectors. Now type @w{@kbd{V R + @key{TAB} V R +}} to compute the sums
524 of the two original columns. (There is also a special
525 grab-and-sum-columns command, @kbd{C-x * :}.)
527 @strong{Units conversion.} Units are entered algebraically.
528 Type @w{@kbd{' 43 mi/hr @key{RET}}} to enter the quantity 43 miles-per-hour.
529 Type @w{@kbd{u c km/hr @key{RET}}}. Type @w{@kbd{u c m/s @key{RET}}}.
531 @strong{Date arithmetic.} Type @kbd{t N} to get the current date and
532 time. Type @kbd{90 +} to find the date 90 days from now. Type
533 @kbd{' <25 dec 87> @key{RET}} to enter a date, then @kbd{- 7 /} to see how
534 many weeks have passed since then.
536 @strong{Algebra.} Algebraic entries can also include formulas
537 or equations involving variables. Type @kbd{@w{' [x + y} = a, x y = 1] @key{RET}}
538 to enter a pair of equations involving three variables.
539 (Note the leading apostrophe in this example; also, note that the space
540 in @samp{x y} is required.) Type @w{@kbd{a S x,y @key{RET}}} to solve
541 these equations for the variables @expr{x} and @expr{y}.
544 Type @kbd{d B} to view the solutions in more readable notation.
545 Type @w{@kbd{d C}} to view them in C language notation, @kbd{d T}
546 to view them in the notation for the @TeX{} typesetting system,
547 and @kbd{d L} to view them in the notation for the @LaTeX{} typesetting
548 system. Type @kbd{d N} to return to normal notation.
551 Type @kbd{7.5}, then @kbd{s l a @key{RET}} to let @expr{a = 7.5} in these formulas.
552 (That's the letter @kbd{l}, not the numeral @kbd{1}.)
555 @strong{Help functions.} You can read about any command in the on-line
556 manual. Type @kbd{C-x * c} to return to Calc after each of these
557 commands: @kbd{h k t N} to read about the @kbd{t N} command,
558 @kbd{h f sqrt @key{RET}} to read about the @code{sqrt} function, and
559 @kbd{h s} to read the Calc summary.
562 @strong{Help functions.} You can read about any command in the on-line
563 manual. Remember to type the letter @kbd{l}, then @kbd{C-x * c}, to
564 return here after each of these commands: @w{@kbd{h k t N}} to read
565 about the @w{@kbd{t N}} command, @kbd{h f sqrt @key{RET}} to read about the
566 @code{sqrt} function, and @kbd{h s} to read the Calc summary.
569 Press @key{DEL} repeatedly to remove any leftover results from the stack.
570 To exit from Calc, press @kbd{q} or @kbd{C-x * c} again.
572 @node Using Calc, History and Acknowledgments, Demonstration of Calc, Getting Started
576 Calc has several user interfaces that are specialized for
577 different kinds of tasks. As well as Calc's standard interface,
578 there are Quick mode, Keypad mode, and Embedded mode.
582 * The Standard Interface::
583 * Quick Mode Overview::
584 * Keypad Mode Overview::
585 * Standalone Operation::
586 * Embedded Mode Overview::
587 * Other C-x * Commands::
590 @node Starting Calc, The Standard Interface, Using Calc, Using Calc
591 @subsection Starting Calc
594 On most systems, you can type @kbd{C-x *} to start the Calculator.
595 The key sequence @kbd{C-x *} is bound to the command @code{calc-dispatch},
596 which can be rebound if convenient (@pxref{Customizing Calc}).
598 When you press @kbd{C-x *}, Emacs waits for you to press a second key to
599 complete the command. In this case, you will follow @kbd{C-x *} with a
600 letter (upper- or lower-case, it doesn't matter for @kbd{C-x *}) that says
601 which Calc interface you want to use.
603 To get Calc's standard interface, type @kbd{C-x * c}. To get
604 Keypad mode, type @kbd{C-x * k}. Type @kbd{C-x * ?} to get a brief
605 list of the available options, and type a second @kbd{?} to get
608 To ease typing, @kbd{C-x * *} also works to start Calc. It starts the
609 same interface (either @kbd{C-x * c} or @w{@kbd{C-x * k}}) that you last
610 used, selecting the @kbd{C-x * c} interface by default.
612 If @kbd{C-x *} doesn't work for you, you can always type explicit
613 commands like @kbd{M-x calc} (for the standard user interface) or
614 @w{@kbd{M-x calc-keypad}} (for Keypad mode). First type @kbd{M-x}
615 (that's Meta with the letter @kbd{x}), then, at the prompt,
616 type the full command (like @kbd{calc-keypad}) and press Return.
618 The same commands (like @kbd{C-x * c} or @kbd{C-x * *}) that start
619 the Calculator also turn it off if it is already on.
621 @node The Standard Interface, Quick Mode Overview, Starting Calc, Using Calc
622 @subsection The Standard Calc Interface
625 @cindex Standard user interface
626 Calc's standard interface acts like a traditional RPN calculator,
627 operated by the normal Emacs keyboard. When you type @kbd{C-x * c}
628 to start the Calculator, the Emacs screen splits into two windows
629 with the file you were editing on top and Calc on the bottom.
635 --**-Emacs: myfile (Fundamental)----All----------------------
636 --- Emacs Calculator Mode --- |Emacs Calculator Trail
644 --%*-Calc: 12 Deg (Calculator)----All----- --%*- *Calc Trail*
648 In this figure, the mode-line for @file{myfile} has moved up and the
649 ``Calculator'' window has appeared below it. As you can see, Calc
650 actually makes two windows side-by-side. The lefthand one is
651 called the @dfn{stack window} and the righthand one is called the
652 @dfn{trail window.} The stack holds the numbers involved in the
653 calculation you are currently performing. The trail holds a complete
654 record of all calculations you have done. In a desk calculator with
655 a printer, the trail corresponds to the paper tape that records what
658 In this case, the trail shows that four numbers (17.3, 3, 2, and 4)
659 were first entered into the Calculator, then the 2 and 4 were
660 multiplied to get 8, then the 3 and 8 were subtracted to get @mathit{-5}.
661 (The @samp{>} symbol shows that this was the most recent calculation.)
662 The net result is the two numbers 17.3 and @mathit{-5} sitting on the stack.
664 Most Calculator commands deal explicitly with the stack only, but
665 there is a set of commands that allow you to search back through
666 the trail and retrieve any previous result.
668 Calc commands use the digits, letters, and punctuation keys.
669 Shifted (i.e., upper-case) letters are different from lowercase
670 letters. Some letters are @dfn{prefix} keys that begin two-letter
671 commands. For example, @kbd{e} means ``enter exponent'' and shifted
672 @kbd{E} means @expr{e^x}. With the @kbd{d} (``display modes'') prefix
673 the letter ``e'' takes on very different meanings: @kbd{d e} means
674 ``engineering notation'' and @kbd{d E} means ``@dfn{eqn} language mode.''
676 There is nothing stopping you from switching out of the Calc
677 window and back into your editing window, say by using the Emacs
678 @w{@kbd{C-x o}} (@code{other-window}) command. When the cursor is
679 inside a regular window, Emacs acts just like normal. When the
680 cursor is in the Calc stack or trail windows, keys are interpreted
683 When you quit by pressing @kbd{C-x * c} a second time, the Calculator
684 windows go away but the actual Stack and Trail are not gone, just
685 hidden. When you press @kbd{C-x * c} once again you will get the
686 same stack and trail contents you had when you last used the
689 The Calculator does not remember its state between Emacs sessions.
690 Thus if you quit Emacs and start it again, @kbd{C-x * c} will give you
691 a fresh stack and trail. There is a command (@kbd{m m}) that lets
692 you save your favorite mode settings between sessions, though.
693 One of the things it saves is which user interface (standard or
694 Keypad) you last used; otherwise, a freshly started Emacs will
695 always treat @kbd{C-x * *} the same as @kbd{C-x * c}.
697 The @kbd{q} key is another equivalent way to turn the Calculator off.
699 If you type @kbd{C-x * b} first and then @kbd{C-x * c}, you get a
700 full-screen version of Calc (@code{full-calc}) in which the stack and
701 trail windows are still side-by-side but are now as tall as the whole
702 Emacs screen. When you press @kbd{q} or @kbd{C-x * c} again to quit,
703 the file you were editing before reappears. The @kbd{C-x * b} key
704 switches back and forth between ``big'' full-screen mode and the
705 normal partial-screen mode.
707 Finally, @kbd{C-x * o} (@code{calc-other-window}) is like @kbd{C-x * c}
708 except that the Calc window is not selected. The buffer you were
709 editing before remains selected instead. If you are in a Calc window,
710 then @kbd{C-x * o} will switch you out of it, being careful not to
711 switch you to the Calc Trail window. So @kbd{C-x * o} is a handy
712 way to switch out of Calc momentarily to edit your file; you can then
713 type @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---+----+----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, leaving a blank line before and after the
880 Now, move the cursor onto this new formula and press @kbd{C-x * e}.
881 Calc will read the formula (using the surrounding blank lines to tell
882 how much text to read), then push this formula (invisibly) onto the Calc
883 stack. The cursor will stay on the formula in the editing buffer, but
884 the line with the formula will now appear as it would on the Calc stack
885 (in this case, it will be left-aligned) and the buffer's mode line will
886 change to look like the Calc mode line (with mode indicators like
887 @samp{12 Deg} and so on). Even though you are still in your editing
888 buffer, the keyboard now acts like the Calc keyboard, and any new result
889 you get is copied from the stack back into the buffer. To take the
890 derivative, you would type @kbd{a d x @key{RET}}.
904 (Note that by default, Calc gives division lower precedence than multiplication,
905 so that @samp{1 / x ln(x)} is equivalent to @samp{1 / (x ln(x))}.)
907 To make this look nicer, you might want to press @kbd{d =} to center
908 the formula, and even @kbd{d B} to use Big display mode.
917 % [calc-mode: justify: center]
918 % [calc-mode: language: big]
926 Calc has added annotations to the file to help it remember the modes
927 that were used for this formula. They are formatted like comments
928 in the @TeX{} typesetting language, just in case you are using @TeX{} or
929 @LaTeX{}. (In this example @TeX{} is not being used, so you might want
930 to move these comments up to the top of the file or otherwise put them
933 As an extra flourish, we can add an equation number using a
934 righthand label: Type @kbd{d @} (1) @key{RET}}.
938 % [calc-mode: justify: center]
939 % [calc-mode: language: big]
940 % [calc-mode: right-label: " (1)"]
948 To leave Embedded mode, type @kbd{C-x * e} again. The mode line
949 and keyboard will revert to the way they were before.
951 The related command @kbd{C-x * w} operates on a single word, which
952 generally means a single number, inside text. It searches for an
953 expression which ``looks'' like a number containing the point.
954 Here's an example of its use (before you try this, remove the Calc
955 annotations or use a new buffer so that the extra settings in the
956 annotations don't take effect):
959 A slope of one-third corresponds to an angle of 1 degrees.
962 Place the cursor on the @samp{1}, then type @kbd{C-x * w} to enable
963 Embedded mode on that number. Now type @kbd{3 /} (to get one-third),
964 and @kbd{I T} (the Inverse Tangent converts a slope into an angle),
965 then @w{@kbd{C-x * w}} again to exit Embedded mode.
968 A slope of one-third corresponds to an angle of 18.4349488229 degrees.
971 @c [fix-ref Embedded Mode]
972 @xref{Embedded Mode}, for full details.
974 @node Other C-x * Commands, , Embedded Mode Overview, Using Calc
975 @subsection Other @kbd{C-x *} Commands
978 Two more Calc-related commands are @kbd{C-x * g} and @kbd{C-x * r},
979 which ``grab'' data from a selected region of a buffer into the
980 Calculator. The region is defined in the usual Emacs way, by
981 a ``mark'' placed at one end of the region, and the Emacs
982 cursor or ``point'' placed at the other.
984 The @kbd{C-x * g} command reads the region in the usual left-to-right,
985 top-to-bottom order. The result is packaged into a Calc vector
986 of numbers and placed on the stack. Calc (in its standard
987 user interface) is then started. Type @kbd{v u} if you want
988 to unpack this vector into separate numbers on the stack. Also,
989 @kbd{C-u C-x * g} interprets the region as a single number or
992 The @kbd{C-x * r} command reads a rectangle, with the point and
993 mark defining opposite corners of the rectangle. The result
994 is a matrix of numbers on the Calculator stack.
996 Complementary to these is @kbd{C-x * y}, which ``yanks'' the
997 value at the top of the Calc stack back into an editing buffer.
998 If you type @w{@kbd{C-x * y}} while in such a buffer, the value is
999 yanked at the current position. If you type @kbd{C-x * y} while
1000 in the Calc buffer, Calc makes an educated guess as to which
1001 editing buffer you want to use. The Calc window does not have
1002 to be visible in order to use this command, as long as there
1003 is something on the Calc stack.
1005 Here, for reference, is the complete list of @kbd{C-x *} commands.
1006 The shift, control, and meta keys are ignored for the keystroke
1007 following @kbd{C-x *}.
1010 Commands for turning Calc on and off:
1014 Turn Calc on or off, employing the same user interface as last time.
1016 @item =, +, -, /, \, &, #
1017 Alternatives for @kbd{*}.
1020 Turn Calc on or off using its standard bottom-of-the-screen
1021 interface. If Calc is already turned on but the cursor is not
1022 in the Calc window, move the cursor into the window.
1025 Same as @kbd{C}, but don't select the new Calc window. If
1026 Calc is already turned on and the cursor is in the Calc window,
1027 move it out of that window.
1030 Control whether @kbd{C-x * c} and @kbd{C-x * k} use the full screen.
1033 Use Quick mode for a single short calculation.
1036 Turn Calc Keypad mode on or off.
1039 Turn Calc Embedded mode on or off at the current formula.
1042 Turn Calc Embedded mode on or off, select the interesting part.
1045 Turn Calc Embedded mode on or off at the current word (number).
1048 Turn Calc on in a user-defined way, as defined by a @kbd{Z I} command.
1051 Quit Calc; turn off standard, Keypad, or Embedded mode if on.
1052 (This is like @kbd{q} or @key{OFF} inside of Calc.)
1059 Commands for moving data into and out of the Calculator:
1063 Grab the region into the Calculator as a vector.
1066 Grab the rectangular region into the Calculator as a matrix.
1069 Grab the rectangular region and compute the sums of its columns.
1072 Grab the rectangular region and compute the sums of its rows.
1075 Yank a value from the Calculator into the current editing buffer.
1082 Commands for use with Embedded mode:
1086 ``Activate'' the current buffer. Locate all formulas that
1087 contain @samp{:=} or @samp{=>} symbols and record their locations
1088 so that they can be updated automatically as variables are changed.
1091 Duplicate the current formula immediately below and select
1095 Insert a new formula at the current point.
1098 Move the cursor to the next active formula in the buffer.
1101 Move the cursor to the previous active formula in the buffer.
1104 Update (i.e., as if by the @kbd{=} key) the formula at the current point.
1107 Edit (as if by @code{calc-edit}) the formula at the current point.
1114 Miscellaneous commands:
1118 Run the Emacs Info system to read the Calc manual.
1119 (This is the same as @kbd{h i} inside of Calc.)
1122 Run the Emacs Info system to read the Calc Tutorial.
1125 Run the Emacs Info system to read the Calc Summary.
1128 Load Calc entirely into memory. (Normally the various parts
1129 are loaded only as they are needed.)
1132 Read a region of written keystroke names (like @kbd{C-n a b c @key{RET}})
1133 and record them as the current keyboard macro.
1136 (This is the ``zero'' digit key.) Reset the Calculator to
1137 its initial state: Empty stack, and initial mode settings.
1140 @node History and Acknowledgments, , Using Calc, Getting Started
1141 @section History and Acknowledgments
1144 Calc was originally started as a two-week project to occupy a lull
1145 in the author's schedule. Basically, a friend asked if I remembered
1147 @texline @math{2^{32}}.
1148 @infoline @expr{2^32}.
1149 I didn't offhand, but I said, ``that's easy, just call up an
1150 @code{xcalc}.'' @code{Xcalc} duly reported that the answer to our
1151 question was @samp{4.294967e+09}---with no way to see the full ten
1152 digits even though we knew they were there in the program's memory! I
1153 was so annoyed, I vowed to write a calculator of my own, once and for
1156 I chose Emacs Lisp, a) because I had always been curious about it
1157 and b) because, being only a text editor extension language after
1158 all, Emacs Lisp would surely reach its limits long before the project
1159 got too far out of hand.
1161 To make a long story short, Emacs Lisp turned out to be a distressingly
1162 solid implementation of Lisp, and the humble task of calculating
1163 turned out to be more open-ended than one might have expected.
1165 Emacs Lisp didn't have built-in floating point math (now it does), so
1166 this had to be simulated in software. In fact, Emacs integers would
1167 only comfortably fit six decimal digits or so (at the time)---not
1168 enough for a decent calculator. So I had to write my own
1169 high-precision integer code as well, and once I had this I figured
1170 that arbitrary-size integers were just as easy as large integers.
1171 Arbitrary floating-point precision was the logical next step. Also,
1172 since the large integer arithmetic was there anyway it seemed only
1173 fair to give the user direct access to it, which in turn made it
1174 practical to support fractions as well as floats. All these features
1175 inspired me to look around for other data types that might be worth
1178 Around this time, my friend Rick Koshi showed me his nifty new HP-28
1179 calculator. It allowed the user to manipulate formulas as well as
1180 numerical quantities, and it could also operate on matrices. I
1181 decided that these would be good for Calc to have, too. And once
1182 things had gone this far, I figured I might as well take a look at
1183 serious algebra systems for further ideas. Since these systems did
1184 far more than I could ever hope to implement, I decided to focus on
1185 rewrite rules and other programming features so that users could
1186 implement what they needed for themselves.
1188 Rick complained that matrices were hard to read, so I put in code to
1189 format them in a 2D style. Once these routines were in place, Big mode
1190 was obligatory. Gee, what other language modes would be useful?
1192 Scott Hemphill and Allen Knutson, two friends with a strong mathematical
1193 bent, contributed ideas and algorithms for a number of Calc features
1194 including modulo forms, primality testing, and float-to-fraction conversion.
1196 Units were added at the eager insistence of Mass Sivilotti. Later,
1197 Ulrich Mueller at CERN and Przemek Klosowski at NIST provided invaluable
1198 expert assistance with the units table. As far as I can remember, the
1199 idea of using algebraic formulas and variables to represent units dates
1200 back to an ancient article in Byte magazine about muMath, an early
1201 algebra system for microcomputers.
1203 Many people have contributed to Calc by reporting bugs and suggesting
1204 features, large and small. A few deserve special mention: Tim Peters,
1205 who helped develop the ideas that led to the selection commands, rewrite
1206 rules, and many other algebra features;
1207 @texline Fran\c{c}ois
1209 Pinard, who contributed an early prototype of the Calc Summary appendix
1210 as well as providing valuable suggestions in many other areas of Calc;
1211 Carl Witty, whose eagle eyes discovered many typographical and factual
1212 errors in the Calc manual; Tim Kay, who drove the development of
1213 Embedded mode; Ove Ewerlid, who made many suggestions relating to the
1214 algebra commands and contributed some code for polynomial operations;
1215 Randal Schwartz, who suggested the @code{calc-eval} function; Juha
1216 Sarlin, who first worked out how to split Calc into quickly-loading
1217 parts; Bob Weiner, who helped immensely with the Lucid Emacs port; and
1218 Robert J. Chassell, who suggested the Calc Tutorial and exercises as
1219 well as many other things.
1221 @cindex Bibliography
1222 @cindex Knuth, Art of Computer Programming
1223 @cindex Numerical Recipes
1224 @c Should these be expanded into more complete references?
1225 Among the books used in the development of Calc were Knuth's @emph{Art
1226 of Computer Programming} (especially volume II, @emph{Seminumerical
1227 Algorithms}); @emph{Numerical Recipes} by Press, Flannery, Teukolsky,
1228 and Vetterling; Bevington's @emph{Data Reduction and Error Analysis
1229 for the Physical Sciences}; @emph{Concrete Mathematics} by Graham,
1230 Knuth, and Patashnik; Steele's @emph{Common Lisp, the Language}; the
1231 @emph{CRC Standard Math Tables} (William H. Beyer, ed.); and
1232 Abramowitz and Stegun's venerable @emph{Handbook of Mathematical
1233 Functions}. Also, of course, Calc could not have been written without
1234 the excellent @emph{GNU Emacs Lisp Reference Manual}, by Bil Lewis and
1237 Final thanks go to Richard Stallman, without whose fine implementations
1238 of the Emacs editor, language, and environment, Calc would have been
1239 finished in two weeks.
1244 @c This node is accessed by the `C-x * t' command.
1245 @node Interactive Tutorial, Tutorial, Getting Started, Top
1249 Some brief instructions on using the Emacs Info system for this tutorial:
1251 Press the space bar and Delete keys to go forward and backward in a
1252 section by screenfuls (or use the regular Emacs scrolling commands
1255 Press @kbd{n} or @kbd{p} to go to the Next or Previous section.
1256 If the section has a @dfn{menu}, press a digit key like @kbd{1}
1257 or @kbd{2} to go to a sub-section from the menu. Press @kbd{u} to
1258 go back up from a sub-section to the menu it is part of.
1260 Exercises in the tutorial all have cross-references to the
1261 appropriate page of the ``answers'' section. Press @kbd{f}, then
1262 the exercise number, to see the answer to an exercise. After
1263 you have followed a cross-reference, you can press the letter
1264 @kbd{l} to return to where you were before.
1266 You can press @kbd{?} at any time for a brief summary of Info commands.
1268 Press the number @kbd{1} now to enter the first section of the Tutorial.
1274 @node Tutorial, Introduction, Interactive Tutorial, Top
1277 @node Tutorial, Introduction, Getting Started, Top
1282 This chapter explains how to use Calc and its many features, in
1283 a step-by-step, tutorial way. You are encouraged to run Calc and
1284 work along with the examples as you read (@pxref{Starting Calc}).
1285 If you are already familiar with advanced calculators, you may wish
1287 to skip on to the rest of this manual.
1289 @c to skip on to volume II of this manual, the @dfn{Calc Reference}.
1291 @c [fix-ref Embedded Mode]
1292 This tutorial describes the standard user interface of Calc only.
1293 The Quick mode and Keypad mode interfaces are fairly
1294 self-explanatory. @xref{Embedded Mode}, for a description of
1295 the Embedded mode interface.
1297 The easiest way to read this tutorial on-line is to have two windows on
1298 your Emacs screen, one with Calc and one with the Info system. Press
1299 @kbd{C-x * t} to set this up; the on-line tutorial will be opened in the
1300 current window and Calc will be started in another window. From the
1301 Info window, the command @kbd{C-x * c} can be used to switch to the Calc
1302 window and @kbd{C-x * o} can be used to switch back to the Info window.
1303 (If you have a printed copy of the manual you can use that instead; in
1304 that case you only need to press @kbd{C-x * c} to start Calc.)
1306 This tutorial is designed to be done in sequence. But the rest of this
1307 manual does not assume you have gone through the tutorial. The tutorial
1308 does not cover everything in the Calculator, but it touches on most
1312 You may wish to print out a copy of the Calc Summary and keep notes on
1313 it as you learn Calc. @xref{About This Manual}, to see how to make a
1314 printed summary. @xref{Summary}.
1317 The Calc Summary at the end of the reference manual includes some blank
1318 space for your own use. You may wish to keep notes there as you learn
1324 * Arithmetic Tutorial::
1325 * Vector/Matrix Tutorial::
1327 * Algebra Tutorial::
1328 * Programming Tutorial::
1330 * Answers to Exercises::
1333 @node Basic Tutorial, Arithmetic Tutorial, Tutorial, Tutorial
1334 @section Basic Tutorial
1337 In this section, we learn how RPN and algebraic-style calculations
1338 work, how to undo and redo an operation done by mistake, and how
1339 to control various modes of the Calculator.
1342 * RPN Tutorial:: Basic operations with the stack.
1343 * Algebraic Tutorial:: Algebraic entry; variables.
1344 * Undo Tutorial:: If you make a mistake: Undo and the trail.
1345 * Modes Tutorial:: Common mode-setting commands.
1348 @node RPN Tutorial, Algebraic Tutorial, Basic Tutorial, Basic Tutorial
1349 @subsection RPN Calculations and the Stack
1351 @cindex RPN notation
1354 Calc normally uses RPN notation. You may be familiar with the RPN
1355 system from Hewlett-Packard calculators, FORTH, or PostScript.
1356 (Reverse Polish Notation, RPN, is named after the Polish mathematician
1360 Calc normally uses RPN notation. You may be familiar with the RPN
1361 system from Hewlett-Packard calculators, FORTH, or PostScript.
1362 (Reverse Polish Notation, RPN, is named after the Polish mathematician
1366 The central component of an RPN calculator is the @dfn{stack}. A
1367 calculator stack is like a stack of dishes. New dishes (numbers) are
1368 added at the top of the stack, and numbers are normally only removed
1369 from the top of the stack.
1373 In an operation like @expr{2+3}, the 2 and 3 are called the @dfn{operands}
1374 and the @expr{+} is the @dfn{operator}. In an RPN calculator you always
1375 enter the operands first, then the operator. Each time you type a
1376 number, Calc adds or @dfn{pushes} it onto the top of the Stack.
1377 When you press an operator key like @kbd{+}, Calc @dfn{pops} the appropriate
1378 number of operands from the stack and pushes back the result.
1380 Thus we could add the numbers 2 and 3 in an RPN calculator by typing:
1381 @kbd{2 @key{RET} 3 @key{RET} +}. (The @key{RET} key, Return, corresponds to
1382 the @key{ENTER} key on traditional RPN calculators.) Try this now if
1383 you wish; type @kbd{C-x * c} to switch into the Calc window (you can type
1384 @kbd{C-x * c} again or @kbd{C-x * o} to switch back to the Tutorial window).
1385 The first four keystrokes ``push'' the numbers 2 and 3 onto the stack.
1386 The @kbd{+} key ``pops'' the top two numbers from the stack, adds them,
1387 and pushes the result (5) back onto the stack. Here's how the stack
1388 will look at various points throughout the calculation:
1396 C-x * c 2 @key{RET} 3 @key{RET} + @key{DEL}
1400 The @samp{.} symbol is a marker that represents the top of the stack.
1401 Note that the ``top'' of the stack is really shown at the bottom of
1402 the Stack window. This may seem backwards, but it turns out to be
1403 less distracting in regular use.
1405 @cindex Stack levels
1406 @cindex Levels of stack
1407 The numbers @samp{1:} and @samp{2:} on the left are @dfn{stack level
1408 numbers}. Old RPN calculators always had four stack levels called
1409 @expr{x}, @expr{y}, @expr{z}, and @expr{t}. Calc's stack can grow
1410 as large as you like, so it uses numbers instead of letters. Some
1411 stack-manipulation commands accept a numeric argument that says
1412 which stack level to work on. Normal commands like @kbd{+} always
1413 work on the top few levels of the stack.
1415 @c [fix-ref Truncating the Stack]
1416 The Stack buffer is just an Emacs buffer, and you can move around in
1417 it using the regular Emacs motion commands. But no matter where the
1418 cursor is, even if you have scrolled the @samp{.} marker out of
1419 view, most Calc commands always move the cursor back down to level 1
1420 before doing anything. It is possible to move the @samp{.} marker
1421 upwards through the stack, temporarily ``hiding'' some numbers from
1422 commands like @kbd{+}. This is called @dfn{stack truncation} and
1423 we will not cover it in this tutorial; @pxref{Truncating the Stack},
1424 if you are interested.
1426 You don't really need the second @key{RET} in @kbd{2 @key{RET} 3
1427 @key{RET} +}. That's because if you type any operator name or
1428 other non-numeric key when you are entering a number, the Calculator
1429 automatically enters that number and then does the requested command.
1430 Thus @kbd{2 @key{RET} 3 +} will work just as well.
1432 Examples in this tutorial will often omit @key{RET} even when the
1433 stack displays shown would only happen if you did press @key{RET}:
1446 Here, after pressing @kbd{3} the stack would really show @samp{1: 2}
1447 with @samp{Calc:@: 3} in the minibuffer. In these situations, you can
1448 press the optional @key{RET} to see the stack as the figure shows.
1450 (@bullet{}) @strong{Exercise 1.} (This tutorial will include exercises
1451 at various points. Try them if you wish. Answers to all the exercises
1452 are located at the end of the Tutorial chapter. Each exercise will
1453 include a cross-reference to its particular answer. If you are
1454 reading with the Emacs Info system, press @kbd{f} and the
1455 exercise number to go to the answer, then the letter @kbd{l} to
1456 return to where you were.)
1459 Here's the first exercise: What will the keystrokes @kbd{1 @key{RET} 2
1460 @key{RET} 3 @key{RET} 4 + * -} compute? (@samp{*} is the symbol for
1461 multiplication.) Figure it out by hand, then try it with Calc to see
1462 if you're right. @xref{RPN Answer 1, 1}. (@bullet{})
1464 (@bullet{}) @strong{Exercise 2.} Compute
1465 @texline @math{(2\times4) + (7\times9.5) + {5\over4}}
1466 @infoline @expr{2*4 + 7*9.5 + 5/4}
1467 using the stack. @xref{RPN Answer 2, 2}. (@bullet{})
1469 The @key{DEL} key is called Backspace on some keyboards. It is
1470 whatever key you would use to correct a simple typing error when
1471 regularly using Emacs. The @key{DEL} key pops and throws away the
1472 top value on the stack. (You can still get that value back from
1473 the Trail if you should need it later on.) There are many places
1474 in this tutorial where we assume you have used @key{DEL} to erase the
1475 results of the previous example at the beginning of a new example.
1476 In the few places where it is really important to use @key{DEL} to
1477 clear away old results, the text will remind you to do so.
1479 (It won't hurt to let things accumulate on the stack, except that
1480 whenever you give a display-mode-changing command Calc will have to
1481 spend a long time reformatting such a large stack.)
1483 Since the @kbd{-} key is also an operator (it subtracts the top two
1484 stack elements), how does one enter a negative number? Calc uses
1485 the @kbd{_} (underscore) key to act like the minus sign in a number.
1486 So, typing @kbd{-5 @key{RET}} won't work because the @kbd{-} key
1487 will try to do a subtraction, but @kbd{_5 @key{RET}} works just fine.
1489 You can also press @kbd{n}, which means ``change sign.'' It changes
1490 the number at the top of the stack (or the number being entered)
1491 from positive to negative or vice-versa: @kbd{5 n @key{RET}}.
1493 @cindex Duplicating a stack entry
1494 If you press @key{RET} when you're not entering a number, the effect
1495 is to duplicate the top number on the stack. Consider this calculation:
1499 1: 3 2: 3 1: 9 2: 9 1: 81
1503 3 @key{RET} @key{RET} * @key{RET} *
1508 (Of course, an easier way to do this would be @kbd{3 @key{RET} 4 ^},
1509 to raise 3 to the fourth power.)
1511 The space-bar key (denoted @key{SPC} here) performs the same function
1512 as @key{RET}; you could replace all three occurrences of @key{RET} in
1513 the above example with @key{SPC} and the effect would be the same.
1515 @cindex Exchanging stack entries
1516 Another stack manipulation key is @key{TAB}. This exchanges the top
1517 two stack entries. Suppose you have computed @kbd{2 @key{RET} 3 +}
1518 to get 5, and then you realize what you really wanted to compute
1519 was @expr{20 / (2+3)}.
1523 1: 5 2: 5 2: 20 1: 4
1527 2 @key{RET} 3 + 20 @key{TAB} /
1532 Planning ahead, the calculation would have gone like this:
1536 1: 20 2: 20 3: 20 2: 20 1: 4
1541 20 @key{RET} 2 @key{RET} 3 + /
1545 A related stack command is @kbd{M-@key{TAB}} (hold @key{META} and type
1546 @key{TAB}). It rotates the top three elements of the stack upward,
1547 bringing the object in level 3 to the top.
1551 1: 10 2: 10 3: 10 3: 20 3: 30
1552 . 1: 20 2: 20 2: 30 2: 10
1556 10 @key{RET} 20 @key{RET} 30 @key{RET} M-@key{TAB} M-@key{TAB}
1560 (@bullet{}) @strong{Exercise 3.} Suppose the numbers 10, 20, and 30 are
1561 on the stack. Figure out how to add one to the number in level 2
1562 without affecting the rest of the stack. Also figure out how to add
1563 one to the number in level 3. @xref{RPN Answer 3, 3}. (@bullet{})
1565 Operations like @kbd{+}, @kbd{-}, @kbd{*}, @kbd{/}, and @kbd{^} pop two
1566 arguments from the stack and push a result. Operations like @kbd{n} and
1567 @kbd{Q} (square root) pop a single number and push the result. You can
1568 think of them as simply operating on the top element of the stack.
1572 1: 3 1: 9 2: 9 1: 25 1: 5
1576 3 @key{RET} @key{RET} * 4 @key{RET} @key{RET} * + Q
1581 (Note that capital @kbd{Q} means to hold down the Shift key while
1582 typing @kbd{q}. Remember, plain unshifted @kbd{q} is the Quit command.)
1584 @cindex Pythagorean Theorem
1585 Here we've used the Pythagorean Theorem to determine the hypotenuse of a
1586 right triangle. Calc actually has a built-in command for that called
1587 @kbd{f h}, but let's suppose we can't remember the necessary keystrokes.
1588 We can still enter it by its full name using @kbd{M-x} notation:
1596 3 @key{RET} 4 @key{RET} M-x calc-hypot
1600 All Calculator commands begin with the word @samp{calc-}. Since it
1601 gets tiring to type this, Calc provides an @kbd{x} key which is just
1602 like the regular Emacs @kbd{M-x} key except that it types the @samp{calc-}
1611 3 @key{RET} 4 @key{RET} x hypot
1615 What happens if you take the square root of a negative number?
1619 1: 4 1: -4 1: (0, 2)
1627 The notation @expr{(a, b)} represents a complex number.
1628 Complex numbers are more traditionally written @expr{a + b i};
1629 Calc can display in this format, too, but for now we'll stick to the
1630 @expr{(a, b)} notation.
1632 If you don't know how complex numbers work, you can safely ignore this
1633 feature. Complex numbers only arise from operations that would be
1634 errors in a calculator that didn't have complex numbers. (For example,
1635 taking the square root or logarithm of a negative number produces a
1638 Complex numbers are entered in the notation shown. The @kbd{(} and
1639 @kbd{,} and @kbd{)} keys manipulate ``incomplete complex numbers.''
1643 1: ( ... 2: ( ... 1: (2, ... 1: (2, ... 1: (2, 3)
1651 You can perform calculations while entering parts of incomplete objects.
1652 However, an incomplete object cannot actually participate in a calculation:
1656 1: ( ... 2: ( ... 3: ( ... 1: ( ... 1: ( ...
1666 Adding 5 to an incomplete object makes no sense, so the last command
1667 produces an error message and leaves the stack the same.
1669 Incomplete objects can't participate in arithmetic, but they can be
1670 moved around by the regular stack commands.
1674 2: 2 3: 2 3: 3 1: ( ... 1: (2, 3)
1675 1: 3 2: 3 2: ( ... 2 .
1679 2 @key{RET} 3 @key{RET} ( M-@key{TAB} M-@key{TAB} )
1684 Note that the @kbd{,} (comma) key did not have to be used here.
1685 When you press @kbd{)} all the stack entries between the incomplete
1686 entry and the top are collected, so there's never really a reason
1687 to use the comma. It's up to you.
1689 (@bullet{}) @strong{Exercise 4.} To enter the complex number @expr{(2, 3)},
1690 your friend Joe typed @kbd{( 2 , @key{SPC} 3 )}. What happened?
1691 (Joe thought of a clever way to correct his mistake in only two
1692 keystrokes, but it didn't quite work. Try it to find out why.)
1693 @xref{RPN Answer 4, 4}. (@bullet{})
1695 Vectors are entered the same way as complex numbers, but with square
1696 brackets in place of parentheses. We'll meet vectors again later in
1699 Any Emacs command can be given a @dfn{numeric prefix argument} by
1700 typing a series of @key{META}-digits beforehand. If @key{META} is
1701 awkward for you, you can instead type @kbd{C-u} followed by the
1702 necessary digits. Numeric prefix arguments can be negative, as in
1703 @kbd{M-- M-3 M-5} or @w{@kbd{C-u - 3 5}}. Calc commands use numeric
1704 prefix arguments in a variety of ways. For example, a numeric prefix
1705 on the @kbd{+} operator adds any number of stack entries at once:
1709 1: 10 2: 10 3: 10 3: 10 1: 60
1710 . 1: 20 2: 20 2: 20 .
1714 10 @key{RET} 20 @key{RET} 30 @key{RET} C-u 3 +
1718 For stack manipulation commands like @key{RET}, a positive numeric
1719 prefix argument operates on the top @var{n} stack entries at once. A
1720 negative argument operates on the entry in level @var{n} only. An
1721 argument of zero operates on the entire stack. In this example, we copy
1722 the second-to-top element of the stack:
1726 1: 10 2: 10 3: 10 3: 10 4: 10
1727 . 1: 20 2: 20 2: 20 3: 20
1732 10 @key{RET} 20 @key{RET} 30 @key{RET} C-u -2 @key{RET}
1736 @cindex Clearing the stack
1737 @cindex Emptying the stack
1738 Another common idiom is @kbd{M-0 @key{DEL}}, which clears the stack.
1739 (The @kbd{M-0} numeric prefix tells @key{DEL} to operate on the
1742 @node Algebraic Tutorial, Undo Tutorial, RPN Tutorial, Basic Tutorial
1743 @subsection Algebraic-Style Calculations
1746 If you are not used to RPN notation, you may prefer to operate the
1747 Calculator in Algebraic mode, which is closer to the way
1748 non-RPN calculators work. In Algebraic mode, you enter formulas
1749 in traditional @expr{2+3} notation.
1751 @strong{Notice:} Calc gives @samp{/} lower precedence than @samp{*}, so
1752 that @samp{a/b*c} is interpreted as @samp{a/(b*c)}; this is not
1753 standard across all computer languages. See below for details.
1755 You don't really need any special ``mode'' to enter algebraic formulas.
1756 You can enter a formula at any time by pressing the apostrophe (@kbd{'})
1757 key. Answer the prompt with the desired formula, then press @key{RET}.
1758 The formula is evaluated and the result is pushed onto the RPN stack.
1759 If you don't want to think in RPN at all, you can enter your whole
1760 computation as a formula, read the result from the stack, then press
1761 @key{DEL} to delete it from the stack.
1763 Try pressing the apostrophe key, then @kbd{2+3+4}, then @key{RET}.
1764 The result should be the number 9.
1766 Algebraic formulas use the operators @samp{+}, @samp{-}, @samp{*},
1767 @samp{/}, and @samp{^}. You can use parentheses to make the order
1768 of evaluation clear. In the absence of parentheses, @samp{^} is
1769 evaluated first, then @samp{*}, then @samp{/}, then finally
1770 @samp{+} and @samp{-}. For example, the expression
1773 2 + 3*4*5 / 6*7^8 - 9
1780 2 + ((3*4*5) / (6*(7^8)) - 9
1784 or, in large mathematical notation,
1798 $$ 2 + { 3 \times 4 \times 5 \over 6 \times 7^8 } - 9 $$
1803 The result of this expression will be the number @mathit{-6.99999826533}.
1805 Calc's order of evaluation is the same as for most computer languages,
1806 except that @samp{*} binds more strongly than @samp{/}, as the above
1807 example shows. As in normal mathematical notation, the @samp{*} symbol
1808 can often be omitted: @samp{2 a} is the same as @samp{2*a}.
1810 Operators at the same level are evaluated from left to right, except
1811 that @samp{^} is evaluated from right to left. Thus, @samp{2-3-4} is
1812 equivalent to @samp{(2-3)-4} or @mathit{-5}, whereas @samp{2^3^4} is equivalent
1813 to @samp{2^(3^4)} (a very large integer; try it!).
1815 If you tire of typing the apostrophe all the time, there is
1816 Algebraic mode, where Calc automatically senses
1817 when you are about to type an algebraic expression. To enter this
1818 mode, press the two letters @w{@kbd{m a}}. (An @samp{Alg} indicator
1819 should appear in the Calc window's mode line.)
1821 Press @kbd{m a}, then @kbd{2+3+4} with no apostrophe, then @key{RET}.
1823 In Algebraic mode, when you press any key that would normally begin
1824 entering a number (such as a digit, a decimal point, or the @kbd{_}
1825 key), or if you press @kbd{(} or @kbd{[}, Calc automatically begins
1828 Functions which do not have operator symbols like @samp{+} and @samp{*}
1829 must be entered in formulas using function-call notation. For example,
1830 the function name corresponding to the square-root key @kbd{Q} is
1831 @code{sqrt}. To compute a square root in a formula, you would use
1832 the notation @samp{sqrt(@var{x})}.
1834 Press the apostrophe, then type @kbd{sqrt(5*2) - 3}. The result should
1835 be @expr{0.16227766017}.
1837 Note that if the formula begins with a function name, you need to use
1838 the apostrophe even if you are in Algebraic mode. If you type @kbd{arcsin}
1839 out of the blue, the @kbd{a r} will be taken as an Algebraic Rewrite
1840 command, and the @kbd{csin} will be taken as the name of the rewrite
1843 Some people prefer to enter complex numbers and vectors in algebraic
1844 form because they find RPN entry with incomplete objects to be too
1845 distracting, even though they otherwise use Calc as an RPN calculator.
1847 Still in Algebraic mode, type:
1851 1: (2, 3) 2: (2, 3) 1: (8, -1) 2: (8, -1) 1: (9, -1)
1852 . 1: (1, -2) . 1: 1 .
1855 (2,3) @key{RET} (1,-2) @key{RET} * 1 @key{RET} +
1859 Algebraic mode allows us to enter complex numbers without pressing
1860 an apostrophe first, but it also means we need to press @key{RET}
1861 after every entry, even for a simple number like @expr{1}.
1863 (You can type @kbd{C-u m a} to enable a special Incomplete Algebraic
1864 mode in which the @kbd{(} and @kbd{[} keys use algebraic entry even
1865 though regular numeric keys still use RPN numeric entry. There is also
1866 Total Algebraic mode, started by typing @kbd{m t}, in which all
1867 normal keys begin algebraic entry. You must then use the @key{META} key
1868 to type Calc commands: @kbd{M-m t} to get back out of Total Algebraic
1869 mode, @kbd{M-q} to quit, etc.)
1871 If you're still in Algebraic mode, press @kbd{m a} again to turn it off.
1873 Actual non-RPN calculators use a mixture of algebraic and RPN styles.
1874 In general, operators of two numbers (like @kbd{+} and @kbd{*})
1875 use algebraic form, but operators of one number (like @kbd{n} and @kbd{Q})
1876 use RPN form. Also, a non-RPN calculator allows you to see the
1877 intermediate results of a calculation as you go along. You can
1878 accomplish this in Calc by performing your calculation as a series
1879 of algebraic entries, using the @kbd{$} sign to tie them together.
1880 In an algebraic formula, @kbd{$} represents the number on the top
1881 of the stack. Here, we perform the calculation
1882 @texline @math{\sqrt{2\times4+1}},
1883 @infoline @expr{sqrt(2*4+1)},
1884 which on a traditional calculator would be done by pressing
1885 @kbd{2 * 4 + 1 =} and then the square-root key.
1892 ' 2*4 @key{RET} $+1 @key{RET} Q
1897 Notice that we didn't need to press an apostrophe for the @kbd{$+1},
1898 because the dollar sign always begins an algebraic entry.
1900 (@bullet{}) @strong{Exercise 1.} How could you get the same effect as
1901 pressing @kbd{Q} but using an algebraic entry instead? How about
1902 if the @kbd{Q} key on your keyboard were broken?
1903 @xref{Algebraic Answer 1, 1}. (@bullet{})
1905 The notations @kbd{$$}, @kbd{$$$}, and so on stand for higher stack
1906 entries. For example, @kbd{' $$+$ @key{RET}} is just like typing @kbd{+}.
1908 Algebraic formulas can include @dfn{variables}. To store in a
1909 variable, press @kbd{s s}, then type the variable name, then press
1910 @key{RET}. (There are actually two flavors of store command:
1911 @kbd{s s} stores a number in a variable but also leaves the number
1912 on the stack, while @w{@kbd{s t}} removes a number from the stack and
1913 stores it in the variable.) A variable name should consist of one
1914 or more letters or digits, beginning with a letter.
1918 1: 17 . 1: a + a^2 1: 306
1921 17 s t a @key{RET} ' a+a^2 @key{RET} =
1926 The @kbd{=} key @dfn{evaluates} a formula by replacing all its
1927 variables by the values that were stored in them.
1929 For RPN calculations, you can recall a variable's value on the
1930 stack either by entering its name as a formula and pressing @kbd{=},
1931 or by using the @kbd{s r} command.
1935 1: 17 2: 17 3: 17 2: 17 1: 306
1936 . 1: 17 2: 17 1: 289 .
1940 s r a @key{RET} ' a @key{RET} = 2 ^ +
1944 If you press a single digit for a variable name (as in @kbd{s t 3}, you
1945 get one of ten @dfn{quick variables} @code{q0} through @code{q9}.
1946 They are ``quick'' simply because you don't have to type the letter
1947 @code{q} or the @key{RET} after their names. In fact, you can type
1948 simply @kbd{s 3} as a shorthand for @kbd{s s 3}, and likewise for
1949 @kbd{t 3} and @w{@kbd{r 3}}.
1951 Any variables in an algebraic formula for which you have not stored
1952 values are left alone, even when you evaluate the formula.
1956 1: 2 a + 2 b 1: 2 b + 34
1963 Calls to function names which are undefined in Calc are also left
1964 alone, as are calls for which the value is undefined.
1968 1: log10(0) + log10(x) + log10(5, 6) + foo(3) + 2
1971 ' log10(100) + log10(0) + log10(x) + log10(5,6) + foo(3) @key{RET}
1976 In this example, the first call to @code{log10} works, but the other
1977 calls are not evaluated. In the second call, the logarithm is
1978 undefined for that value of the argument; in the third, the argument
1979 is symbolic, and in the fourth, there are too many arguments. In the
1980 fifth case, there is no function called @code{foo}. You will see a
1981 ``Wrong number of arguments'' message referring to @samp{log10(5,6)}.
1982 Press the @kbd{w} (``why'') key to see any other messages that may
1983 have arisen from the last calculation. In this case you will get
1984 ``logarithm of zero,'' then ``number expected: @code{x}''. Calc
1985 automatically displays the first message only if the message is
1986 sufficiently important; for example, Calc considers ``wrong number
1987 of arguments'' and ``logarithm of zero'' to be important enough to
1988 report automatically, while a message like ``number expected: @code{x}''
1989 will only show up if you explicitly press the @kbd{w} key.
1991 (@bullet{}) @strong{Exercise 2.} Joe entered the formula @samp{2 x y},
1992 stored 5 in @code{x}, pressed @kbd{=}, and got the expected result,
1993 @samp{10 y}. He then tried the same for the formula @samp{2 x (1+y)},
1994 expecting @samp{10 (1+y)}, but it didn't work. Why not?
1995 @xref{Algebraic Answer 2, 2}. (@bullet{})
1997 (@bullet{}) @strong{Exercise 3.} What result would you expect
1998 @kbd{1 @key{RET} 0 /} to give? What if you then type @kbd{0 *}?
1999 @xref{Algebraic Answer 3, 3}. (@bullet{})
2001 One interesting way to work with variables is to use the
2002 @dfn{evaluates-to} (@samp{=>}) operator. It works like this:
2003 Enter a formula algebraically in the usual way, but follow
2004 the formula with an @samp{=>} symbol. (There is also an @kbd{s =}
2005 command which builds an @samp{=>} formula using the stack.) On
2006 the stack, you will see two copies of the formula with an @samp{=>}
2007 between them. The lefthand formula is exactly like you typed it;
2008 the righthand formula has been evaluated as if by typing @kbd{=}.
2012 2: 2 + 3 => 5 2: 2 + 3 => 5
2013 1: 2 a + 2 b => 34 + 2 b 1: 2 a + 2 b => 20 + 2 b
2016 ' 2+3 => @key{RET} ' 2a+2b @key{RET} s = 10 s t a @key{RET}
2021 Notice that the instant we stored a new value in @code{a}, all
2022 @samp{=>} operators already on the stack that referred to @expr{a}
2023 were updated to use the new value. With @samp{=>}, you can push a
2024 set of formulas on the stack, then change the variables experimentally
2025 to see the effects on the formulas' values.
2027 You can also ``unstore'' a variable when you are through with it:
2032 1: 2 a + 2 b => 2 a + 2 b
2039 We will encounter formulas involving variables and functions again
2040 when we discuss the algebra and calculus features of the Calculator.
2042 @node Undo Tutorial, Modes Tutorial, Algebraic Tutorial, Basic Tutorial
2043 @subsection Undo and Redo
2046 If you make a mistake, you can usually correct it by pressing shift-@kbd{U},
2047 the ``undo'' command. First, clear the stack (@kbd{M-0 @key{DEL}}) and exit
2048 and restart Calc (@kbd{C-x * * C-x * *}) to make sure things start off
2049 with a clean slate. Now:
2053 1: 2 2: 2 1: 8 2: 2 1: 6
2061 You can undo any number of times. Calc keeps a complete record of
2062 all you have done since you last opened the Calc window. After the
2063 above example, you could type:
2075 You can also type @kbd{D} to ``redo'' a command that you have undone
2080 . 1: 2 2: 2 1: 6 1: 6
2089 It was not possible to redo past the @expr{6}, since that was placed there
2090 by something other than an undo command.
2093 You can think of undo and redo as a sort of ``time machine.'' Press
2094 @kbd{U} to go backward in time, @kbd{D} to go forward. If you go
2095 backward and do something (like @kbd{*}) then, as any science fiction
2096 reader knows, you have changed your future and you cannot go forward
2097 again. Thus, the inability to redo past the @expr{6} even though there
2098 was an earlier undo command.
2100 You can always recall an earlier result using the Trail. We've ignored
2101 the trail so far, but it has been faithfully recording everything we
2102 did since we loaded the Calculator. If the Trail is not displayed,
2103 press @kbd{t d} now to turn it on.
2105 Let's try grabbing an earlier result. The @expr{8} we computed was
2106 undone by a @kbd{U} command, and was lost even to Redo when we pressed
2107 @kbd{*}, but it's still there in the trail. There should be a little
2108 @samp{>} arrow (the @dfn{trail pointer}) resting on the last trail
2109 entry. If there isn't, press @kbd{t ]} to reset the trail pointer.
2110 Now, press @w{@kbd{t p}} to move the arrow onto the line containing
2111 @expr{8}, and press @w{@kbd{t y}} to ``yank'' that number back onto the
2114 If you press @kbd{t ]} again, you will see that even our Yank command
2115 went into the trail.
2117 Let's go further back in time. Earlier in the tutorial we computed
2118 a huge integer using the formula @samp{2^3^4}. We don't remember
2119 what it was, but the first digits were ``241''. Press @kbd{t r}
2120 (which stands for trail-search-reverse), then type @kbd{241}.
2121 The trail cursor will jump back to the next previous occurrence of
2122 the string ``241'' in the trail. This is just a regular Emacs
2123 incremental search; you can now press @kbd{C-s} or @kbd{C-r} to
2124 continue the search forwards or backwards as you like.
2126 To finish the search, press @key{RET}. This halts the incremental
2127 search and leaves the trail pointer at the thing we found. Now we
2128 can type @kbd{t y} to yank that number onto the stack. If we hadn't
2129 remembered the ``241'', we could simply have searched for @kbd{2^3^4},
2130 then pressed @kbd{@key{RET} t n} to halt and then move to the next item.
2132 You may have noticed that all the trail-related commands begin with
2133 the letter @kbd{t}. (The store-and-recall commands, on the other hand,
2134 all began with @kbd{s}.) Calc has so many commands that there aren't
2135 enough keys for all of them, so various commands are grouped into
2136 two-letter sequences where the first letter is called the @dfn{prefix}
2137 key. If you type a prefix key by accident, you can press @kbd{C-g}
2138 to cancel it. (In fact, you can press @kbd{C-g} to cancel almost
2139 anything in Emacs.) To get help on a prefix key, press that key
2140 followed by @kbd{?}. Some prefixes have several lines of help,
2141 so you need to press @kbd{?} repeatedly to see them all.
2142 You can also type @kbd{h h} to see all the help at once.
2144 Try pressing @kbd{t ?} now. You will see a line of the form,
2147 trail/time: Display; Fwd, Back; Next, Prev, Here, [, ]; Yank: [MORE] t-
2151 The word ``trail'' indicates that the @kbd{t} prefix key contains
2152 trail-related commands. Each entry on the line shows one command,
2153 with a single capital letter showing which letter you press to get
2154 that command. We have used @kbd{t n}, @kbd{t p}, @kbd{t ]}, and
2155 @kbd{t y} so far. The @samp{[MORE]} means you can press @kbd{?}
2156 again to see more @kbd{t}-prefix commands. Notice that the commands
2157 are roughly divided (by semicolons) into related groups.
2159 When you are in the help display for a prefix key, the prefix is
2160 still active. If you press another key, like @kbd{y} for example,
2161 it will be interpreted as a @kbd{t y} command. If all you wanted
2162 was to look at the help messages, press @kbd{C-g} afterwards to cancel
2165 One more way to correct an error is by editing the stack entries.
2166 The actual Stack buffer is marked read-only and must not be edited
2167 directly, but you can press @kbd{`} (the backquote or accent grave)
2168 to edit a stack entry.
2170 Try entering @samp{3.141439} now. If this is supposed to represent
2171 @cpi{}, it's got several errors. Press @kbd{`} to edit this number.
2172 Now use the normal Emacs cursor motion and editing keys to change
2173 the second 4 to a 5, and to transpose the 3 and the 9. When you
2174 press @key{RET}, the number on the stack will be replaced by your
2175 new number. This works for formulas, vectors, and all other types
2176 of values you can put on the stack. The @kbd{`} key also works
2177 during entry of a number or algebraic formula.
2179 @node Modes Tutorial, , Undo Tutorial, Basic Tutorial
2180 @subsection Mode-Setting Commands
2183 Calc has many types of @dfn{modes} that affect the way it interprets
2184 your commands or the way it displays data. We have already seen one
2185 mode, namely Algebraic mode. There are many others, too; we'll
2186 try some of the most common ones here.
2188 Perhaps the most fundamental mode in Calc is the current @dfn{precision}.
2189 Notice the @samp{12} on the Calc window's mode line:
2192 --%*-Calc: 12 Deg (Calculator)----All------
2196 Most of the symbols there are Emacs things you don't need to worry
2197 about, but the @samp{12} and the @samp{Deg} are mode indicators.
2198 The @samp{12} means that calculations should always be carried to
2199 12 significant figures. That is why, when we type @kbd{1 @key{RET} 7 /},
2200 we get @expr{0.142857142857} with exactly 12 digits, not counting
2201 leading and trailing zeros.
2203 You can set the precision to anything you like by pressing @kbd{p},
2204 then entering a suitable number. Try pressing @kbd{p 30 @key{RET}},
2205 then doing @kbd{1 @key{RET} 7 /} again:
2210 2: 0.142857142857142857142857142857
2215 Although the precision can be set arbitrarily high, Calc always
2216 has to have @emph{some} value for the current precision. After
2217 all, the true value @expr{1/7} is an infinitely repeating decimal;
2218 Calc has to stop somewhere.
2220 Of course, calculations are slower the more digits you request.
2221 Press @w{@kbd{p 12}} now to set the precision back down to the default.
2223 Calculations always use the current precision. For example, even
2224 though we have a 30-digit value for @expr{1/7} on the stack, if
2225 we use it in a calculation in 12-digit mode it will be rounded
2226 down to 12 digits before it is used. Try it; press @key{RET} to
2227 duplicate the number, then @w{@kbd{1 +}}. Notice that the @key{RET}
2228 key didn't round the number, because it doesn't do any calculation.
2229 But the instant we pressed @kbd{+}, the number was rounded down.
2234 2: 0.142857142857142857142857142857
2241 In fact, since we added a digit on the left, we had to lose one
2242 digit on the right from even the 12-digit value of @expr{1/7}.
2244 How did we get more than 12 digits when we computed @samp{2^3^4}? The
2245 answer is that Calc makes a distinction between @dfn{integers} and
2246 @dfn{floating-point} numbers, or @dfn{floats}. An integer is a number
2247 that does not contain a decimal point. There is no such thing as an
2248 ``infinitely repeating fraction integer,'' so Calc doesn't have to limit
2249 itself. If you asked for @samp{2^10000} (don't try this!), you would
2250 have to wait a long time but you would eventually get an exact answer.
2251 If you ask for @samp{2.^10000}, you will quickly get an answer which is
2252 correct only to 12 places. The decimal point tells Calc that it should
2253 use floating-point arithmetic to get the answer, not exact integer
2256 You can use the @kbd{F} (@code{calc-floor}) command to convert a
2257 floating-point value to an integer, and @kbd{c f} (@code{calc-float})
2258 to convert an integer to floating-point form.
2260 Let's try entering that last calculation:
2264 1: 2. 2: 2. 1: 1.99506311689e3010
2268 2.0 @key{RET} 10000 @key{RET} ^
2273 @cindex Scientific notation, entry of
2274 Notice the letter @samp{e} in there. It represents ``times ten to the
2275 power of,'' and is used by Calc automatically whenever writing the
2276 number out fully would introduce more extra zeros than you probably
2277 want to see. You can enter numbers in this notation, too.
2281 1: 2. 2: 2. 1: 1.99506311678e3010
2285 2.0 @key{RET} 1e4 @key{RET} ^
2289 @cindex Round-off errors
2291 Hey, the answer is different! Look closely at the middle columns
2292 of the two examples. In the first, the stack contained the
2293 exact integer @expr{10000}, but in the second it contained
2294 a floating-point value with a decimal point. When you raise a
2295 number to an integer power, Calc uses repeated squaring and
2296 multiplication to get the answer. When you use a floating-point
2297 power, Calc uses logarithms and exponentials. As you can see,
2298 a slight error crept in during one of these methods. Which
2299 one should we trust? Let's raise the precision a bit and find
2304 . 1: 2. 2: 2. 1: 1.995063116880828e3010
2308 p 16 @key{RET} 2. @key{RET} 1e4 ^ p 12 @key{RET}
2313 @cindex Guard digits
2314 Presumably, it doesn't matter whether we do this higher-precision
2315 calculation using an integer or floating-point power, since we
2316 have added enough ``guard digits'' to trust the first 12 digits
2317 no matter what. And the verdict is@dots{} Integer powers were more
2318 accurate; in fact, the result was only off by one unit in the
2321 @cindex Guard digits
2322 Calc does many of its internal calculations to a slightly higher
2323 precision, but it doesn't always bump the precision up enough.
2324 In each case, Calc added about two digits of precision during
2325 its calculation and then rounded back down to 12 digits
2326 afterward. In one case, it was enough; in the other, it
2327 wasn't. If you really need @var{x} digits of precision, it
2328 never hurts to do the calculation with a few extra guard digits.
2330 What if we want guard digits but don't want to look at them?
2331 We can set the @dfn{float format}. Calc supports four major
2332 formats for floating-point numbers, called @dfn{normal},
2333 @dfn{fixed-point}, @dfn{scientific notation}, and @dfn{engineering
2334 notation}. You get them by pressing @w{@kbd{d n}}, @kbd{d f},
2335 @kbd{d s}, and @kbd{d e}, respectively. In each case, you can
2336 supply a numeric prefix argument which says how many digits
2337 should be displayed. As an example, let's put a few numbers
2338 onto the stack and try some different display modes. First,
2339 use @kbd{M-0 @key{DEL}} to clear the stack, then enter the four
2344 4: 12345 4: 12345 4: 12345 4: 12345 4: 12345
2345 3: 12345. 3: 12300. 3: 1.2345e4 3: 1.23e4 3: 12345.000
2346 2: 123.45 2: 123. 2: 1.2345e2 2: 1.23e2 2: 123.450
2347 1: 12.345 1: 12.3 1: 1.2345e1 1: 1.23e1 1: 12.345
2350 d n M-3 d n d s M-3 d s M-3 d f
2355 Notice that when we typed @kbd{M-3 d n}, the numbers were rounded down
2356 to three significant digits, but then when we typed @kbd{d s} all
2357 five significant figures reappeared. The float format does not
2358 affect how numbers are stored, it only affects how they are
2359 displayed. Only the current precision governs the actual rounding
2360 of numbers in the Calculator's memory.
2362 Engineering notation, not shown here, is like scientific notation
2363 except the exponent (the power-of-ten part) is always adjusted to be
2364 a multiple of three (as in ``kilo,'' ``micro,'' etc.). As a result
2365 there will be one, two, or three digits before the decimal point.
2367 Whenever you change a display-related mode, Calc redraws everything
2368 in the stack. This may be slow if there are many things on the stack,
2369 so Calc allows you to type shift-@kbd{H} before any mode command to
2370 prevent it from updating the stack. Anything Calc displays after the
2371 mode-changing command will appear in the new format.
2375 4: 12345 4: 12345 4: 12345 4: 12345 4: 12345
2376 3: 12345.000 3: 12345.000 3: 12345.000 3: 1.2345e4 3: 12345.
2377 2: 123.450 2: 123.450 2: 1.2345e1 2: 1.2345e1 2: 123.45
2378 1: 12.345 1: 1.2345e1 1: 1.2345e2 1: 1.2345e2 1: 12.345
2381 H d s @key{DEL} U @key{TAB} d @key{SPC} d n
2386 Here the @kbd{H d s} command changes to scientific notation but without
2387 updating the screen. Deleting the top stack entry and undoing it back
2388 causes it to show up in the new format; swapping the top two stack
2389 entries reformats both entries. The @kbd{d @key{SPC}} command refreshes the
2390 whole stack. The @kbd{d n} command changes back to the normal float
2391 format; since it doesn't have an @kbd{H} prefix, it also updates all
2392 the stack entries to be in @kbd{d n} format.
2394 Notice that the integer @expr{12345} was not affected by any
2395 of the float formats. Integers are integers, and are always
2398 @cindex Large numbers, readability
2399 Large integers have their own problems. Let's look back at
2400 the result of @kbd{2^3^4}.
2403 2417851639229258349412352
2407 Quick---how many digits does this have? Try typing @kbd{d g}:
2410 2,417,851,639,229,258,349,412,352
2414 Now how many digits does this have? It's much easier to tell!
2415 We can actually group digits into clumps of any size. Some
2416 people prefer @kbd{M-5 d g}:
2419 24178,51639,22925,83494,12352
2422 Let's see what happens to floating-point numbers when they are grouped.
2423 First, type @kbd{p 25 @key{RET}} to make sure we have enough precision
2424 to get ourselves into trouble. Now, type @kbd{1e13 /}:
2427 24,17851,63922.9258349412352
2431 The integer part is grouped but the fractional part isn't. Now try
2432 @kbd{M-- M-5 d g} (that's meta-minus-sign, meta-five):
2435 24,17851,63922.92583,49412,352
2438 If you find it hard to tell the decimal point from the commas, try
2439 changing the grouping character to a space with @kbd{d , @key{SPC}}:
2442 24 17851 63922.92583 49412 352
2445 Type @kbd{d , ,} to restore the normal grouping character, then
2446 @kbd{d g} again to turn grouping off. Also, press @kbd{p 12} to
2447 restore the default precision.
2449 Press @kbd{U} enough times to get the original big integer back.
2450 (Notice that @kbd{U} does not undo each mode-setting command; if
2451 you want to undo a mode-setting command, you have to do it yourself.)
2452 Now, type @kbd{d r 16 @key{RET}}:
2455 16#200000000000000000000
2459 The number is now displayed in @dfn{hexadecimal}, or ``base-16'' form.
2460 Suddenly it looks pretty simple; this should be no surprise, since we
2461 got this number by computing a power of two, and 16 is a power of 2.
2462 In fact, we can use @w{@kbd{d r 2 @key{RET}}} to see it in actual binary
2466 2#1000000000000000000000000000000000000000000000000000000 @dots{}
2470 We don't have enough space here to show all the zeros! They won't
2471 fit on a typical screen, either, so you will have to use horizontal
2472 scrolling to see them all. Press @kbd{<} and @kbd{>} to scroll the
2473 stack window left and right by half its width. Another way to view
2474 something large is to press @kbd{`} (back-quote) to edit the top of
2475 stack in a separate window. (Press @kbd{C-c C-c} when you are done.)
2477 You can enter non-decimal numbers using the @kbd{#} symbol, too.
2478 Let's see what the hexadecimal number @samp{5FE} looks like in
2479 binary. Type @kbd{16#5FE} (the letters can be typed in upper or
2480 lower case; they will always appear in upper case). It will also
2481 help to turn grouping on with @kbd{d g}:
2487 Notice that @kbd{d g} groups by fours by default if the display radix
2488 is binary or hexadecimal, but by threes if it is decimal, octal, or any
2491 Now let's see that number in decimal; type @kbd{d r 10}:
2497 Numbers are not @emph{stored} with any particular radix attached. They're
2498 just numbers; they can be entered in any radix, and are always displayed
2499 in whatever radix you've chosen with @kbd{d r}. The current radix applies
2500 to integers, fractions, and floats.
2502 @cindex Roundoff errors, in non-decimal numbers
2503 (@bullet{}) @strong{Exercise 1.} Your friend Joe tried to enter one-third
2504 as @samp{3#0.1} in @kbd{d r 3} mode with a precision of 12. He got
2505 @samp{3#0.0222222...} (with 25 2's) in the display. When he multiplied
2506 that by three, he got @samp{3#0.222222...} instead of the expected
2507 @samp{3#1}. Next, Joe entered @samp{3#0.2} and, to his great relief,
2508 saw @samp{3#0.2} on the screen. But when he typed @kbd{2 /}, he got
2509 @samp{3#0.10000001} (some zeros omitted). What's going on here?
2510 @xref{Modes Answer 1, 1}. (@bullet{})
2512 @cindex Scientific notation, in non-decimal numbers
2513 (@bullet{}) @strong{Exercise 2.} Scientific notation works in non-decimal
2514 modes in the natural way (the exponent is a power of the radix instead of
2515 a power of ten, although the exponent itself is always written in decimal).
2516 Thus @samp{8#1.23e3 = 8#1230.0}. Suppose we have the hexadecimal number
2517 @samp{f.e8f} times 16 to the 15th power: We write @samp{16#f.e8fe15}.
2518 What is wrong with this picture? What could we write instead that would
2519 work better? @xref{Modes Answer 2, 2}. (@bullet{})
2521 The @kbd{m} prefix key has another set of modes, relating to the way
2522 Calc interprets your inputs and does computations. Whereas @kbd{d}-prefix
2523 modes generally affect the way things look, @kbd{m}-prefix modes affect
2524 the way they are actually computed.
2526 The most popular @kbd{m}-prefix mode is the @dfn{angular mode}. Notice
2527 the @samp{Deg} indicator in the mode line. This means that if you use
2528 a command that interprets a number as an angle, it will assume the
2529 angle is measured in degrees. For example,
2533 1: 45 1: 0.707106781187 1: 0.500000000001 1: 0.5
2541 The shift-@kbd{S} command computes the sine of an angle. The sine
2543 @texline @math{\sqrt{2}/2};
2544 @infoline @expr{sqrt(2)/2};
2545 squaring this yields @expr{2/4 = 0.5}. However, there has been a slight
2546 roundoff error because the representation of
2547 @texline @math{\sqrt{2}/2}
2548 @infoline @expr{sqrt(2)/2}
2549 wasn't exact. The @kbd{c 1} command is a handy way to clean up numbers
2550 in this case; it temporarily reduces the precision by one digit while it
2551 re-rounds the number on the top of the stack.
2553 @cindex Roundoff errors, examples
2554 (@bullet{}) @strong{Exercise 3.} Your friend Joe computed the sine
2555 of 45 degrees as shown above, then, hoping to avoid an inexact
2556 result, he increased the precision to 16 digits before squaring.
2557 What happened? @xref{Modes Answer 3, 3}. (@bullet{})
2559 To do this calculation in radians, we would type @kbd{m r} first.
2560 (The indicator changes to @samp{Rad}.) 45 degrees corresponds to
2561 @cpiover{4} radians. To get @cpi{}, press the @kbd{P} key. (Once
2562 again, this is a shifted capital @kbd{P}. Remember, unshifted
2563 @kbd{p} sets the precision.)
2567 1: 3.14159265359 1: 0.785398163398 1: 0.707106781187
2574 Likewise, inverse trigonometric functions generate results in
2575 either radians or degrees, depending on the current angular mode.
2579 1: 0.707106781187 1: 0.785398163398 1: 45.
2582 .5 Q m r I S m d U I S
2587 Here we compute the Inverse Sine of
2588 @texline @math{\sqrt{0.5}},
2589 @infoline @expr{sqrt(0.5)},
2590 first in radians, then in degrees.
2592 Use @kbd{c d} and @kbd{c r} to convert a number from radians to degrees
2597 1: 45 1: 0.785398163397 1: 45.
2604 Another interesting mode is @dfn{Fraction mode}. Normally,
2605 dividing two integers produces a floating-point result if the
2606 quotient can't be expressed as an exact integer. Fraction mode
2607 causes integer division to produce a fraction, i.e., a rational
2612 2: 12 1: 1.33333333333 1: 4:3
2616 12 @key{RET} 9 / m f U / m f
2621 In the first case, we get an approximate floating-point result.
2622 In the second case, we get an exact fractional result (four-thirds).
2624 You can enter a fraction at any time using @kbd{:} notation.
2625 (Calc uses @kbd{:} instead of @kbd{/} as the fraction separator
2626 because @kbd{/} is already used to divide the top two stack
2627 elements.) Calculations involving fractions will always
2628 produce exact fractional results; Fraction mode only says
2629 what to do when dividing two integers.
2631 @cindex Fractions vs. floats
2632 @cindex Floats vs. fractions
2633 (@bullet{}) @strong{Exercise 4.} If fractional arithmetic is exact,
2634 why would you ever use floating-point numbers instead?
2635 @xref{Modes Answer 4, 4}. (@bullet{})
2637 Typing @kbd{m f} doesn't change any existing values in the stack.
2638 In the above example, we had to Undo the division and do it over
2639 again when we changed to Fraction mode. But if you use the
2640 evaluates-to operator you can get commands like @kbd{m f} to
2645 1: 12 / 9 => 1.33333333333 1: 12 / 9 => 1.333 1: 12 / 9 => 4:3
2648 ' 12/9 => @key{RET} p 4 @key{RET} m f
2653 In this example, the righthand side of the @samp{=>} operator
2654 on the stack is recomputed when we change the precision, then
2655 again when we change to Fraction mode. All @samp{=>} expressions
2656 on the stack are recomputed every time you change any mode that
2657 might affect their values.
2659 @node Arithmetic Tutorial, Vector/Matrix Tutorial, Basic Tutorial, Tutorial
2660 @section Arithmetic Tutorial
2663 In this section, we explore the arithmetic and scientific functions
2664 available in the Calculator.
2666 The standard arithmetic commands are @kbd{+}, @kbd{-}, @kbd{*}, @kbd{/},
2667 and @kbd{^}. Each normally takes two numbers from the top of the stack
2668 and pushes back a result. The @kbd{n} and @kbd{&} keys perform
2669 change-sign and reciprocal operations, respectively.
2673 1: 5 1: 0.2 1: 5. 1: -5. 1: 5.
2680 @cindex Binary operators
2681 You can apply a ``binary operator'' like @kbd{+} across any number of
2682 stack entries by giving it a numeric prefix. You can also apply it
2683 pairwise to several stack elements along with the top one if you use
2688 3: 2 1: 9 3: 2 4: 2 3: 12
2689 2: 3 . 2: 3 3: 3 2: 13
2690 1: 4 1: 4 2: 4 1: 14
2694 2 @key{RET} 3 @key{RET} 4 M-3 + U 10 M-- M-3 +
2698 @cindex Unary operators
2699 You can apply a ``unary operator'' like @kbd{&} to the top @var{n}
2700 stack entries with a numeric prefix, too.
2705 2: 3 2: 0.333333333333 2: 3.
2709 2 @key{RET} 3 @key{RET} 4 M-3 & M-2 &
2713 Notice that the results here are left in floating-point form.
2714 We can convert them back to integers by pressing @kbd{F}, the
2715 ``floor'' function. This function rounds down to the next lower
2716 integer. There is also @kbd{R}, which rounds to the nearest
2734 Since dividing-and-flooring (i.e., ``integer quotient'') is such a
2735 common operation, Calc provides a special command for that purpose, the
2736 backslash @kbd{\}. Another common arithmetic operator is @kbd{%}, which
2737 computes the remainder that would arise from a @kbd{\} operation, i.e.,
2738 the ``modulo'' of two numbers. For example,
2742 2: 1234 1: 12 2: 1234 1: 34
2746 1234 @key{RET} 100 \ U %
2750 These commands actually work for any real numbers, not just integers.
2754 2: 3.1415 1: 3 2: 3.1415 1: 0.1415
2758 3.1415 @key{RET} 1 \ U %
2762 (@bullet{}) @strong{Exercise 1.} The @kbd{\} command would appear to be a
2763 frill, since you could always do the same thing with @kbd{/ F}. Think
2764 of a situation where this is not true---@kbd{/ F} would be inadequate.
2765 Now think of a way you could get around the problem if Calc didn't
2766 provide a @kbd{\} command. @xref{Arithmetic Answer 1, 1}. (@bullet{})
2768 We've already seen the @kbd{Q} (square root) and @kbd{S} (sine)
2769 commands. Other commands along those lines are @kbd{C} (cosine),
2770 @kbd{T} (tangent), @kbd{E} (@expr{e^x}) and @kbd{L} (natural
2771 logarithm). These can be modified by the @kbd{I} (inverse) and
2772 @kbd{H} (hyperbolic) prefix keys.
2774 Let's compute the sine and cosine of an angle, and verify the
2776 @texline @math{\sin^2x + \cos^2x = 1}.
2777 @infoline @expr{sin(x)^2 + cos(x)^2 = 1}.
2778 We'll arbitrarily pick @mathit{-64} degrees as a good value for @expr{x}.
2779 With the angular mode set to degrees (type @w{@kbd{m d}}), do:
2783 2: -64 2: -64 2: -0.89879 2: -0.89879 1: 1.
2784 1: -64 1: -0.89879 1: -64 1: 0.43837 .
2787 64 n @key{RET} @key{RET} S @key{TAB} C f h
2792 (For brevity, we're showing only five digits of the results here.
2793 You can of course do these calculations to any precision you like.)
2795 Remember, @kbd{f h} is the @code{calc-hypot}, or square-root of sum
2796 of squares, command.
2799 @texline @math{\displaystyle\tan x = {\sin x \over \cos x}}.
2800 @infoline @expr{tan(x) = sin(x) / cos(x)}.
2804 2: -0.89879 1: -2.0503 1: -64.
2812 A physical interpretation of this calculation is that if you move
2813 @expr{0.89879} units downward and @expr{0.43837} units to the right,
2814 your direction of motion is @mathit{-64} degrees from horizontal. Suppose
2815 we move in the opposite direction, up and to the left:
2819 2: -0.89879 2: 0.89879 1: -2.0503 1: -64.
2820 1: 0.43837 1: -0.43837 . .
2828 How can the angle be the same? The answer is that the @kbd{/} operation
2829 loses information about the signs of its inputs. Because the quotient
2830 is negative, we know exactly one of the inputs was negative, but we
2831 can't tell which one. There is an @kbd{f T} [@code{arctan2}] function which
2832 computes the inverse tangent of the quotient of a pair of numbers.
2833 Since you feed it the two original numbers, it has enough information
2834 to give you a full 360-degree answer.
2838 2: 0.89879 1: 116. 3: 116. 2: 116. 1: 180.
2839 1: -0.43837 . 2: -0.89879 1: -64. .
2843 U U f T M-@key{RET} M-2 n f T -
2848 The resulting angles differ by 180 degrees; in other words, they
2849 point in opposite directions, just as we would expect.
2851 The @key{META}-@key{RET} we used in the third step is the
2852 ``last-arguments'' command. It is sort of like Undo, except that it
2853 restores the arguments of the last command to the stack without removing
2854 the command's result. It is useful in situations like this one,
2855 where we need to do several operations on the same inputs. We could
2856 have accomplished the same thing by using @kbd{M-2 @key{RET}} to duplicate
2857 the top two stack elements right after the @kbd{U U}, then a pair of
2858 @kbd{M-@key{TAB}} commands to cycle the 116 up around the duplicates.
2860 A similar identity is supposed to hold for hyperbolic sines and cosines,
2861 except that it is the @emph{difference}
2862 @texline @math{\cosh^2x - \sinh^2x}
2863 @infoline @expr{cosh(x)^2 - sinh(x)^2}
2864 that always equals one. Let's try to verify this identity.
2868 2: -64 2: -64 2: -64 2: 9.7192e54 2: 9.7192e54
2869 1: -64 1: -3.1175e27 1: 9.7192e54 1: -64 1: 9.7192e54
2872 64 n @key{RET} @key{RET} H C 2 ^ @key{TAB} H S 2 ^
2877 @cindex Roundoff errors, examples
2878 Something's obviously wrong, because when we subtract these numbers
2879 the answer will clearly be zero! But if you think about it, if these
2880 numbers @emph{did} differ by one, it would be in the 55th decimal
2881 place. The difference we seek has been lost entirely to roundoff
2884 We could verify this hypothesis by doing the actual calculation with,
2885 say, 60 decimal places of precision. This will be slow, but not
2886 enormously so. Try it if you wish; sure enough, the answer is
2887 0.99999, reasonably close to 1.
2889 Of course, a more reasonable way to verify the identity is to use
2890 a more reasonable value for @expr{x}!
2892 @cindex Common logarithm
2893 Some Calculator commands use the Hyperbolic prefix for other purposes.
2894 The logarithm and exponential functions, for example, work to the base
2895 @expr{e} normally but use base-10 instead if you use the Hyperbolic
2900 1: 1000 1: 6.9077 1: 1000 1: 3
2908 First, we mistakenly compute a natural logarithm. Then we undo
2909 and compute a common logarithm instead.
2911 The @kbd{B} key computes a general base-@var{b} logarithm for any
2916 2: 1000 1: 3 1: 1000. 2: 1000. 1: 6.9077
2917 1: 10 . . 1: 2.71828 .
2920 1000 @key{RET} 10 B H E H P B
2925 Here we first use @kbd{B} to compute the base-10 logarithm, then use
2926 the ``hyperbolic'' exponential as a cheap hack to recover the number
2927 1000, then use @kbd{B} again to compute the natural logarithm. Note
2928 that @kbd{P} with the hyperbolic prefix pushes the constant @expr{e}
2931 You may have noticed that both times we took the base-10 logarithm
2932 of 1000, we got an exact integer result. Calc always tries to give
2933 an exact rational result for calculations involving rational numbers
2934 where possible. But when we used @kbd{H E}, the result was a
2935 floating-point number for no apparent reason. In fact, if we had
2936 computed @kbd{10 @key{RET} 3 ^} we @emph{would} have gotten an
2937 exact integer 1000. But the @kbd{H E} command is rigged to generate
2938 a floating-point result all of the time so that @kbd{1000 H E} will
2939 not waste time computing a thousand-digit integer when all you
2940 probably wanted was @samp{1e1000}.
2942 (@bullet{}) @strong{Exercise 2.} Find a pair of integer inputs to
2943 the @kbd{B} command for which Calc could find an exact rational
2944 result but doesn't. @xref{Arithmetic Answer 2, 2}. (@bullet{})
2946 The Calculator also has a set of functions relating to combinatorics
2947 and statistics. You may be familiar with the @dfn{factorial} function,
2948 which computes the product of all the integers up to a given number.
2952 1: 100 1: 93326215443... 1: 100. 1: 9.3326e157
2960 Recall, the @kbd{c f} command converts the integer or fraction at the
2961 top of the stack to floating-point format. If you take the factorial
2962 of a floating-point number, you get a floating-point result
2963 accurate to the current precision. But if you give @kbd{!} an
2964 exact integer, you get an exact integer result (158 digits long
2967 If you take the factorial of a non-integer, Calc uses a generalized
2968 factorial function defined in terms of Euler's Gamma function
2969 @texline @math{\Gamma(n)}
2970 @infoline @expr{gamma(n)}
2971 (which is itself available as the @kbd{f g} command).
2975 3: 4. 3: 24. 1: 5.5 1: 52.342777847
2976 2: 4.5 2: 52.3427777847 . .
2980 M-3 ! M-0 @key{DEL} 5.5 f g
2985 Here we verify the identity
2986 @texline @math{n! = \Gamma(n+1)}.
2987 @infoline @expr{@var{n}!@: = gamma(@var{n}+1)}.
2989 The binomial coefficient @var{n}-choose-@var{m}
2990 @texline or @math{\displaystyle {n \choose m}}
2992 @texline @math{\displaystyle {n! \over m! \, (n-m)!}}
2993 @infoline @expr{n!@: / m!@: (n-m)!}
2994 for all reals @expr{n} and @expr{m}. The intermediate results in this
2995 formula can become quite large even if the final result is small; the
2996 @kbd{k c} command computes a binomial coefficient in a way that avoids
2997 large intermediate values.
2999 The @kbd{k} prefix key defines several common functions out of
3000 combinatorics and number theory. Here we compute the binomial
3001 coefficient 30-choose-20, then determine its prime factorization.
3005 2: 30 1: 30045015 1: [3, 3, 5, 7, 11, 13, 23, 29]
3009 30 @key{RET} 20 k c k f
3014 You can verify these prime factors by using @kbd{V R *} to multiply
3015 together the elements of this vector. The result is the original
3019 Suppose a program you are writing needs a hash table with at least
3020 10000 entries. It's best to use a prime number as the actual size
3021 of a hash table. Calc can compute the next prime number after 10000:
3025 1: 10000 1: 10007 1: 9973
3033 Just for kicks we've also computed the next prime @emph{less} than
3036 @c [fix-ref Financial Functions]
3037 @xref{Financial Functions}, for a description of the Calculator
3038 commands that deal with business and financial calculations (functions
3039 like @code{pv}, @code{rate}, and @code{sln}).
3041 @c [fix-ref Binary Number Functions]
3042 @xref{Binary Functions}, to read about the commands for operating
3043 on binary numbers (like @code{and}, @code{xor}, and @code{lsh}).
3045 @node Vector/Matrix Tutorial, Types Tutorial, Arithmetic Tutorial, Tutorial
3046 @section Vector/Matrix Tutorial
3049 A @dfn{vector} is a list of numbers or other Calc data objects.
3050 Calc provides a large set of commands that operate on vectors. Some
3051 are familiar operations from vector analysis. Others simply treat
3052 a vector as a list of objects.
3055 * Vector Analysis Tutorial::
3060 @node Vector Analysis Tutorial, Matrix Tutorial, Vector/Matrix Tutorial, Vector/Matrix Tutorial
3061 @subsection Vector Analysis
3064 If you add two vectors, the result is a vector of the sums of the
3065 elements, taken pairwise.
3069 1: [1, 2, 3] 2: [1, 2, 3] 1: [8, 8, 3]
3073 [1,2,3] s 1 [7 6 0] s 2 +
3078 Note that we can separate the vector elements with either commas or
3079 spaces. This is true whether we are using incomplete vectors or
3080 algebraic entry. The @kbd{s 1} and @kbd{s 2} commands save these
3081 vectors so we can easily reuse them later.
3083 If you multiply two vectors, the result is the sum of the products
3084 of the elements taken pairwise. This is called the @dfn{dot product}
3098 The dot product of two vectors is equal to the product of their
3099 lengths times the cosine of the angle between them. (Here the vector
3100 is interpreted as a line from the origin @expr{(0,0,0)} to the
3101 specified point in three-dimensional space.) The @kbd{A}
3102 (absolute value) command can be used to compute the length of a
3107 3: 19 3: 19 1: 0.550782 1: 56.579
3108 2: [1, 2, 3] 2: 3.741657 . .
3109 1: [7, 6, 0] 1: 9.219544
3112 M-@key{RET} M-2 A * / I C
3117 First we recall the arguments to the dot product command, then
3118 we compute the absolute values of the top two stack entries to
3119 obtain the lengths of the vectors, then we divide the dot product
3120 by the product of the lengths to get the cosine of the angle.
3121 The inverse cosine finds that the angle between the vectors
3122 is about 56 degrees.
3124 @cindex Cross product
3125 @cindex Perpendicular vectors
3126 The @dfn{cross product} of two vectors is a vector whose length
3127 is the product of the lengths of the inputs times the sine of the
3128 angle between them, and whose direction is perpendicular to both
3129 input vectors. Unlike the dot product, the cross product is
3130 defined only for three-dimensional vectors. Let's double-check
3131 our computation of the angle using the cross product.
3135 2: [1, 2, 3] 3: [-18, 21, -8] 1: [-0.52, 0.61, -0.23] 1: 56.579
3136 1: [7, 6, 0] 2: [1, 2, 3] . .
3140 r 1 r 2 V C s 3 M-@key{RET} M-2 A * / A I S
3145 First we recall the original vectors and compute their cross product,
3146 which we also store for later reference. Now we divide the vector
3147 by the product of the lengths of the original vectors. The length of
3148 this vector should be the sine of the angle; sure enough, it is!
3150 @c [fix-ref General Mode Commands]
3151 Vector-related commands generally begin with the @kbd{v} prefix key.
3152 Some are uppercase letters and some are lowercase. To make it easier
3153 to type these commands, the shift-@kbd{V} prefix key acts the same as
3154 the @kbd{v} key. (@xref{General Mode Commands}, for a way to make all
3155 prefix keys have this property.)
3157 If we take the dot product of two perpendicular vectors we expect
3158 to get zero, since the cosine of 90 degrees is zero. Let's check
3159 that the cross product is indeed perpendicular to both inputs:
3163 2: [1, 2, 3] 1: 0 2: [7, 6, 0] 1: 0
3164 1: [-18, 21, -8] . 1: [-18, 21, -8] .
3167 r 1 r 3 * @key{DEL} r 2 r 3 *
3171 @cindex Normalizing a vector
3172 @cindex Unit vectors
3173 (@bullet{}) @strong{Exercise 1.} Given a vector on the top of the
3174 stack, what keystrokes would you use to @dfn{normalize} the
3175 vector, i.e., to reduce its length to one without changing its
3176 direction? @xref{Vector Answer 1, 1}. (@bullet{})
3178 (@bullet{}) @strong{Exercise 2.} Suppose a certain particle can be
3179 at any of several positions along a ruler. You have a list of
3180 those positions in the form of a vector, and another list of the
3181 probabilities for the particle to be at the corresponding positions.
3182 Find the average position of the particle.
3183 @xref{Vector Answer 2, 2}. (@bullet{})
3185 @node Matrix Tutorial, List Tutorial, Vector Analysis Tutorial, Vector/Matrix Tutorial
3186 @subsection Matrices
3189 A @dfn{matrix} is just a vector of vectors, all the same length.
3190 This means you can enter a matrix using nested brackets. You can
3191 also use the semicolon character to enter a matrix. We'll show
3196 1: [ [ 1, 2, 3 ] 1: [ [ 1, 2, 3 ]
3197 [ 4, 5, 6 ] ] [ 4, 5, 6 ] ]
3200 [[1 2 3] [4 5 6]] ' [1 2 3; 4 5 6] @key{RET}
3205 We'll be using this matrix again, so type @kbd{s 4} to save it now.
3207 Note that semicolons work with incomplete vectors, but they work
3208 better in algebraic entry. That's why we use the apostrophe in
3211 When two matrices are multiplied, the lefthand matrix must have
3212 the same number of columns as the righthand matrix has rows.
3213 Row @expr{i}, column @expr{j} of the result is effectively the
3214 dot product of row @expr{i} of the left matrix by column @expr{j}
3215 of the right matrix.
3217 If we try to duplicate this matrix and multiply it by itself,
3218 the dimensions are wrong and the multiplication cannot take place:
3222 1: [ [ 1, 2, 3 ] * [ [ 1, 2, 3 ]
3223 [ 4, 5, 6 ] ] [ 4, 5, 6 ] ]
3231 Though rather hard to read, this is a formula which shows the product
3232 of two matrices. The @samp{*} function, having invalid arguments, has
3233 been left in symbolic form.
3235 We can multiply the matrices if we @dfn{transpose} one of them first.
3239 2: [ [ 1, 2, 3 ] 1: [ [ 14, 32 ] 1: [ [ 17, 22, 27 ]
3240 [ 4, 5, 6 ] ] [ 32, 77 ] ] [ 22, 29, 36 ]
3241 1: [ [ 1, 4 ] . [ 27, 36, 45 ] ]
3246 U v t * U @key{TAB} *
3250 Matrix multiplication is not commutative; indeed, switching the
3251 order of the operands can even change the dimensions of the result
3252 matrix, as happened here!
3254 If you multiply a plain vector by a matrix, it is treated as a
3255 single row or column depending on which side of the matrix it is
3256 on. The result is a plain vector which should also be interpreted
3257 as a row or column as appropriate.
3261 2: [ [ 1, 2, 3 ] 1: [14, 32]
3270 Multiplying in the other order wouldn't work because the number of
3271 rows in the matrix is different from the number of elements in the
3274 (@bullet{}) @strong{Exercise 1.} Use @samp{*} to sum along the rows
3276 @texline @math{2\times3}
3278 matrix to get @expr{[6, 15]}. Now use @samp{*} to sum along the columns
3279 to get @expr{[5, 7, 9]}.
3280 @xref{Matrix Answer 1, 1}. (@bullet{})
3282 @cindex Identity matrix
3283 An @dfn{identity matrix} is a square matrix with ones along the
3284 diagonal and zeros elsewhere. It has the property that multiplication
3285 by an identity matrix, on the left or on the right, always produces
3286 the original matrix.
3290 1: [ [ 1, 2, 3 ] 2: [ [ 1, 2, 3 ] 1: [ [ 1, 2, 3 ]
3291 [ 4, 5, 6 ] ] [ 4, 5, 6 ] ] [ 4, 5, 6 ] ]
3292 . 1: [ [ 1, 0, 0 ] .
3297 r 4 v i 3 @key{RET} *
3301 If a matrix is square, it is often possible to find its @dfn{inverse},
3302 that is, a matrix which, when multiplied by the original matrix, yields
3303 an identity matrix. The @kbd{&} (reciprocal) key also computes the
3304 inverse of a matrix.
3308 1: [ [ 1, 2, 3 ] 1: [ [ -2.4, 1.2, -0.2 ]
3309 [ 4, 5, 6 ] [ 2.8, -1.4, 0.4 ]
3310 [ 7, 6, 0 ] ] [ -0.73333, 0.53333, -0.2 ] ]
3318 The vertical bar @kbd{|} @dfn{concatenates} numbers, vectors, and
3319 matrices together. Here we have used it to add a new row onto
3320 our matrix to make it square.
3322 We can multiply these two matrices in either order to get an identity.
3326 1: [ [ 1., 0., 0. ] 1: [ [ 1., 0., 0. ]
3327 [ 0., 1., 0. ] [ 0., 1., 0. ]
3328 [ 0., 0., 1. ] ] [ 0., 0., 1. ] ]
3331 M-@key{RET} * U @key{TAB} *
3335 @cindex Systems of linear equations
3336 @cindex Linear equations, systems of
3337 Matrix inverses are related to systems of linear equations in algebra.
3338 Suppose we had the following set of equations:
3351 $$ \openup1\jot \tabskip=0pt plus1fil
3352 \halign to\displaywidth{\tabskip=0pt
3353 $\hfil#$&$\hfil{}#{}$&
3354 $\hfil#$&$\hfil{}#{}$&
3355 $\hfil#$&${}#\hfil$\tabskip=0pt plus1fil\cr
3364 This can be cast into the matrix equation,
3369 [ [ 1, 2, 3 ] [ [ a ] [ [ 6 ]
3370 [ 4, 5, 6 ] * [ b ] = [ 2 ]
3371 [ 7, 6, 0 ] ] [ c ] ] [ 3 ] ]
3377 $$ \pmatrix{ 1 & 2 & 3 \cr 4 & 5 & 6 \cr 7 & 6 & 0 }
3379 \pmatrix{ a \cr b \cr c } = \pmatrix{ 6 \cr 2 \cr 3 }
3384 We can solve this system of equations by multiplying both sides by the
3385 inverse of the matrix. Calc can do this all in one step:
3389 2: [6, 2, 3] 1: [-12.6, 15.2, -3.93333]
3400 The result is the @expr{[a, b, c]} vector that solves the equations.
3401 (Dividing by a square matrix is equivalent to multiplying by its
3404 Let's verify this solution:
3408 2: [ [ 1, 2, 3 ] 1: [6., 2., 3.]
3411 1: [-12.6, 15.2, -3.93333]
3419 Note that we had to be careful about the order in which we multiplied
3420 the matrix and vector. If we multiplied in the other order, Calc would
3421 assume the vector was a row vector in order to make the dimensions
3422 come out right, and the answer would be incorrect. If you
3423 don't feel safe letting Calc take either interpretation of your
3424 vectors, use explicit
3425 @texline @math{N\times1}
3428 @texline @math{1\times N}
3430 matrices instead. In this case, you would enter the original column
3431 vector as @samp{[[6], [2], [3]]} or @samp{[6; 2; 3]}.
3433 (@bullet{}) @strong{Exercise 2.} Algebraic entry allows you to make
3434 vectors and matrices that include variables. Solve the following
3435 system of equations to get expressions for @expr{x} and @expr{y}
3436 in terms of @expr{a} and @expr{b}.
3448 $$ \eqalign{ x &+ a y = 6 \cr
3455 @xref{Matrix Answer 2, 2}. (@bullet{})
3457 @cindex Least-squares for over-determined systems
3458 @cindex Over-determined systems of equations
3459 (@bullet{}) @strong{Exercise 3.} A system of equations is ``over-determined''
3460 if it has more equations than variables. It is often the case that
3461 there are no values for the variables that will satisfy all the
3462 equations at once, but it is still useful to find a set of values
3463 which ``nearly'' satisfy all the equations. In terms of matrix equations,
3464 you can't solve @expr{A X = B} directly because the matrix @expr{A}
3465 is not square for an over-determined system. Matrix inversion works
3466 only for square matrices. One common trick is to multiply both sides
3467 on the left by the transpose of @expr{A}:
3469 @samp{trn(A)*A*X = trn(A)*B}.
3472 $A^T A \, X = A^T B$, where $A^T$ is the transpose \samp{trn(A)}.
3475 @texline @math{A^T A}
3476 @infoline @expr{trn(A)*A}
3477 is a square matrix so a solution is possible. It turns out that the
3478 @expr{X} vector you compute in this way will be a ``least-squares''
3479 solution, which can be regarded as the ``closest'' solution to the set
3480 of equations. Use Calc to solve the following over-determined
3495 $$ \openup1\jot \tabskip=0pt plus1fil
3496 \halign to\displaywidth{\tabskip=0pt
3497 $\hfil#$&$\hfil{}#{}$&
3498 $\hfil#$&$\hfil{}#{}$&
3499 $\hfil#$&${}#\hfil$\tabskip=0pt plus1fil\cr
3503 2a&+&4b&+&6c&=11 \cr}
3509 @xref{Matrix Answer 3, 3}. (@bullet{})
3511 @node List Tutorial, , Matrix Tutorial, Vector/Matrix Tutorial
3512 @subsection Vectors as Lists
3516 Although Calc has a number of features for manipulating vectors and
3517 matrices as mathematical objects, you can also treat vectors as
3518 simple lists of values. For example, we saw that the @kbd{k f}
3519 command returns a vector which is a list of the prime factors of a
3522 You can pack and unpack stack entries into vectors:
3526 3: 10 1: [10, 20, 30] 3: 10
3535 You can also build vectors out of consecutive integers, or out
3536 of many copies of a given value:
3540 1: [1, 2, 3, 4] 2: [1, 2, 3, 4] 2: [1, 2, 3, 4]
3541 . 1: 17 1: [17, 17, 17, 17]
3544 v x 4 @key{RET} 17 v b 4 @key{RET}
3548 You can apply an operator to every element of a vector using the
3553 1: [17, 34, 51, 68] 1: [289, 1156, 2601, 4624] 1: [17, 34, 51, 68]
3561 In the first step, we multiply the vector of integers by the vector
3562 of 17's elementwise. In the second step, we raise each element to
3563 the power two. (The general rule is that both operands must be
3564 vectors of the same length, or else one must be a vector and the
3565 other a plain number.) In the final step, we take the square root
3568 (@bullet{}) @strong{Exercise 1.} Compute a vector of powers of two
3570 @texline @math{2^{-4}}
3571 @infoline @expr{2^-4}
3572 to @expr{2^4}. @xref{List Answer 1, 1}. (@bullet{})
3574 You can also @dfn{reduce} a binary operator across a vector.
3575 For example, reducing @samp{*} computes the product of all the
3576 elements in the vector:
3580 1: 123123 1: [3, 7, 11, 13, 41] 1: 123123
3588 In this example, we decompose 123123 into its prime factors, then
3589 multiply those factors together again to yield the original number.
3591 We could compute a dot product ``by hand'' using mapping and
3596 2: [1, 2, 3] 1: [7, 12, 0] 1: 19
3605 Recalling two vectors from the previous section, we compute the
3606 sum of pairwise products of the elements to get the same answer
3607 for the dot product as before.
3609 A slight variant of vector reduction is the @dfn{accumulate} operation,
3610 @kbd{V U}. This produces a vector of the intermediate results from
3611 a corresponding reduction. Here we compute a table of factorials:
3615 1: [1, 2, 3, 4, 5, 6] 1: [1, 2, 6, 24, 120, 720]
3618 v x 6 @key{RET} V U *
3622 Calc allows vectors to grow as large as you like, although it gets
3623 rather slow if vectors have more than about a hundred elements.
3624 Actually, most of the time is spent formatting these large vectors
3625 for display, not calculating on them. Try the following experiment
3626 (if your computer is very fast you may need to substitute a larger
3631 1: [1, 2, 3, 4, ... 1: [2, 3, 4, 5, ...
3634 v x 500 @key{RET} 1 V M +
3638 Now press @kbd{v .} (the letter @kbd{v}, then a period) and try the
3639 experiment again. In @kbd{v .} mode, long vectors are displayed
3640 ``abbreviated'' like this:
3644 1: [1, 2, 3, ..., 500] 1: [2, 3, 4, ..., 501]
3647 v x 500 @key{RET} 1 V M +
3652 (where now the @samp{...} is actually part of the Calc display).
3653 You will find both operations are now much faster. But notice that
3654 even in @w{@kbd{v .}} mode, the full vectors are still shown in the Trail.
3655 Type @w{@kbd{t .}} to cause the trail to abbreviate as well, and try the
3656 experiment one more time. Operations on long vectors are now quite
3657 fast! (But of course if you use @kbd{t .} you will lose the ability
3658 to get old vectors back using the @kbd{t y} command.)
3660 An easy way to view a full vector when @kbd{v .} mode is active is
3661 to press @kbd{`} (back-quote) to edit the vector; editing always works
3662 with the full, unabbreviated value.
3664 @cindex Least-squares for fitting a straight line
3665 @cindex Fitting data to a line
3666 @cindex Line, fitting data to
3667 @cindex Data, extracting from buffers
3668 @cindex Columns of data, extracting
3669 As a larger example, let's try to fit a straight line to some data,
3670 using the method of least squares. (Calc has a built-in command for
3671 least-squares curve fitting, but we'll do it by hand here just to
3672 practice working with vectors.) Suppose we have the following list
3673 of values in a file we have loaded into Emacs:
3700 If you are reading this tutorial in printed form, you will find it
3701 easiest to press @kbd{C-x * i} to enter the on-line Info version of
3702 the manual and find this table there. (Press @kbd{g}, then type
3703 @kbd{List Tutorial}, to jump straight to this section.)
3705 Position the cursor at the upper-left corner of this table, just
3706 to the left of the @expr{1.34}. Press @kbd{C-@@} to set the mark.
3707 (On your system this may be @kbd{C-2}, @kbd{C-@key{SPC}}, or @kbd{NUL}.)
3708 Now position the cursor to the lower-right, just after the @expr{1.354}.
3709 You have now defined this region as an Emacs ``rectangle.'' Still
3710 in the Info buffer, type @kbd{C-x * r}. This command
3711 (@code{calc-grab-rectangle}) will pop you back into the Calculator, with
3712 the contents of the rectangle you specified in the form of a matrix.
3716 1: [ [ 1.34, 0.234 ]
3723 (You may wish to use @kbd{v .} mode to abbreviate the display of this
3726 We want to treat this as a pair of lists. The first step is to
3727 transpose this matrix into a pair of rows. Remember, a matrix is
3728 just a vector of vectors. So we can unpack the matrix into a pair
3729 of row vectors on the stack.
3733 1: [ [ 1.34, 1.41, 1.49, ... ] 2: [1.34, 1.41, 1.49, ... ]
3734 [ 0.234, 0.298, 0.402, ... ] ] 1: [0.234, 0.298, 0.402, ... ]
3742 Let's store these in quick variables 1 and 2, respectively.
3746 1: [1.34, 1.41, 1.49, ... ] .
3754 (Recall that @kbd{t 2} is a variant of @kbd{s 2} that removes the
3755 stored value from the stack.)
3757 In a least squares fit, the slope @expr{m} is given by the formula
3761 m = (N sum(x y) - sum(x) sum(y)) / (N sum(x^2) - sum(x)^2)
3766 $$ m = {N \sum x y - \sum x \sum y \over
3767 N \sum x^2 - \left( \sum x \right)^2} $$
3773 @texline @math{\sum x}
3774 @infoline @expr{sum(x)}
3775 represents the sum of all the values of @expr{x}. While there is an
3776 actual @code{sum} function in Calc, it's easier to sum a vector using a
3777 simple reduction. First, let's compute the four different sums that
3785 r 1 V R + t 3 r 1 2 V M ^ V R + t 4
3792 1: 13.613 1: 33.36554
3795 r 2 V R + t 5 r 1 r 2 V M * V R + t 6
3801 These are @samp{sum(x)}, @samp{sum(x^2)}, @samp{sum(y)}, and @samp{sum(x y)},
3802 respectively. (We could have used @kbd{*} to compute @samp{sum(x^2)} and
3806 These are $\sum x$, $\sum x^2$, $\sum y$, and $\sum x y$,
3807 respectively. (We could have used \kbd{*} to compute $\sum x^2$ and
3811 Finally, we also need @expr{N}, the number of data points. This is just
3812 the length of either of our lists.
3824 (That's @kbd{v} followed by a lower-case @kbd{l}.)
3826 Now we grind through the formula:
3830 1: 633.94526 2: 633.94526 1: 67.23607
3834 r 7 r 6 * r 3 r 5 * -
3841 2: 67.23607 3: 67.23607 2: 67.23607 1: 0.52141679
3842 1: 1862.0057 2: 1862.0057 1: 128.9488 .
3846 r 7 r 4 * r 3 2 ^ - / t 8
3850 That gives us the slope @expr{m}. The y-intercept @expr{b} can now
3851 be found with the simple formula,
3855 b = (sum(y) - m sum(x)) / N
3860 $$ b = {\sum y - m \sum x \over N} $$
3867 1: 13.613 2: 13.613 1: -8.09358 1: -0.425978
3871 r 5 r 8 r 3 * - r 7 / t 9
3875 Let's ``plot'' this straight line approximation,
3876 @texline @math{y \approx m x + b},
3877 @infoline @expr{m x + b},
3878 and compare it with the original data.
3882 1: [0.699, 0.735, ... ] 1: [0.273, 0.309, ... ]
3890 Notice that multiplying a vector by a constant, and adding a constant
3891 to a vector, can be done without mapping commands since these are
3892 common operations from vector algebra. As far as Calc is concerned,
3893 we've just been doing geometry in 19-dimensional space!
3895 We can subtract this vector from our original @expr{y} vector to get
3896 a feel for the error of our fit. Let's find the maximum error:
3900 1: [0.0387, 0.0112, ... ] 1: [0.0387, 0.0112, ... ] 1: 0.0897
3908 First we compute a vector of differences, then we take the absolute
3909 values of these differences, then we reduce the @code{max} function
3910 across the vector. (The @code{max} function is on the two-key sequence
3911 @kbd{f x}; because it is so common to use @code{max} in a vector
3912 operation, the letters @kbd{X} and @kbd{N} are also accepted for
3913 @code{max} and @code{min} in this context. In general, you answer
3914 the @kbd{V M} or @kbd{V R} prompt with the actual key sequence that
3915 invokes the function you want. You could have typed @kbd{V R f x} or
3916 even @kbd{V R x max @key{RET}} if you had preferred.)
3918 If your system has the GNUPLOT program, you can see graphs of your
3919 data and your straight line to see how well they match. (If you have
3920 GNUPLOT 3.0 or higher, the following instructions will work regardless
3921 of the kind of display you have. Some GNUPLOT 2.0, non-X-windows systems
3922 may require additional steps to view the graphs.)
3924 Let's start by plotting the original data. Recall the ``@var{x}'' and ``@var{y}''
3925 vectors onto the stack and press @kbd{g f}. This ``fast'' graphing
3926 command does everything you need to do for simple, straightforward
3931 2: [1.34, 1.41, 1.49, ... ]
3932 1: [0.234, 0.298, 0.402, ... ]
3939 If all goes well, you will shortly get a new window containing a graph
3940 of the data. (If not, contact your GNUPLOT or Calc installer to find
3941 out what went wrong.) In the X window system, this will be a separate
3942 graphics window. For other kinds of displays, the default is to
3943 display the graph in Emacs itself using rough character graphics.
3944 Press @kbd{q} when you are done viewing the character graphics.
3946 Next, let's add the line we got from our least-squares fit.
3948 (If you are reading this tutorial on-line while running Calc, typing
3949 @kbd{g a} may cause the tutorial to disappear from its window and be
3950 replaced by a buffer named @file{*Gnuplot Commands*}. The tutorial
3951 will reappear when you terminate GNUPLOT by typing @kbd{g q}.)
3956 2: [1.34, 1.41, 1.49, ... ]
3957 1: [0.273, 0.309, 0.351, ... ]
3960 @key{DEL} r 0 g a g p
3964 It's not very useful to get symbols to mark the data points on this
3965 second curve; you can type @kbd{g S g p} to remove them. Type @kbd{g q}
3966 when you are done to remove the X graphics window and terminate GNUPLOT.
3968 (@bullet{}) @strong{Exercise 2.} An earlier exercise showed how to do
3969 least squares fitting to a general system of equations. Our 19 data
3970 points are really 19 equations of the form @expr{y_i = m x_i + b} for
3971 different pairs of @expr{(x_i,y_i)}. Use the matrix-transpose method
3972 to solve for @expr{m} and @expr{b}, duplicating the above result.
3973 @xref{List Answer 2, 2}. (@bullet{})
3975 @cindex Geometric mean
3976 (@bullet{}) @strong{Exercise 3.} If the input data do not form a
3977 rectangle, you can use @w{@kbd{C-x * g}} (@code{calc-grab-region})
3978 to grab the data the way Emacs normally works with regions---it reads
3979 left-to-right, top-to-bottom, treating line breaks the same as spaces.
3980 Use this command to find the geometric mean of the following numbers.
3981 (The geometric mean is the @var{n}th root of the product of @var{n} numbers.)
3990 The @kbd{C-x * g} command accepts numbers separated by spaces or commas,
3991 with or without surrounding vector brackets.
3992 @xref{List Answer 3, 3}. (@bullet{})
3995 As another example, a theorem about binomial coefficients tells
3996 us that the alternating sum of binomial coefficients
3997 @var{n}-choose-0 minus @var{n}-choose-1 plus @var{n}-choose-2, and so
3998 on up to @var{n}-choose-@var{n},
3999 always comes out to zero. Let's verify this
4003 As another example, a theorem about binomial coefficients tells
4004 us that the alternating sum of binomial coefficients
4005 ${n \choose 0} - {n \choose 1} + {n \choose 2} - \cdots \pm {n \choose n}$
4006 always comes out to zero. Let's verify this
4012 1: [1, 2, 3, 4, 5, 6, 7] 1: [0, 1, 2, 3, 4, 5, 6]
4022 1: [1, -6, 15, -20, 15, -6, 1] 1: 0
4025 V M ' (-1)^$ choose(6,$) @key{RET} V R +
4029 The @kbd{V M '} command prompts you to enter any algebraic expression
4030 to define the function to map over the vector. The symbol @samp{$}
4031 inside this expression represents the argument to the function.
4032 The Calculator applies this formula to each element of the vector,
4033 substituting each element's value for the @samp{$} sign(s) in turn.
4035 To define a two-argument function, use @samp{$$} for the first
4036 argument and @samp{$} for the second: @kbd{V M ' $$-$ @key{RET}} is
4037 equivalent to @kbd{V M -}. This is analogous to regular algebraic
4038 entry, where @samp{$$} would refer to the next-to-top stack entry
4039 and @samp{$} would refer to the top stack entry, and @kbd{' $$-$ @key{RET}}
4040 would act exactly like @kbd{-}.
4042 Notice that the @kbd{V M '} command has recorded two things in the
4043 trail: The result, as usual, and also a funny-looking thing marked
4044 @samp{oper} that represents the operator function you typed in.
4045 The function is enclosed in @samp{< >} brackets, and the argument is
4046 denoted by a @samp{#} sign. If there were several arguments, they
4047 would be shown as @samp{#1}, @samp{#2}, and so on. (For example,
4048 @kbd{V M ' $$-$} will put the function @samp{<#1 - #2>} on the
4049 trail.) This object is a ``nameless function''; you can use nameless
4050 @w{@samp{< >}} notation to answer the @kbd{V M '} prompt if you like.
4051 Nameless function notation has the interesting, occasionally useful
4052 property that a nameless function is not actually evaluated until
4053 it is used. For example, @kbd{V M ' $+random(2.0)} evaluates
4054 @samp{random(2.0)} once and adds that random number to all elements
4055 of the vector, but @kbd{V M ' <#+random(2.0)>} evaluates the
4056 @samp{random(2.0)} separately for each vector element.
4058 Another group of operators that are often useful with @kbd{V M} are
4059 the relational operators: @kbd{a =}, for example, compares two numbers
4060 and gives the result 1 if they are equal, or 0 if not. Similarly,
4061 @w{@kbd{a <}} checks for one number being less than another.
4063 Other useful vector operations include @kbd{v v}, to reverse a
4064 vector end-for-end; @kbd{V S}, to sort the elements of a vector
4065 into increasing order; and @kbd{v r} and @w{@kbd{v c}}, to extract
4066 one row or column of a matrix, or (in both cases) to extract one
4067 element of a plain vector. With a negative argument, @kbd{v r}
4068 and @kbd{v c} instead delete one row, column, or vector element.
4070 @cindex Divisor functions
4071 (@bullet{}) @strong{Exercise 4.} The @expr{k}th @dfn{divisor function}
4075 is the sum of the @expr{k}th powers of all the divisors of an
4076 integer @expr{n}. Figure out a method for computing the divisor
4077 function for reasonably small values of @expr{n}. As a test,
4078 the 0th and 1st divisor functions of 30 are 8 and 72, respectively.
4079 @xref{List Answer 4, 4}. (@bullet{})
4081 @cindex Square-free numbers
4082 @cindex Duplicate values in a list
4083 (@bullet{}) @strong{Exercise 5.} The @kbd{k f} command produces a
4084 list of prime factors for a number. Sometimes it is important to
4085 know that a number is @dfn{square-free}, i.e., that no prime occurs
4086 more than once in its list of prime factors. Find a sequence of
4087 keystrokes to tell if a number is square-free; your method should
4088 leave 1 on the stack if it is, or 0 if it isn't.
4089 @xref{List Answer 5, 5}. (@bullet{})
4091 @cindex Triangular lists
4092 (@bullet{}) @strong{Exercise 6.} Build a list of lists that looks
4093 like the following diagram. (You may wish to use the @kbd{v /}
4094 command to enable multi-line display of vectors.)
4103 [1, 2, 3, 4, 5, 6] ]
4108 @xref{List Answer 6, 6}. (@bullet{})
4110 (@bullet{}) @strong{Exercise 7.} Build the following list of lists.
4118 [10, 11, 12, 13, 14],
4119 [15, 16, 17, 18, 19, 20] ]
4124 @xref{List Answer 7, 7}. (@bullet{})
4126 @cindex Maximizing a function over a list of values
4127 @c [fix-ref Numerical Solutions]
4128 (@bullet{}) @strong{Exercise 8.} Compute a list of values of Bessel's
4129 @texline @math{J_1(x)}
4131 function @samp{besJ(1,x)} for @expr{x} from 0 to 5 in steps of 0.25.
4132 Find the value of @expr{x} (from among the above set of values) for
4133 which @samp{besJ(1,x)} is a maximum. Use an ``automatic'' method,
4134 i.e., just reading along the list by hand to find the largest value
4135 is not allowed! (There is an @kbd{a X} command which does this kind
4136 of thing automatically; @pxref{Numerical Solutions}.)
4137 @xref{List Answer 8, 8}. (@bullet{})
4139 @cindex Digits, vectors of
4140 (@bullet{}) @strong{Exercise 9.} You are given an integer in the range
4141 @texline @math{0 \le N < 10^m}
4142 @infoline @expr{0 <= N < 10^m}
4143 for @expr{m=12} (i.e., an integer of less than
4144 twelve digits). Convert this integer into a vector of @expr{m}
4145 digits, each in the range from 0 to 9. In vector-of-digits notation,
4146 add one to this integer to produce a vector of @expr{m+1} digits
4147 (since there could be a carry out of the most significant digit).
4148 Convert this vector back into a regular integer. A good integer
4149 to try is 25129925999. @xref{List Answer 9, 9}. (@bullet{})
4151 (@bullet{}) @strong{Exercise 10.} Your friend Joe tried to use
4152 @kbd{V R a =} to test if all numbers in a list were equal. What
4153 happened? How would you do this test? @xref{List Answer 10, 10}. (@bullet{})
4155 (@bullet{}) @strong{Exercise 11.} The area of a circle of radius one
4156 is @cpi{}. The area of the
4157 @texline @math{2\times2}
4159 square that encloses that circle is 4. So if we throw @var{n} darts at
4160 random points in the square, about @cpiover{4} of them will land inside
4161 the circle. This gives us an entertaining way to estimate the value of
4162 @cpi{}. The @w{@kbd{k r}}
4163 command picks a random number between zero and the value on the stack.
4164 We could get a random floating-point number between @mathit{-1} and 1 by typing
4165 @w{@kbd{2.0 k r 1 -}}. Build a vector of 100 random @expr{(x,y)} points in
4166 this square, then use vector mapping and reduction to count how many
4167 points lie inside the unit circle. Hint: Use the @kbd{v b} command.
4168 @xref{List Answer 11, 11}. (@bullet{})
4170 @cindex Matchstick problem
4171 (@bullet{}) @strong{Exercise 12.} The @dfn{matchstick problem} provides
4172 another way to calculate @cpi{}. Say you have an infinite field
4173 of vertical lines with a spacing of one inch. Toss a one-inch matchstick
4174 onto the field. The probability that the matchstick will land crossing
4175 a line turns out to be
4176 @texline @math{2/\pi}.
4177 @infoline @expr{2/pi}.
4178 Toss 100 matchsticks to estimate @cpi{}. (If you want still more fun,
4179 the probability that the GCD (@w{@kbd{k g}}) of two large integers is
4181 @texline @math{6/\pi^2}.
4182 @infoline @expr{6/pi^2}.
4183 That provides yet another way to estimate @cpi{}.)
4184 @xref{List Answer 12, 12}. (@bullet{})
4186 (@bullet{}) @strong{Exercise 13.} An algebraic entry of a string in
4187 double-quote marks, @samp{"hello"}, creates a vector of the numerical
4188 (ASCII) codes of the characters (here, @expr{[104, 101, 108, 108, 111]}).
4189 Sometimes it is convenient to compute a @dfn{hash code} of a string,
4190 which is just an integer that represents the value of that string.
4191 Two equal strings have the same hash code; two different strings
4192 @dfn{probably} have different hash codes. (For example, Calc has
4193 over 400 function names, but Emacs can quickly find the definition for
4194 any given name because it has sorted the functions into ``buckets'' by
4195 their hash codes. Sometimes a few names will hash into the same bucket,
4196 but it is easier to search among a few names than among all the names.)
4197 One popular hash function is computed as follows: First set @expr{h = 0}.
4198 Then, for each character from the string in turn, set @expr{h = 3h + c_i}
4199 where @expr{c_i} is the character's ASCII code. If we have 511 buckets,
4200 we then take the hash code modulo 511 to get the bucket number. Develop a
4201 simple command or commands for converting string vectors into hash codes.
4202 The hash code for @samp{"Testing, 1, 2, 3"} is 1960915098, which modulo
4203 511 is 121. @xref{List Answer 13, 13}. (@bullet{})
4205 (@bullet{}) @strong{Exercise 14.} The @kbd{H V R} and @kbd{H V U}
4206 commands do nested function evaluations. @kbd{H V U} takes a starting
4207 value and a number of steps @var{n} from the stack; it then applies the
4208 function you give to the starting value 0, 1, 2, up to @var{n} times
4209 and returns a vector of the results. Use this command to create a
4210 ``random walk'' of 50 steps. Start with the two-dimensional point
4211 @expr{(0,0)}; then take one step a random distance between @mathit{-1} and 1
4212 in both @expr{x} and @expr{y}; then take another step, and so on. Use the
4213 @kbd{g f} command to display this random walk. Now modify your random
4214 walk to walk a unit distance, but in a random direction, at each step.
4215 (Hint: The @code{sincos} function returns a vector of the cosine and
4216 sine of an angle.) @xref{List Answer 14, 14}. (@bullet{})
4218 @node Types Tutorial, Algebra Tutorial, Vector/Matrix Tutorial, Tutorial
4219 @section Types Tutorial
4222 Calc understands a variety of data types as well as simple numbers.
4223 In this section, we'll experiment with each of these types in turn.
4225 The numbers we've been using so far have mainly been either @dfn{integers}
4226 or @dfn{floats}. We saw that floats are usually a good approximation to
4227 the mathematical concept of real numbers, but they are only approximations
4228 and are susceptible to roundoff error. Calc also supports @dfn{fractions},
4229 which can exactly represent any rational number.
4233 1: 3628800 2: 3628800 1: 518400:7 1: 518414:7 1: 7:518414
4237 10 ! 49 @key{RET} : 2 + &
4242 The @kbd{:} command divides two integers to get a fraction; @kbd{/}
4243 would normally divide integers to get a floating-point result.
4244 Notice we had to type @key{RET} between the @kbd{49} and the @kbd{:}
4245 since the @kbd{:} would otherwise be interpreted as part of a
4246 fraction beginning with 49.
4248 You can convert between floating-point and fractional format using
4249 @kbd{c f} and @kbd{c F}:
4253 1: 1.35027217629e-5 1: 7:518414
4260 The @kbd{c F} command replaces a floating-point number with the
4261 ``simplest'' fraction whose floating-point representation is the
4262 same, to within the current precision.
4266 1: 3.14159265359 1: 1146408:364913 1: 3.1416 1: 355:113
4269 P c F @key{DEL} p 5 @key{RET} P c F
4273 (@bullet{}) @strong{Exercise 1.} A calculation has produced the
4274 result 1.26508260337. You suspect it is the square root of the
4275 product of @cpi{} and some rational number. Is it? (Be sure
4276 to allow for roundoff error!) @xref{Types Answer 1, 1}. (@bullet{})
4278 @dfn{Complex numbers} can be stored in both rectangular and polar form.
4282 1: -9 1: (0, 3) 1: (3; 90.) 1: (6; 90.) 1: (2.4495; 45.)
4290 The square root of @mathit{-9} is by default rendered in rectangular form
4291 (@w{@expr{0 + 3i}}), but we can convert it to polar form (3 with a
4292 phase angle of 90 degrees). All the usual arithmetic and scientific
4293 operations are defined on both types of complex numbers.
4295 Another generalized kind of number is @dfn{infinity}. Infinity
4296 isn't really a number, but it can sometimes be treated like one.
4297 Calc uses the symbol @code{inf} to represent positive infinity,
4298 i.e., a value greater than any real number. Naturally, you can
4299 also write @samp{-inf} for minus infinity, a value less than any
4300 real number. The word @code{inf} can only be input using
4305 2: inf 2: -inf 2: -inf 2: -inf 1: nan
4306 1: -17 1: -inf 1: -inf 1: inf .
4309 ' inf @key{RET} 17 n * @key{RET} 72 + A +
4314 Since infinity is infinitely large, multiplying it by any finite
4315 number (like @mathit{-17}) has no effect, except that since @mathit{-17}
4316 is negative, it changes a plus infinity to a minus infinity.
4317 (``A huge positive number, multiplied by @mathit{-17}, yields a huge
4318 negative number.'') Adding any finite number to infinity also
4319 leaves it unchanged. Taking an absolute value gives us plus
4320 infinity again. Finally, we add this plus infinity to the minus
4321 infinity we had earlier. If you work it out, you might expect
4322 the answer to be @mathit{-72} for this. But the 72 has been completely
4323 lost next to the infinities; by the time we compute @w{@samp{inf - inf}}
4324 the finite difference between them, if any, is undetectable.
4325 So we say the result is @dfn{indeterminate}, which Calc writes
4326 with the symbol @code{nan} (for Not A Number).
4328 Dividing by zero is normally treated as an error, but you can get
4329 Calc to write an answer in terms of infinity by pressing @kbd{m i}
4330 to turn on Infinite mode.
4334 3: nan 2: nan 2: nan 2: nan 1: nan
4335 2: 1 1: 1 / 0 1: uinf 1: uinf .
4339 1 @key{RET} 0 / m i U / 17 n * +
4344 Dividing by zero normally is left unevaluated, but after @kbd{m i}
4345 it instead gives an infinite result. The answer is actually
4346 @code{uinf}, ``undirected infinity.'' If you look at a graph of
4347 @expr{1 / x} around @w{@expr{x = 0}}, you'll see that it goes toward
4348 plus infinity as you approach zero from above, but toward minus
4349 infinity as you approach from below. Since we said only @expr{1 / 0},
4350 Calc knows that the answer is infinite but not in which direction.
4351 That's what @code{uinf} means. Notice that multiplying @code{uinf}
4352 by a negative number still leaves plain @code{uinf}; there's no
4353 point in saying @samp{-uinf} because the sign of @code{uinf} is
4354 unknown anyway. Finally, we add @code{uinf} to our @code{nan},
4355 yielding @code{nan} again. It's easy to see that, because
4356 @code{nan} means ``totally unknown'' while @code{uinf} means
4357 ``unknown sign but known to be infinite,'' the more mysterious
4358 @code{nan} wins out when it is combined with @code{uinf}, or, for
4359 that matter, with anything else.
4361 (@bullet{}) @strong{Exercise 2.} Predict what Calc will answer
4362 for each of these formulas: @samp{inf / inf}, @samp{exp(inf)},
4363 @samp{exp(-inf)}, @samp{sqrt(-inf)}, @samp{sqrt(uinf)},
4364 @samp{abs(uinf)}, @samp{ln(0)}.
4365 @xref{Types Answer 2, 2}. (@bullet{})
4367 (@bullet{}) @strong{Exercise 3.} We saw that @samp{inf - inf = nan},
4368 which stands for an unknown value. Can @code{nan} stand for
4369 a complex number? Can it stand for infinity?
4370 @xref{Types Answer 3, 3}. (@bullet{})
4372 @dfn{HMS forms} represent a value in terms of hours, minutes, and
4377 1: 2@@ 30' 0" 1: 3@@ 30' 0" 2: 3@@ 30' 0" 1: 2.
4378 . . 1: 1@@ 45' 0." .
4381 2@@ 30' @key{RET} 1 + @key{RET} 2 / /
4385 HMS forms can also be used to hold angles in degrees, minutes, and
4390 1: 0.5 1: 26.56505 1: 26@@ 33' 54.18" 1: 0.44721
4398 First we convert the inverse tangent of 0.5 to degrees-minutes-seconds
4399 form, then we take the sine of that angle. Note that the trigonometric
4400 functions will accept HMS forms directly as input.
4403 (@bullet{}) @strong{Exercise 4.} The Beatles' @emph{Abbey Road} is
4404 47 minutes and 26 seconds long, and contains 17 songs. What is the
4405 average length of a song on @emph{Abbey Road}? If the Extended Disco
4406 Version of @emph{Abbey Road} added 20 seconds to the length of each
4407 song, how long would the album be? @xref{Types Answer 4, 4}. (@bullet{})
4409 A @dfn{date form} represents a date, or a date and time. Dates must
4410 be entered using algebraic entry. Date forms are surrounded by
4411 @samp{< >} symbols; most standard formats for dates are recognized.
4415 2: <Sun Jan 13, 1991> 1: 2.25
4416 1: <6:00pm Thu Jan 10, 1991> .
4419 ' <13 Jan 1991>, <1/10/91, 6pm> @key{RET} -
4424 In this example, we enter two dates, then subtract to find the
4425 number of days between them. It is also possible to add an
4426 HMS form or a number (of days) to a date form to get another
4431 1: <4:45:59pm Mon Jan 14, 1991> 1: <2:50:59am Thu Jan 17, 1991>
4438 @c [fix-ref Date Arithmetic]
4440 The @kbd{t N} (``now'') command pushes the current date and time on the
4441 stack; then we add two days, ten hours and five minutes to the date and
4442 time. Other date-and-time related commands include @kbd{t J}, which
4443 does Julian day conversions, @kbd{t W}, which finds the beginning of
4444 the week in which a date form lies, and @kbd{t I}, which increments a
4445 date by one or several months. @xref{Date Arithmetic}, for more.
4447 (@bullet{}) @strong{Exercise 5.} How many days until the next
4448 Friday the 13th? @xref{Types Answer 5, 5}. (@bullet{})
4450 (@bullet{}) @strong{Exercise 6.} How many leap years will there be
4451 between now and the year 10001 AD@? @xref{Types Answer 6, 6}. (@bullet{})
4453 @cindex Slope and angle of a line
4454 @cindex Angle and slope of a line
4455 An @dfn{error form} represents a mean value with an attached standard
4456 deviation, or error estimate. Suppose our measurements indicate that
4457 a certain telephone pole is about 30 meters away, with an estimated
4458 error of 1 meter, and 8 meters tall, with an estimated error of 0.2
4459 meters. What is the slope of a line from here to the top of the
4460 pole, and what is the equivalent angle in degrees?
4464 1: 8 +/- 0.2 2: 8 +/- 0.2 1: 0.266 +/- 0.011 1: 14.93 +/- 0.594
4468 8 p .2 @key{RET} 30 p 1 / I T
4473 This means that the angle is about 15 degrees, and, assuming our
4474 original error estimates were valid standard deviations, there is about
4475 a 60% chance that the result is correct within 0.59 degrees.
4477 @cindex Torus, volume of
4478 (@bullet{}) @strong{Exercise 7.} The volume of a torus (a donut shape) is
4479 @texline @math{2 \pi^2 R r^2}
4480 @infoline @w{@expr{2 pi^2 R r^2}}
4481 where @expr{R} is the radius of the circle that
4482 defines the center of the tube and @expr{r} is the radius of the tube
4483 itself. Suppose @expr{R} is 20 cm and @expr{r} is 4 cm, each known to
4484 within 5 percent. What is the volume and the relative uncertainty of
4485 the volume? @xref{Types Answer 7, 7}. (@bullet{})
4487 An @dfn{interval form} represents a range of values. While an
4488 error form is best for making statistical estimates, intervals give
4489 you exact bounds on an answer. Suppose we additionally know that
4490 our telephone pole is definitely between 28 and 31 meters away,
4491 and that it is between 7.7 and 8.1 meters tall.
4495 1: [7.7 .. 8.1] 2: [7.7 .. 8.1] 1: [0.24 .. 0.28] 1: [13.9 .. 16.1]
4499 [ 7.7 .. 8.1 ] [ 28 .. 31 ] / I T
4504 If our bounds were correct, then the angle to the top of the pole
4505 is sure to lie in the range shown.
4507 The square brackets around these intervals indicate that the endpoints
4508 themselves are allowable values. In other words, the distance to the
4509 telephone pole is between 28 and 31, @emph{inclusive}. You can also
4510 make an interval that is exclusive of its endpoints by writing
4511 parentheses instead of square brackets. You can even make an interval
4512 which is inclusive (``closed'') on one end and exclusive (``open'') on
4517 1: [1 .. 10) 1: (0.1 .. 1] 2: (0.1 .. 1] 1: (0.2 .. 3)
4521 [ 1 .. 10 ) & [ 2 .. 3 ) *
4526 The Calculator automatically keeps track of which end values should
4527 be open and which should be closed. You can also make infinite or
4528 semi-infinite intervals by using @samp{-inf} or @samp{inf} for one
4531 (@bullet{}) @strong{Exercise 8.} What answer would you expect from
4532 @samp{@w{1 /} @w{(0 .. 10)}}? What about @samp{@w{1 /} @w{(-10 .. 0)}}? What
4533 about @samp{@w{1 /} @w{[0 .. 10]}} (where the interval actually includes
4534 zero)? What about @samp{@w{1 /} @w{(-10 .. 10)}}?
4535 @xref{Types Answer 8, 8}. (@bullet{})
4537 (@bullet{}) @strong{Exercise 9.} Two easy ways of squaring a number
4538 are @kbd{@key{RET} *} and @w{@kbd{2 ^}}. Normally these produce the same
4539 answer. Would you expect this still to hold true for interval forms?
4540 If not, which of these will result in a larger interval?
4541 @xref{Types Answer 9, 9}. (@bullet{})
4543 A @dfn{modulo form} is used for performing arithmetic modulo @var{m}.
4544 For example, arithmetic involving time is generally done modulo 12
4549 1: 17 mod 24 1: 3 mod 24 1: 21 mod 24 1: 9 mod 24
4552 17 M 24 @key{RET} 10 + n 5 /
4557 In this last step, Calc has divided by 5 modulo 24; i.e., it has found a
4558 new number which, when multiplied by 5 modulo 24, produces the original
4559 number, 21. If @var{m} is prime and the divisor is not a multiple of
4560 @var{m}, it is always possible to find such a number. For non-prime
4561 @var{m} like 24, it is only sometimes possible.
4565 1: 10 mod 24 1: 16 mod 24 1: 1000000... 1: 16
4568 10 M 24 @key{RET} 100 ^ 10 @key{RET} 100 ^ 24 %
4573 These two calculations get the same answer, but the first one is
4574 much more efficient because it avoids the huge intermediate value
4575 that arises in the second one.
4577 @cindex Fermat, primality test of
4578 (@bullet{}) @strong{Exercise 10.} A theorem of Pierre de Fermat
4580 @texline @math{x^{n-1} \bmod n = 1}
4581 @infoline @expr{x^(n-1) mod n = 1}
4582 if @expr{n} is a prime number and @expr{x} is an integer less than
4583 @expr{n}. If @expr{n} is @emph{not} a prime number, this will
4584 @emph{not} be true for most values of @expr{x}. Thus we can test
4585 informally if a number is prime by trying this formula for several
4586 values of @expr{x}. Use this test to tell whether the following numbers
4587 are prime: 811749613, 15485863. @xref{Types Answer 10, 10}. (@bullet{})
4589 It is possible to use HMS forms as parts of error forms, intervals,
4590 modulo forms, or as the phase part of a polar complex number.
4591 For example, the @code{calc-time} command pushes the current time
4592 of day on the stack as an HMS/modulo form.
4596 1: 17@@ 34' 45" mod 24@@ 0' 0" 1: 6@@ 22' 15" mod 24@@ 0' 0"
4604 This calculation tells me it is six hours and 22 minutes until midnight.
4606 (@bullet{}) @strong{Exercise 11.} A rule of thumb is that one year
4608 @texline @math{\pi \times 10^7}
4609 @infoline @w{@expr{pi * 10^7}}
4610 seconds. What time will it be that many seconds from right now?
4611 @xref{Types Answer 11, 11}. (@bullet{})
4613 (@bullet{}) @strong{Exercise 12.} You are preparing to order packaging
4614 for the CD release of the Extended Disco Version of @emph{Abbey Road}.
4615 You are told that the songs will actually be anywhere from 20 to 60
4616 seconds longer than the originals. One CD can hold about 75 minutes
4617 of music. Should you order single or double packages?
4618 @xref{Types Answer 12, 12}. (@bullet{})
4620 Another kind of data the Calculator can manipulate is numbers with
4621 @dfn{units}. This isn't strictly a new data type; it's simply an
4622 application of algebraic expressions, where we use variables with
4623 suggestive names like @samp{cm} and @samp{in} to represent units
4624 like centimeters and inches.
4628 1: 2 in 1: 5.08 cm 1: 0.027778 fath 1: 0.0508 m
4631 ' 2in @key{RET} u c cm @key{RET} u c fath @key{RET} u b
4636 We enter the quantity ``2 inches'' (actually an algebraic expression
4637 which means two times the variable @samp{in}), then we convert it
4638 first to centimeters, then to fathoms, then finally to ``base'' units,
4639 which in this case means meters.
4643 1: 9 acre 1: 3 sqrt(acre) 1: 190.84 m 1: 190.84 m + 30 cm
4646 ' 9 acre @key{RET} Q u s ' $+30 cm @key{RET}
4653 1: 191.14 m 1: 36536.3046 m^2 1: 365363046 cm^2
4661 Since units expressions are really just formulas, taking the square
4662 root of @samp{acre} is undefined. After all, @code{acre} might be an
4663 algebraic variable that you will someday assign a value. We use the
4664 ``units-simplify'' command to simplify the expression with variables
4665 being interpreted as unit names.
4667 In the final step, we have converted not to a particular unit, but to a
4668 units system. The ``cgs'' system uses centimeters instead of meters
4669 as its standard unit of length.
4671 There is a wide variety of units defined in the Calculator.
4675 1: 55 mph 1: 88.5139 kph 1: 88.5139 km / hr 1: 8.201407e-8 c
4678 ' 55 mph @key{RET} u c kph @key{RET} u c km/hr @key{RET} u c c @key{RET}
4683 We express a speed first in miles per hour, then in kilometers per
4684 hour, then again using a slightly more explicit notation, then
4685 finally in terms of fractions of the speed of light.
4687 Temperature conversions are a bit more tricky. There are two ways to
4688 interpret ``20 degrees Fahrenheit''---it could mean an actual
4689 temperature, or it could mean a change in temperature. For normal
4690 units there is no difference, but temperature units have an offset
4691 as well as a scale factor and so there must be two explicit commands
4696 1: 20 degF 1: 11.1111 degC 1: -6.666 degC
4699 ' 20 degF @key{RET} u c degC @key{RET} U u t degC @key{RET}
4704 First we convert a change of 20 degrees Fahrenheit into an equivalent
4705 change in degrees Celsius (or Centigrade). Then, we convert the
4706 absolute temperature 20 degrees Fahrenheit into Celsius.
4708 For simple unit conversions, you can put a plain number on the stack.
4709 Then @kbd{u c} and @kbd{u t} will prompt for both old and new units.
4710 When you use this method, you're responsible for remembering which
4711 numbers are in which units:
4715 1: 55 1: 88.5139 1: 8.201407e-8
4718 55 u c mph @key{RET} kph @key{RET} u c km/hr @key{RET} c @key{RET}
4722 To see a complete list of built-in units, type @kbd{u v}. Press
4723 @w{@kbd{C-x * c}} again to re-enter the Calculator when you're done looking
4726 (@bullet{}) @strong{Exercise 13.} How many seconds are there really
4727 in a year? @xref{Types Answer 13, 13}. (@bullet{})
4729 @cindex Speed of light
4730 (@bullet{}) @strong{Exercise 14.} Supercomputer designs are limited by
4731 the speed of light (and of electricity, which is nearly as fast).
4732 Suppose a computer has a 4.1 ns (nanosecond) clock cycle, and its
4733 cabinet is one meter across. Is speed of light going to be a
4734 significant factor in its design? @xref{Types Answer 14, 14}. (@bullet{})
4736 (@bullet{}) @strong{Exercise 15.} Sam the Slug normally travels about
4737 five yards in an hour. He has obtained a supply of Power Pills; each
4738 Power Pill he eats doubles his speed. How many Power Pills can he
4739 swallow and still travel legally on most US highways?
4740 @xref{Types Answer 15, 15}. (@bullet{})
4742 @node Algebra Tutorial, Programming Tutorial, Types Tutorial, Tutorial
4743 @section Algebra and Calculus Tutorial
4746 This section shows how to use Calc's algebra facilities to solve
4747 equations, do simple calculus problems, and manipulate algebraic
4751 * Basic Algebra Tutorial::
4752 * Rewrites Tutorial::
4755 @node Basic Algebra Tutorial, Rewrites Tutorial, Algebra Tutorial, Algebra Tutorial
4756 @subsection Basic Algebra
4759 If you enter a formula in Algebraic mode that refers to variables,
4760 the formula itself is pushed onto the stack. You can manipulate
4761 formulas as regular data objects.
4765 1: 2 x^2 - 6 1: 6 - 2 x^2 1: (3 x^2 + y) (6 - 2 x^2)
4768 ' 2x^2-6 @key{RET} n ' 3x^2+y @key{RET} *
4772 (@bullet{}) @strong{Exercise 1.} Do @kbd{' x @key{RET} Q 2 ^} and
4773 @kbd{' x @key{RET} 2 ^ Q} both wind up with the same result (@samp{x})?
4774 Why or why not? @xref{Algebra Answer 1, 1}. (@bullet{})
4776 There are also commands for doing common algebraic operations on
4777 formulas. Continuing with the formula from the last example,
4781 1: 18 x^2 - 6 x^4 + 6 y - 2 y x^2 1: (18 - 2 y) x^2 - 6 x^4 + 6 y
4789 First we ``expand'' using the distributive law, then we ``collect''
4790 terms involving like powers of @expr{x}.
4792 Let's find the value of this expression when @expr{x} is 2 and @expr{y}
4797 1: 17 x^2 - 6 x^4 + 3 1: -25
4800 1:2 s l y @key{RET} 2 s l x @key{RET}
4805 The @kbd{s l} command means ``let''; it takes a number from the top of
4806 the stack and temporarily assigns it as the value of the variable
4807 you specify. It then evaluates (as if by the @kbd{=} key) the
4808 next expression on the stack. After this command, the variable goes
4809 back to its original value, if any.
4811 (An earlier exercise in this tutorial involved storing a value in the
4812 variable @code{x}; if this value is still there, you will have to
4813 unstore it with @kbd{s u x @key{RET}} before the above example will work
4816 @cindex Maximum of a function using Calculus
4817 Let's find the maximum value of our original expression when @expr{y}
4818 is one-half and @expr{x} ranges over all possible values. We can
4819 do this by taking the derivative with respect to @expr{x} and examining
4820 values of @expr{x} for which the derivative is zero. If the second
4821 derivative of the function at that value of @expr{x} is negative,
4822 the function has a local maximum there.
4826 1: 17 x^2 - 6 x^4 + 3 1: 34 x - 24 x^3
4829 U @key{DEL} s 1 a d x @key{RET} s 2
4834 Well, the derivative is clearly zero when @expr{x} is zero. To find
4835 the other root(s), let's divide through by @expr{x} and then solve:
4839 1: (34 x - 24 x^3) / x 1: 34 - 24 x^2
4849 1: 0.70588 x^2 = 1 1: x = 1.19023
4852 0 a = s 3 a S x @key{RET}
4857 Now we compute the second derivative and plug in our values of @expr{x}:
4861 1: 1.19023 2: 1.19023 2: 1.19023
4862 . 1: 34 x - 24 x^3 1: 34 - 72 x^2
4865 a . r 2 a d x @key{RET} s 4
4870 (The @kbd{a .} command extracts just the righthand side of an equation.
4871 Another method would have been to use @kbd{v u} to unpack the equation
4872 @w{@samp{x = 1.19}} to @samp{x} and @samp{1.19}, then use @kbd{M-- M-2 @key{DEL}}
4873 to delete the @samp{x}.)
4877 2: 34 - 72 x^2 1: -68. 2: 34 - 72 x^2 1: 34
4881 @key{TAB} s l x @key{RET} U @key{DEL} 0 s l x @key{RET}
4886 The first of these second derivatives is negative, so we know the function
4887 has a maximum value at @expr{x = 1.19023}. (The function also has a
4888 local @emph{minimum} at @expr{x = 0}.)
4890 When we solved for @expr{x}, we got only one value even though
4891 @expr{0.70588 x^2 = 1} is a quadratic equation that ought to have
4892 two solutions. The reason is that @w{@kbd{a S}} normally returns a
4893 single ``principal'' solution. If it needs to come up with an
4894 arbitrary sign (as occurs in the quadratic formula) it picks @expr{+}.
4895 If it needs an arbitrary integer, it picks zero. We can get a full
4896 solution by pressing @kbd{H} (the Hyperbolic flag) before @kbd{a S}.
4900 1: 0.70588 x^2 = 1 1: x = 1.19023 s1 1: x = -1.19023
4903 r 3 H a S x @key{RET} s 5 1 n s l s1 @key{RET}
4908 Calc has invented the variable @samp{s1} to represent an unknown sign;
4909 it is supposed to be either @mathit{+1} or @mathit{-1}. Here we have used
4910 the ``let'' command to evaluate the expression when the sign is negative.
4911 If we plugged this into our second derivative we would get the same,
4912 negative, answer, so @expr{x = -1.19023} is also a maximum.
4914 To find the actual maximum value, we must plug our two values of @expr{x}
4915 into the original formula.
4919 2: 17 x^2 - 6 x^4 + 3 1: 24.08333 s1^2 - 12.04166 s1^4 + 3
4923 r 1 r 5 s l @key{RET}
4928 (Here we see another way to use @kbd{s l}; if its input is an equation
4929 with a variable on the lefthand side, then @kbd{s l} treats the equation
4930 like an assignment to that variable if you don't give a variable name.)
4932 It's clear that this will have the same value for either sign of
4933 @code{s1}, but let's work it out anyway, just for the exercise:
4937 2: [-1, 1] 1: [15.04166, 15.04166]
4938 1: 24.08333 s1^2 ... .
4941 [ 1 n , 1 ] @key{TAB} V M $ @key{RET}
4946 Here we have used a vector mapping operation to evaluate the function
4947 at several values of @samp{s1} at once. @kbd{V M $} is like @kbd{V M '}
4948 except that it takes the formula from the top of the stack. The
4949 formula is interpreted as a function to apply across the vector at the
4950 next-to-top stack level. Since a formula on the stack can't contain
4951 @samp{$} signs, Calc assumes the variables in the formula stand for
4952 different arguments. It prompts you for an @dfn{argument list}, giving
4953 the list of all variables in the formula in alphabetical order as the
4954 default list. In this case the default is @samp{(s1)}, which is just
4955 what we want so we simply press @key{RET} at the prompt.
4957 If there had been several different values, we could have used
4958 @w{@kbd{V R X}} to find the global maximum.
4960 Calc has a built-in @kbd{a P} command that solves an equation using
4961 @w{@kbd{H a S}} and returns a vector of all the solutions. It simply
4962 automates the job we just did by hand. Applied to our original
4963 cubic polynomial, it would produce the vector of solutions
4964 @expr{[1.19023, -1.19023, 0]}. (There is also an @kbd{a X} command
4965 which finds a local maximum of a function. It uses a numerical search
4966 method rather than examining the derivatives, and thus requires you
4967 to provide some kind of initial guess to show it where to look.)
4969 (@bullet{}) @strong{Exercise 2.} Given a vector of the roots of a
4970 polynomial (such as the output of an @kbd{a P} command), what
4971 sequence of commands would you use to reconstruct the original
4972 polynomial? (The answer will be unique to within a constant
4973 multiple; choose the solution where the leading coefficient is one.)
4974 @xref{Algebra Answer 2, 2}. (@bullet{})
4976 The @kbd{m s} command enables Symbolic mode, in which formulas
4977 like @samp{sqrt(5)} that can't be evaluated exactly are left in
4978 symbolic form rather than giving a floating-point approximate answer.
4979 Fraction mode (@kbd{m f}) is also useful when doing algebra.
4983 2: 34 x - 24 x^3 2: 34 x - 24 x^3
4984 1: 34 x - 24 x^3 1: [sqrt(51) / 6, sqrt(51) / -6, 0]
4987 r 2 @key{RET} m s m f a P x @key{RET}
4991 One more mode that makes reading formulas easier is Big mode.
5000 1: [-----, -----, 0]
5009 Here things like powers, square roots, and quotients and fractions
5010 are displayed in a two-dimensional pictorial form. Calc has other
5011 language modes as well, such as C mode, FORTRAN mode, @TeX{} mode
5016 2: 34*x - 24*pow(x, 3) 2: 34*x - 24*x**3
5017 1: @{sqrt(51) / 6, sqrt(51) / -6, 0@} 1: /sqrt(51) / 6, sqrt(51) / -6, 0/
5028 2: [@{\sqrt@{51@} \over 6@}, @{\sqrt@{51@} \over -6@}, 0]
5029 1: @{2 \over 3@} \sqrt@{5@}
5032 d T ' 2 \sqrt@{5@} \over 3 @key{RET}
5037 As you can see, language modes affect both entry and display of
5038 formulas. They affect such things as the names used for built-in
5039 functions, the set of arithmetic operators and their precedences,
5040 and notations for vectors and matrices.
5042 Notice that @samp{sqrt(51)} may cause problems with older
5043 implementations of C and FORTRAN, which would require something more
5044 like @samp{sqrt(51.0)}. It is always wise to check over the formulas
5045 produced by the various language modes to make sure they are fully
5048 Type @kbd{m s}, @kbd{m f}, and @kbd{d N} to reset these modes. (You
5049 may prefer to remain in Big mode, but all the examples in the tutorial
5050 are shown in normal mode.)
5052 @cindex Area under a curve
5053 What is the area under the portion of this curve from @expr{x = 1} to @expr{2}?
5054 This is simply the integral of the function:
5058 1: 17 x^2 - 6 x^4 + 3 1: 5.6666 x^3 - 1.2 x^5 + 3 x
5066 We want to evaluate this at our two values for @expr{x} and subtract.
5067 One way to do it is again with vector mapping and reduction:
5071 2: [2, 1] 1: [12.93333, 7.46666] 1: 5.46666
5072 1: 5.6666 x^3 ... . .
5074 [ 2 , 1 ] @key{TAB} V M $ @key{RET} V R -
5078 (@bullet{}) @strong{Exercise 3.} Find the integral from 1 to @expr{y}
5080 @texline @math{x \sin \pi x}
5081 @infoline @w{@expr{x sin(pi x)}}
5082 (where the sine is calculated in radians). Find the values of the
5083 integral for integers @expr{y} from 1 to 5. @xref{Algebra Answer 3,
5086 Calc's integrator can do many simple integrals symbolically, but many
5087 others are beyond its capabilities. Suppose we wish to find the area
5089 @texline @math{\sin x \ln x}
5090 @infoline @expr{sin(x) ln(x)}
5091 over the same range of @expr{x}. If you entered this formula and typed
5092 @kbd{a i x @key{RET}} (don't bother to try this), Calc would work for a
5093 long time but would be unable to find a solution. In fact, there is no
5094 closed-form solution to this integral. Now what do we do?
5096 @cindex Integration, numerical
5097 @cindex Numerical integration
5098 One approach would be to do the integral numerically. It is not hard
5099 to do this by hand using vector mapping and reduction. It is rather
5100 slow, though, since the sine and logarithm functions take a long time.
5101 We can save some time by reducing the working precision.
5105 3: 10 1: [1, 1.1, 1.2, ... , 1.8, 1.9]
5110 10 @key{RET} 1 @key{RET} .1 @key{RET} C-u v x
5115 (Note that we have used the extended version of @kbd{v x}; we could
5116 also have used plain @kbd{v x} as follows: @kbd{v x 10 @key{RET} 9 + .1 *}.)
5120 2: [1, 1.1, ... ] 1: [0., 0.084941, 0.16993, ... ]
5124 ' sin(x) ln(x) @key{RET} s 1 m r p 5 @key{RET} V M $ @key{RET}
5139 (If you got wildly different results, did you remember to switch
5142 Here we have divided the curve into ten segments of equal width;
5143 approximating these segments as rectangular boxes (i.e., assuming
5144 the curve is nearly flat at that resolution), we compute the areas
5145 of the boxes (height times width), then sum the areas. (It is
5146 faster to sum first, then multiply by the width, since the width
5147 is the same for every box.)
5149 The true value of this integral turns out to be about 0.374, so
5150 we're not doing too well. Let's try another approach.
5154 1: ln(x) sin(x) 1: 0.84147 x + 0.11957 (x - 1)^2 - ...
5157 r 1 a t x=1 @key{RET} 4 @key{RET}
5162 Here we have computed the Taylor series expansion of the function
5163 about the point @expr{x=1}. We can now integrate this polynomial
5164 approximation, since polynomials are easy to integrate.
5168 1: 0.42074 x^2 + ... 1: [-0.0446, -0.42073] 1: 0.3761
5171 a i x @key{RET} [ 2 , 1 ] @key{TAB} V M $ @key{RET} V R -
5176 Better! By increasing the precision and/or asking for more terms
5177 in the Taylor series, we can get a result as accurate as we like.
5178 (Taylor series converge better away from singularities in the
5179 function such as the one at @code{ln(0)}, so it would also help to
5180 expand the series about the points @expr{x=2} or @expr{x=1.5} instead
5183 @cindex Simpson's rule
5184 @cindex Integration by Simpson's rule
5185 (@bullet{}) @strong{Exercise 4.} Our first method approximated the
5186 curve by stairsteps of width 0.1; the total area was then the sum
5187 of the areas of the rectangles under these stairsteps. Our second
5188 method approximated the function by a polynomial, which turned out
5189 to be a better approximation than stairsteps. A third method is
5190 @dfn{Simpson's rule}, which is like the stairstep method except
5191 that the steps are not required to be flat. Simpson's rule boils
5192 down to the formula,
5196 (h/3) * (f(a) + 4 f(a+h) + 2 f(a+2h) + 4 f(a+3h) + ...
5197 + 2 f(a+(n-2)*h) + 4 f(a+(n-1)*h) + f(a+n*h))
5203 \qquad {h \over 3} (f(a) + 4 f(a+h) + 2 f(a+2h) + 4 f(a+3h) + \cdots
5204 \hfill \cr \hfill {} + 2 f(a+(n-2)h) + 4 f(a+(n-1)h) + f(a+n h)) \qquad
5210 where @expr{n} (which must be even) is the number of slices and @expr{h}
5211 is the width of each slice. These are 10 and 0.1 in our example.
5212 For reference, here is the corresponding formula for the stairstep
5217 h * (f(a) + f(a+h) + f(a+2h) + f(a+3h) + ...
5218 + f(a+(n-2)*h) + f(a+(n-1)*h))
5223 $$ h (f(a) + f(a+h) + f(a+2h) + f(a+3h) + \cdots
5224 + f(a+(n-2)h) + f(a+(n-1)h)) $$
5228 Compute the integral from 1 to 2 of
5229 @texline @math{\sin x \ln x}
5230 @infoline @expr{sin(x) ln(x)}
5231 using Simpson's rule with 10 slices.
5232 @xref{Algebra Answer 4, 4}. (@bullet{})
5234 Calc has a built-in @kbd{a I} command for doing numerical integration.
5235 It uses @dfn{Romberg's method}, which is a more sophisticated cousin
5236 of Simpson's rule. In particular, it knows how to keep refining the
5237 result until the current precision is satisfied.
5239 @c [fix-ref Selecting Sub-Formulas]
5240 Aside from the commands we've seen so far, Calc also provides a
5241 large set of commands for operating on parts of formulas. You
5242 indicate the desired sub-formula by placing the cursor on any part
5243 of the formula before giving a @dfn{selection} command. Selections won't
5244 be covered in the tutorial; @pxref{Selecting Subformulas}, for
5245 details and examples.
5247 @c hard exercise: simplify (2^(n r) - 2^(r*(n - 1))) / (2^r - 1) 2^(n - 1)
5248 @c to 2^((n-1)*(r-1)).
5250 @node Rewrites Tutorial, , Basic Algebra Tutorial, Algebra Tutorial
5251 @subsection Rewrite Rules
5254 No matter how many built-in commands Calc provided for doing algebra,
5255 there would always be something you wanted to do that Calc didn't have
5256 in its repertoire. So Calc also provides a @dfn{rewrite rule} system
5257 that you can use to define your own algebraic manipulations.
5259 Suppose we want to simplify this trigonometric formula:
5263 1: 2 sec(x)^2 / tan(x)^2 - 2 / tan(x)^2
5266 ' 2sec(x)^2/tan(x)^2 - 2/tan(x)^2 @key{RET} s 1
5271 If we were simplifying this by hand, we'd probably combine over the common
5272 denominator. The @kbd{a n} algebra command will do this, but we'll do
5273 it with a rewrite rule just for practice.
5275 Rewrite rules are written with the @samp{:=} symbol.
5279 1: (2 sec(x)^2 - 2) / tan(x)^2
5282 a r a/x + b/x := (a+b)/x @key{RET}
5287 (The ``assignment operator'' @samp{:=} has several uses in Calc. All
5288 by itself the formula @samp{a/x + b/x := (a+b)/x} doesn't do anything,
5289 but when it is given to the @kbd{a r} command, that command interprets
5290 it as a rewrite rule.)
5292 The lefthand side, @samp{a/x + b/x}, is called the @dfn{pattern} of the
5293 rewrite rule. Calc searches the formula on the stack for parts that
5294 match the pattern. Variables in a rewrite pattern are called
5295 @dfn{meta-variables}, and when matching the pattern each meta-variable
5296 can match any sub-formula. Here, the meta-variable @samp{a} matched
5297 the expression @samp{2 sec(x)^2}, the meta-variable @samp{b} matched
5298 the constant @samp{-2} and the meta-variable @samp{x} matched
5299 the expression @samp{tan(x)^2}.
5301 This rule points out several interesting features of rewrite patterns.
5302 First, if a meta-variable appears several times in a pattern, it must
5303 match the same thing everywhere. This rule detects common denominators
5304 because the same meta-variable @samp{x} is used in both of the
5307 Second, meta-variable names are independent from variables in the
5308 target formula. Notice that the meta-variable @samp{x} here matches
5309 the subformula @samp{tan(x)^2}; Calc never confuses the two meanings of
5312 And third, rewrite patterns know a little bit about the algebraic
5313 properties of formulas. The pattern called for a sum of two quotients;
5314 Calc was able to match a difference of two quotients by matching
5315 @samp{a = 2 sec(x)^2}, @samp{b = -2}, and @samp{x = tan(x)^2}.
5317 When the pattern part of a rewrite rule matches a part of the formula,
5318 that part is replaced by the righthand side with all the meta-variables
5319 substituted with the things they matched. So the result is
5320 @samp{(2 sec(x)^2 - 2) / tan(x)^2}.
5322 @c [fix-ref Algebraic Properties of Rewrite Rules]
5323 We could just as easily have written @samp{a/x - b/x := (a-b)/x} for
5324 the rule. It would have worked just the same in all cases. (If we
5325 really wanted the rule to apply only to @samp{+} or only to @samp{-},
5326 we could have used the @code{plain} symbol. @xref{Algebraic Properties
5327 of Rewrite Rules}, for some examples of this.)
5329 One more rewrite will complete the job. We want to use the identity
5330 @samp{tan(x)^2 + 1 = sec(x)^2}, but of course we must first rearrange
5331 the identity in a way that matches our formula. The obvious rule
5332 would be @samp{@w{2 sec(x)^2 - 2} := 2 tan(x)^2}, but a little thought shows
5333 that the rule @samp{sec(x)^2 := 1 + tan(x)^2} will also work. The
5334 latter rule has a more general pattern so it will work in many other
5342 a r sec(x)^2 := 1 + tan(x)^2 @key{RET}
5346 You may ask, what's the point of using the most general rule if you
5347 have to type it in every time anyway? The answer is that Calc allows
5348 you to store a rewrite rule in a variable, then give the variable
5349 name in the @kbd{a r} command. In fact, this is the preferred way to
5350 use rewrites. For one, if you need a rule once you'll most likely
5351 need it again later. Also, if the rule doesn't work quite right you
5352 can simply Undo, edit the variable, and run the rule again without
5353 having to retype it.
5357 ' a/x + b/x := (a+b)/x @key{RET} s t merge @key{RET}
5358 ' sec(x)^2 := 1 + tan(x)^2 @key{RET} s t secsqr @key{RET}
5360 1: 2 sec(x)^2 / tan(x)^2 - 2 / tan(x)^2 1: 2
5363 r 1 a r merge @key{RET} a r secsqr @key{RET}
5367 To edit a variable, type @kbd{s e} and the variable name, use regular
5368 Emacs editing commands as necessary, then type @kbd{C-c C-c} to store
5369 the edited value back into the variable.
5370 You can also use @w{@kbd{s e}} to create a new variable if you wish.
5372 Notice that the first time you use each rule, Calc puts up a ``compiling''
5373 message briefly. The pattern matcher converts rules into a special
5374 optimized pattern-matching language rather than using them directly.
5375 This allows @kbd{a r} to apply even rather complicated rules very
5376 efficiently. If the rule is stored in a variable, Calc compiles it
5377 only once and stores the compiled form along with the variable. That's
5378 another good reason to store your rules in variables rather than
5379 entering them on the fly.
5381 (@bullet{}) @strong{Exercise 1.} Type @kbd{m s} to get Symbolic
5382 mode, then enter the formula @samp{@w{(2 + sqrt(2))} / @w{(1 + sqrt(2))}}.
5383 Using a rewrite rule, simplify this formula by multiplying the top and
5384 bottom by the conjugate @w{@samp{1 - sqrt(2)}}. The result will have
5385 to be expanded by the distributive law; do this with another
5386 rewrite. @xref{Rewrites Answer 1, 1}. (@bullet{})
5388 The @kbd{a r} command can also accept a vector of rewrite rules, or
5389 a variable containing a vector of rules.
5393 1: [merge, secsqr] 1: [a/x + b/x := (a + b)/x, ... ]
5396 ' [merge,sinsqr] @key{RET} =
5403 1: 2 sec(x)^2 / tan(x)^2 - 2 / tan(x)^2 1: 2
5406 s t trig @key{RET} r 1 a r trig @key{RET}
5410 @c [fix-ref Nested Formulas with Rewrite Rules]
5411 Calc tries all the rules you give against all parts of the formula,
5412 repeating until no further change is possible. (The exact order in
5413 which things are tried is rather complex, but for simple rules like
5414 the ones we've used here the order doesn't really matter.
5415 @xref{Nested Formulas with Rewrite Rules}.)
5417 Calc actually repeats only up to 100 times, just in case your rule set
5418 has gotten into an infinite loop. You can give a numeric prefix argument
5419 to @kbd{a r} to specify any limit. In particular, @kbd{M-1 a r} does
5420 only one rewrite at a time.
5424 1: (2 sec(x)^2 - 2) / tan(x)^2 1: 2
5427 r 1 M-1 a r trig @key{RET} M-1 a r trig @key{RET}
5431 You can type @kbd{M-0 a r} if you want no limit at all on the number
5432 of rewrites that occur.
5434 Rewrite rules can also be @dfn{conditional}. Simply follow the rule
5435 with a @samp{::} symbol and the desired condition. For example,
5439 1: sin(x + 2 pi) + sin(x + 3 pi) + sin(x + 4 pi)
5442 ' sin(x+2pi) + sin(x+3pi) + sin(x+4pi) @key{RET}
5449 1: sin(x + 3 pi) + 2 sin(x)
5452 a r sin(a + k pi) := sin(a) :: k % 2 = 0 @key{RET}
5457 (Recall, @samp{k % 2} is the remainder from dividing @samp{k} by 2,
5458 which will be zero only when @samp{k} is an even integer.)
5460 An interesting point is that the variable @samp{pi} was matched
5461 literally rather than acting as a meta-variable.
5462 This is because it is a special-constant variable. The special
5463 constants @samp{e}, @samp{i}, @samp{phi}, and so on also match literally.
5464 A common error with rewrite
5465 rules is to write, say, @samp{f(a,b,c,d,e) := g(a+b+c+d+e)}, expecting
5466 to match any @samp{f} with five arguments but in fact matching
5467 only when the fifth argument is literally @samp{e}!
5469 @cindex Fibonacci numbers
5474 Rewrite rules provide an interesting way to define your own functions.
5475 Suppose we want to define @samp{fib(n)} to produce the @var{n}th
5476 Fibonacci number. The first two Fibonacci numbers are each 1;
5477 later numbers are formed by summing the two preceding numbers in
5478 the sequence. This is easy to express in a set of three rules:
5482 ' [fib(1) := 1, fib(2) := 1, fib(n) := fib(n-1) + fib(n-2)] @key{RET} s t fib
5487 ' fib(7) @key{RET} a r fib @key{RET}
5491 One thing that is guaranteed about the order that rewrites are tried
5492 is that, for any given subformula, earlier rules in the rule set will
5493 be tried for that subformula before later ones. So even though the
5494 first and third rules both match @samp{fib(1)}, we know the first will
5495 be used preferentially.
5497 This rule set has one dangerous bug: Suppose we apply it to the
5498 formula @samp{fib(x)}? (Don't actually try this.) The third rule
5499 will match @samp{fib(x)} and replace it with @w{@samp{fib(x-1) + fib(x-2)}}.
5500 Each of these will then be replaced to get @samp{fib(x-2) + 2 fib(x-3) +
5501 fib(x-4)}, and so on, expanding forever. What we really want is to apply
5502 the third rule only when @samp{n} is an integer greater than two. Type
5503 @w{@kbd{s e fib @key{RET}}}, then edit the third rule to:
5506 fib(n) := fib(n-1) + fib(n-2) :: integer(n) :: n > 2
5514 1: fib(6) + fib(x) + fib(0) 1: fib(x) + fib(0) + 8
5517 ' fib(6)+fib(x)+fib(0) @key{RET} a r fib @key{RET}
5522 We've created a new function, @code{fib}, and a new command,
5523 @w{@kbd{a r fib @key{RET}}}, which means ``evaluate all @code{fib} calls in
5524 this formula.'' To make things easier still, we can tell Calc to
5525 apply these rules automatically by storing them in the special
5526 variable @code{EvalRules}.
5530 1: [fib(1) := ...] . 1: [8, 13]
5533 s r fib @key{RET} s t EvalRules @key{RET} ' [fib(6), fib(7)] @key{RET}
5537 It turns out that this rule set has the problem that it does far
5538 more work than it needs to when @samp{n} is large. Consider the
5539 first few steps of the computation of @samp{fib(6)}:
5545 fib(4) + fib(3) + fib(3) + fib(2) =
5546 fib(3) + fib(2) + fib(2) + fib(1) + fib(2) + fib(1) + 1 = ...
5551 Note that @samp{fib(3)} appears three times here. Unless Calc's
5552 algebraic simplifier notices the multiple @samp{fib(3)}s and combines
5553 them (and, as it happens, it doesn't), this rule set does lots of
5554 needless recomputation. To cure the problem, type @code{s e EvalRules}
5555 to edit the rules (or just @kbd{s E}, a shorthand command for editing
5556 @code{EvalRules}) and add another condition:
5559 fib(n) := fib(n-1) + fib(n-2) :: integer(n) :: n > 2 :: remember
5563 If a @samp{:: remember} condition appears anywhere in a rule, then if
5564 that rule succeeds Calc will add another rule that describes that match
5565 to the front of the rule set. (Remembering works in any rule set, but
5566 for technical reasons it is most effective in @code{EvalRules}.) For
5567 example, if the rule rewrites @samp{fib(7)} to something that evaluates
5568 to 13, then the rule @samp{fib(7) := 13} will be added to the rule set.
5570 Type @kbd{' fib(8) @key{RET}} to compute the eighth Fibonacci number, then
5571 type @kbd{s E} again to see what has happened to the rule set.
5573 With the @code{remember} feature, our rule set can now compute
5574 @samp{fib(@var{n})} in just @var{n} steps. In the process it builds
5575 up a table of all Fibonacci numbers up to @var{n}. After we have
5576 computed the result for a particular @var{n}, we can get it back
5577 (and the results for all smaller @var{n}) later in just one step.
5579 All Calc operations will run somewhat slower whenever @code{EvalRules}
5580 contains any rules. You should type @kbd{s u EvalRules @key{RET}} now to
5581 un-store the variable.
5583 (@bullet{}) @strong{Exercise 2.} Sometimes it is possible to reformulate
5584 a problem to reduce the amount of recursion necessary to solve it.
5585 Create a rule that, in about @var{n} simple steps and without recourse
5586 to the @code{remember} option, replaces @samp{fib(@var{n}, 1, 1)} with
5587 @samp{fib(1, @var{x}, @var{y})} where @var{x} and @var{y} are the
5588 @var{n}th and @var{n+1}st Fibonacci numbers, respectively. This rule is
5589 rather clunky to use, so add a couple more rules to make the ``user
5590 interface'' the same as for our first version: enter @samp{fib(@var{n})},
5591 get back a plain number. @xref{Rewrites Answer 2, 2}. (@bullet{})
5593 There are many more things that rewrites can do. For example, there
5594 are @samp{&&&} and @samp{|||} pattern operators that create ``and''
5595 and ``or'' combinations of rules. As one really simple example, we
5596 could combine our first two Fibonacci rules thusly:
5599 [fib(1 ||| 2) := 1, fib(n) := ... ]
5603 That means ``@code{fib} of something matching either 1 or 2 rewrites
5606 You can also make meta-variables optional by enclosing them in @code{opt}.
5607 For example, the pattern @samp{a + b x} matches @samp{2 + 3 x} but not
5608 @samp{2 + x} or @samp{3 x} or @samp{x}. The pattern @samp{opt(a) + opt(b) x}
5609 matches all of these forms, filling in a default of zero for @samp{a}
5610 and one for @samp{b}.
5612 (@bullet{}) @strong{Exercise 3.} Your friend Joe had @samp{2 + 3 x}
5613 on the stack and tried to use the rule
5614 @samp{opt(a) + opt(b) x := f(a, b, x)}. What happened?
5615 @xref{Rewrites Answer 3, 3}. (@bullet{})
5617 (@bullet{}) @strong{Exercise 4.} Starting with a positive integer @expr{a},
5618 divide @expr{a} by two if it is even, otherwise compute @expr{3 a + 1}.
5619 Now repeat this step over and over. A famous unproved conjecture
5620 is that for any starting @expr{a}, the sequence always eventually
5621 reaches 1. Given the formula @samp{seq(@var{a}, 0)}, write a set of
5622 rules that convert this into @samp{seq(1, @var{n})} where @var{n}
5623 is the number of steps it took the sequence to reach the value 1.
5624 Now enhance the rules to accept @samp{seq(@var{a})} as a starting
5625 configuration, and to stop with just the number @var{n} by itself.
5626 Now make the result be a vector of values in the sequence, from @var{a}
5627 to 1. (The formula @samp{@var{x}|@var{y}} appends the vectors @var{x}
5628 and @var{y}.) For example, rewriting @samp{seq(6)} should yield the
5629 vector @expr{[6, 3, 10, 5, 16, 8, 4, 2, 1]}.
5630 @xref{Rewrites Answer 4, 4}. (@bullet{})
5632 (@bullet{}) @strong{Exercise 5.} Define, using rewrite rules, a function
5633 @samp{nterms(@var{x})} that returns the number of terms in the sum
5634 @var{x}, or 1 if @var{x} is not a sum. (A @dfn{sum} for our purposes
5635 is one or more non-sum terms separated by @samp{+} or @samp{-} signs,
5636 so that @expr{2 - 3 (x + y) + x y} is a sum of three terms.)
5637 @xref{Rewrites Answer 5, 5}. (@bullet{})
5639 (@bullet{}) @strong{Exercise 6.} A Taylor series for a function is an
5640 infinite series that exactly equals the value of that function at
5641 values of @expr{x} near zero.
5645 cos(x) = 1 - x^2 / 2! + x^4 / 4! - x^6 / 6! + ...
5650 $$ \cos x = 1 - {x^2 \over 2!} + {x^4 \over 4!} - {x^6 \over 6!} + \cdots $$
5654 The @kbd{a t} command produces a @dfn{truncated Taylor series} which
5655 is obtained by dropping all the terms higher than, say, @expr{x^2}.
5656 Calc represents the truncated Taylor series as a polynomial in @expr{x}.
5657 Mathematicians often write a truncated series using a ``big-O'' notation
5658 that records what was the lowest term that was truncated.
5662 cos(x) = 1 - x^2 / 2! + O(x^3)
5667 $$ \cos x = 1 - {x^2 \over 2!} + O(x^3) $$
5672 The meaning of @expr{O(x^3)} is ``a quantity which is negligibly small
5673 if @expr{x^3} is considered negligibly small as @expr{x} goes to zero.''
5675 The exercise is to create rewrite rules that simplify sums and products of
5676 power series represented as @samp{@var{polynomial} + O(@var{var}^@var{n})}.
5677 For example, given @samp{1 - x^2 / 2 + O(x^3)} and @samp{x - x^3 / 6 + O(x^4)}
5678 on the stack, we want to be able to type @kbd{*} and get the result
5679 @samp{x - 2:3 x^3 + O(x^4)}. Don't worry if the terms of the sum are
5680 rearranged. (This one is rather tricky; the solution at the end of
5681 this chapter uses 6 rewrite rules. Hint: The @samp{constant(x)}
5682 condition tests whether @samp{x} is a number.) @xref{Rewrites Answer
5685 Just for kicks, try adding the rule @code{2+3 := 6} to @code{EvalRules}.
5686 What happens? (Be sure to remove this rule afterward, or you might get
5687 a nasty surprise when you use Calc to balance your checkbook!)
5689 @xref{Rewrite Rules}, for the whole story on rewrite rules.
5691 @node Programming Tutorial, Answers to Exercises, Algebra Tutorial, Tutorial
5692 @section Programming Tutorial
5695 The Calculator is written entirely in Emacs Lisp, a highly extensible
5696 language. If you know Lisp, you can program the Calculator to do
5697 anything you like. Rewrite rules also work as a powerful programming
5698 system. But Lisp and rewrite rules take a while to master, and often
5699 all you want to do is define a new function or repeat a command a few
5700 times. Calc has features that allow you to do these things easily.
5702 One very limited form of programming is defining your own functions.
5703 Calc's @kbd{Z F} command allows you to define a function name and
5704 key sequence to correspond to any formula. Programming commands use
5705 the shift-@kbd{Z} prefix; the user commands they create use the lower
5706 case @kbd{z} prefix.
5710 1: x + x^2 / 2 + x^3 / 6 + 1 1: x + x^2 / 2 + x^3 / 6 + 1
5713 ' 1 + x + x^2/2! + x^3/3! @key{RET} Z F e myexp @key{RET} @key{RET} @key{RET} y
5717 This polynomial is a Taylor series approximation to @samp{exp(x)}.
5718 The @kbd{Z F} command asks a number of questions. The above answers
5719 say that the key sequence for our function should be @kbd{z e}; the
5720 @kbd{M-x} equivalent should be @code{calc-myexp}; the name of the
5721 function in algebraic formulas should also be @code{myexp}; the
5722 default argument list @samp{(x)} is acceptable; and finally @kbd{y}
5723 answers the question ``leave it in symbolic form for non-constant
5728 1: 1.3495 2: 1.3495 3: 1.3495
5729 . 1: 1.34986 2: 1.34986
5733 .3 z e .3 E ' a+1 @key{RET} z e
5738 First we call our new @code{exp} approximation with 0.3 as an
5739 argument, and compare it with the true @code{exp} function. Then
5740 we note that, as requested, if we try to give @kbd{z e} an
5741 argument that isn't a plain number, it leaves the @code{myexp}
5742 function call in symbolic form. If we had answered @kbd{n} to the
5743 final question, @samp{myexp(a + 1)} would have evaluated by plugging
5744 in @samp{a + 1} for @samp{x} in the defining formula.
5746 @cindex Sine integral Si(x)
5751 (@bullet{}) @strong{Exercise 1.} The ``sine integral'' function
5752 @texline @math{{\rm Si}(x)}
5753 @infoline @expr{Si(x)}
5754 is defined as the integral of @samp{sin(t)/t} for
5755 @expr{t = 0} to @expr{x} in radians. (It was invented because this
5756 integral has no solution in terms of basic functions; if you give it
5757 to Calc's @kbd{a i} command, it will ponder it for a long time and then
5758 give up.) We can use the numerical integration command, however,
5759 which in algebraic notation is written like @samp{ninteg(f(t), t, 0, x)}
5760 with any integrand @samp{f(t)}. Define a @kbd{z s} command and
5761 @code{Si} function that implement this. You will need to edit the
5762 default argument list a bit. As a test, @samp{Si(1)} should return
5763 0.946083. (If you don't get this answer, you might want to check that
5764 Calc is in Radians mode. Also, @code{ninteg} will run a lot faster if
5765 you reduce the precision to, say, six digits beforehand.)
5766 @xref{Programming Answer 1, 1}. (@bullet{})
5768 The simplest way to do real ``programming'' of Emacs is to define a
5769 @dfn{keyboard macro}. A keyboard macro is simply a sequence of
5770 keystrokes which Emacs has stored away and can play back on demand.
5771 For example, if you find yourself typing @kbd{H a S x @key{RET}} often,
5772 you may wish to program a keyboard macro to type this for you.
5776 1: y = sqrt(x) 1: x = y^2
5779 ' y=sqrt(x) @key{RET} C-x ( H a S x @key{RET} C-x )
5781 1: y = cos(x) 1: x = s1 arccos(y) + 2 n1 pi
5784 ' y=cos(x) @key{RET} X
5789 When you type @kbd{C-x (}, Emacs begins recording. But it is also
5790 still ready to execute your keystrokes, so you're really ``training''
5791 Emacs by walking it through the procedure once. When you type
5792 @w{@kbd{C-x )}}, the macro is recorded. You can now type @kbd{X} to
5793 re-execute the same keystrokes.
5795 You can give a name to your macro by typing @kbd{Z K}.
5799 1: . 1: y = x^4 1: x = s2 sqrt(s1 sqrt(y))
5802 Z K x @key{RET} ' y=x^4 @key{RET} z x
5807 Notice that we use shift-@kbd{Z} to define the command, and lower-case
5808 @kbd{z} to call it up.
5810 Keyboard macros can call other macros.
5814 1: abs(x) 1: x = s1 y 1: 2 / x 1: x = 2 / y
5817 ' abs(x) @key{RET} C-x ( ' y @key{RET} a = z x C-x ) ' 2/x @key{RET} X
5821 (@bullet{}) @strong{Exercise 2.} Define a keyboard macro to negate
5822 the item in level 3 of the stack, without disturbing the rest of
5823 the stack. @xref{Programming Answer 2, 2}. (@bullet{})
5825 (@bullet{}) @strong{Exercise 3.} Define keyboard macros to compute
5826 the following functions:
5831 @texline @math{\displaystyle{\sin x \over x}},
5832 @infoline @expr{sin(x) / x},
5833 where @expr{x} is the number on the top of the stack.
5836 Compute the base-@expr{b} logarithm, just like the @kbd{B} key except
5837 the arguments are taken in the opposite order.
5840 Produce a vector of integers from 1 to the integer on the top of
5844 @xref{Programming Answer 3, 3}. (@bullet{})
5846 (@bullet{}) @strong{Exercise 4.} Define a keyboard macro to compute
5847 the average (mean) value of a list of numbers.
5848 @xref{Programming Answer 4, 4}. (@bullet{})
5850 In many programs, some of the steps must execute several times.
5851 Calc has @dfn{looping} commands that allow this. Loops are useful
5852 inside keyboard macros, but actually work at any time.
5856 1: x^6 2: x^6 1: 360 x^2
5860 ' x^6 @key{RET} 4 Z < a d x @key{RET} Z >
5865 Here we have computed the fourth derivative of @expr{x^6} by
5866 enclosing a derivative command in a ``repeat loop'' structure.
5867 This structure pops a repeat count from the stack, then
5868 executes the body of the loop that many times.
5870 If you make a mistake while entering the body of the loop,
5871 type @w{@kbd{Z C-g}} to cancel the loop command.
5873 @cindex Fibonacci numbers
5874 Here's another example:
5883 1 @key{RET} @key{RET} 20 Z < @key{TAB} C-j + Z >
5888 The numbers in levels 2 and 1 should be the 21st and 22nd Fibonacci
5889 numbers, respectively. (To see what's going on, try a few repetitions
5890 of the loop body by hand; @kbd{C-j}, also on the Line-Feed or @key{LFD}
5891 key if you have one, makes a copy of the number in level 2.)
5893 @cindex Golden ratio
5894 @cindex Phi, golden ratio
5895 A fascinating property of the Fibonacci numbers is that the @expr{n}th
5896 Fibonacci number can be found directly by computing
5897 @texline @math{\phi^n / \sqrt{5}}
5898 @infoline @expr{phi^n / sqrt(5)}
5899 and then rounding to the nearest integer, where
5900 @texline @math{\phi} (``phi''),
5901 @infoline @expr{phi},
5902 the ``golden ratio,'' is
5903 @texline @math{(1 + \sqrt{5}) / 2}.
5904 @infoline @expr{(1 + sqrt(5)) / 2}.
5905 (For convenience, this constant is available from the @code{phi}
5906 variable, or the @kbd{I H P} command.)
5910 1: 1.61803 1: 24476.0000409 1: 10945.9999817 1: 10946
5917 @cindex Continued fractions
5918 (@bullet{}) @strong{Exercise 5.} The @dfn{continued fraction}
5920 @texline @math{\phi}
5921 @infoline @expr{phi}
5923 @texline @math{1 + 1/(1 + 1/(1 + 1/( \ldots )))}.
5924 @infoline @expr{1 + 1/(1 + 1/(1 + 1/( ...@: )))}.
5925 We can compute an approximate value by carrying this however far
5926 and then replacing the innermost
5927 @texline @math{1/( \ldots )}
5928 @infoline @expr{1/( ...@: )}
5930 @texline @math{\phi}
5931 @infoline @expr{phi}
5932 using a twenty-term continued fraction.
5933 @xref{Programming Answer 5, 5}. (@bullet{})
5935 (@bullet{}) @strong{Exercise 6.} Linear recurrences like the one for
5936 Fibonacci numbers can be expressed in terms of matrices. Given a
5937 vector @w{@expr{[a, b]}} determine a matrix which, when multiplied by this
5938 vector, produces the vector @expr{[b, c]}, where @expr{a}, @expr{b} and
5939 @expr{c} are three successive Fibonacci numbers. Now write a program
5940 that, given an integer @expr{n}, computes the @expr{n}th Fibonacci number
5941 using matrix arithmetic. @xref{Programming Answer 6, 6}. (@bullet{})
5943 @cindex Harmonic numbers
5944 A more sophisticated kind of loop is the @dfn{for} loop. Suppose
5945 we wish to compute the 20th ``harmonic'' number, which is equal to
5946 the sum of the reciprocals of the integers from 1 to 20.
5955 0 @key{RET} 1 @key{RET} 20 Z ( & + 1 Z )
5960 The ``for'' loop pops two numbers, the lower and upper limits, then
5961 repeats the body of the loop as an internal counter increases from
5962 the lower limit to the upper one. Just before executing the loop
5963 body, it pushes the current loop counter. When the loop body
5964 finishes, it pops the ``step,'' i.e., the amount by which to
5965 increment the loop counter. As you can see, our loop always
5968 This harmonic number function uses the stack to hold the running
5969 total as well as for the various loop housekeeping functions. If
5970 you find this disorienting, you can sum in a variable instead:
5974 1: 0 2: 1 . 1: 3.597739
5978 0 t 7 1 @key{RET} 20 Z ( & s + 7 1 Z ) r 7
5983 The @kbd{s +} command adds the top-of-stack into the value in a
5984 variable (and removes that value from the stack).
5986 It's worth noting that many jobs that call for a ``for'' loop can
5987 also be done more easily by Calc's high-level operations. Two
5988 other ways to compute harmonic numbers are to use vector mapping
5989 and reduction (@kbd{v x 20}, then @w{@kbd{V M &}}, then @kbd{V R +}),
5990 or to use the summation command @kbd{a +}. Both of these are
5991 probably easier than using loops. However, there are some
5992 situations where loops really are the way to go:
5994 (@bullet{}) @strong{Exercise 7.} Use a ``for'' loop to find the first
5995 harmonic number which is greater than 4.0.
5996 @xref{Programming Answer 7, 7}. (@bullet{})
5998 Of course, if we're going to be using variables in our programs,
5999 we have to worry about the programs clobbering values that the
6000 caller was keeping in those same variables. This is easy to
6005 . 1: 0.6667 1: 0.6667 3: 0.6667
6010 Z ` p 4 @key{RET} 2 @key{RET} 3 / s 7 s s a @key{RET} Z ' r 7 s r a @key{RET}
6015 When we type @kbd{Z `} (that's a back-quote character), Calc saves
6016 its mode settings and the contents of the ten ``quick variables''
6017 for later reference. When we type @kbd{Z '} (that's an apostrophe
6018 now), Calc restores those saved values. Thus the @kbd{p 4} and
6019 @kbd{s 7} commands have no effect outside this sequence. Wrapping
6020 this around the body of a keyboard macro ensures that it doesn't
6021 interfere with what the user of the macro was doing. Notice that
6022 the contents of the stack, and the values of named variables,
6023 survive past the @kbd{Z '} command.
6025 @cindex Bernoulli numbers, approximate
6026 The @dfn{Bernoulli numbers} are a sequence with the interesting
6027 property that all of the odd Bernoulli numbers are zero, and the
6028 even ones, while difficult to compute, can be roughly approximated
6030 @texline @math{\displaystyle{2 n! \over (2 \pi)^n}}.
6031 @infoline @expr{2 n!@: / (2 pi)^n}.
6032 Let's write a keyboard macro to compute (approximate) Bernoulli numbers.
6033 (Calc has a command, @kbd{k b}, to compute exact Bernoulli numbers, but
6034 this command is very slow for large @expr{n} since the higher Bernoulli
6035 numbers are very large fractions.)
6042 10 C-x ( @key{RET} 2 % Z [ @key{DEL} 0 Z : ' 2 $! / (2 pi)^$ @key{RET} = Z ] C-x )
6047 You can read @kbd{Z [} as ``then,'' @kbd{Z :} as ``else,'' and
6048 @kbd{Z ]} as ``end-if.'' There is no need for an explicit ``if''
6049 command. For the purposes of @w{@kbd{Z [}}, the condition is ``true''
6050 if the value it pops from the stack is a nonzero number, or ``false''
6051 if it pops zero or something that is not a number (like a formula).
6052 Here we take our integer argument modulo 2; this will be nonzero
6053 if we're asking for an odd Bernoulli number.
6055 The actual tenth Bernoulli number is @expr{5/66}.
6059 3: 0.0756823 1: 0 1: 0.25305 1: 0 1: 1.16659
6064 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
6068 Just to exercise loops a bit more, let's compute a table of even
6073 3: [] 1: [0.10132, 0.03079, 0.02340, 0.033197, ...]
6078 [ ] 2 @key{RET} 30 Z ( X | 2 Z )
6083 The vertical-bar @kbd{|} is the vector-concatenation command. When
6084 we execute it, the list we are building will be in stack level 2
6085 (initially this is an empty list), and the next Bernoulli number
6086 will be in level 1. The effect is to append the Bernoulli number
6087 onto the end of the list. (To create a table of exact fractional
6088 Bernoulli numbers, just replace @kbd{X} with @kbd{k b} in the above
6089 sequence of keystrokes.)
6091 With loops and conditionals, you can program essentially anything
6092 in Calc. One other command that makes looping easier is @kbd{Z /},
6093 which takes a condition from the stack and breaks out of the enclosing
6094 loop if the condition is true (non-zero). You can use this to make
6095 ``while'' and ``until'' style loops.
6097 If you make a mistake when entering a keyboard macro, you can edit
6098 it using @kbd{Z E}. First, you must attach it to a key with @kbd{Z K}.
6099 One technique is to enter a throwaway dummy definition for the macro,
6100 then enter the real one in the edit command.
6104 1: 3 1: 3 Calc Macro Edit Mode.
6105 . . Original keys: 1 <return> 2 +
6112 C-x ( 1 @key{RET} 2 + C-x ) Z K h @key{RET} Z E h
6117 A keyboard macro is stored as a pure keystroke sequence. The
6118 @file{edmacro} package (invoked by @kbd{Z E}) scans along the
6119 macro and tries to decode it back into human-readable steps.
6120 Descriptions of the keystrokes are given as comments, which begin with
6121 @samp{;;}, and which are ignored when the edited macro is saved.
6122 Spaces and line breaks are also ignored when the edited macro is saved.
6123 To enter a space into the macro, type @code{SPC}. All the special
6124 characters @code{RET}, @code{LFD}, @code{TAB}, @code{SPC}, @code{DEL},
6125 and @code{NUL} must be written in all uppercase, as must the prefixes
6126 @code{C-} and @code{M-}.
6128 Let's edit in a new definition, for computing harmonic numbers.
6129 First, erase the four lines of the old definition. Then, type
6130 in the new definition (or use Emacs @kbd{M-w} and @kbd{C-y} commands
6131 to copy it from this page of the Info file; you can of course skip
6132 typing the comments, which begin with @samp{;;}).
6135 Z` ;; calc-kbd-push (Save local values)
6136 0 ;; calc digits (Push a zero onto the stack)
6137 st ;; calc-store-into (Store it in the following variable)
6138 1 ;; calc quick variable (Quick variable q1)
6139 1 ;; calc digits (Initial value for the loop)
6140 TAB ;; calc-roll-down (Swap initial and final)
6141 Z( ;; calc-kbd-for (Begin the "for" loop)
6142 & ;; calc-inv (Take the reciprocal)
6143 s+ ;; calc-store-plus (Add to the following variable)
6144 1 ;; calc quick variable (Quick variable q1)
6145 1 ;; calc digits (The loop step is 1)
6146 Z) ;; calc-kbd-end-for (End the "for" loop)
6147 sr ;; calc-recall (Recall the final accumulated value)
6148 1 ;; calc quick variable (Quick variable q1)
6149 Z' ;; calc-kbd-pop (Restore values)
6153 Press @kbd{C-c C-c} to finish editing and return to the Calculator.
6164 The @file{edmacro} package defines a handy @code{read-kbd-macro} command
6165 which reads the current region of the current buffer as a sequence of
6166 keystroke names, and defines that sequence on the @kbd{X}
6167 (and @kbd{C-x e}) key. Because this is so useful, Calc puts this
6168 command on the @kbd{C-x * m} key. Try reading in this macro in the
6169 following form: Press @kbd{C-@@} (or @kbd{C-@key{SPC}}) at
6170 one end of the text below, then type @kbd{C-x * m} at the other.
6182 (@bullet{}) @strong{Exercise 8.} A general algorithm for solving
6183 equations numerically is @dfn{Newton's Method}. Given the equation
6184 @expr{f(x) = 0} for any function @expr{f}, and an initial guess
6185 @expr{x_0} which is reasonably close to the desired solution, apply
6186 this formula over and over:
6190 new_x = x - f(x)/f'(x)
6195 $$ x_{\rm new} = x - {f(x) \over f^{\prime}(x)} $$
6200 where @expr{f'(x)} is the derivative of @expr{f}. The @expr{x}
6201 values will quickly converge to a solution, i.e., eventually
6202 @texline @math{x_{\rm new}}
6203 @infoline @expr{new_x}
6204 and @expr{x} will be equal to within the limits
6205 of the current precision. Write a program which takes a formula
6206 involving the variable @expr{x}, and an initial guess @expr{x_0},
6207 on the stack, and produces a value of @expr{x} for which the formula
6208 is zero. Use it to find a solution of
6209 @texline @math{\sin(\cos x) = 0.5}
6210 @infoline @expr{sin(cos(x)) = 0.5}
6211 near @expr{x = 4.5}. (Use angles measured in radians.) Note that
6212 the built-in @w{@kbd{a R}} (@code{calc-find-root}) command uses Newton's
6213 method when it is able. @xref{Programming Answer 8, 8}. (@bullet{})
6215 @cindex Digamma function
6216 @cindex Gamma constant, Euler's
6217 @cindex Euler's gamma constant
6218 (@bullet{}) @strong{Exercise 9.} The @dfn{digamma} function
6219 @texline @math{\psi(z) (``psi'')}
6220 @infoline @expr{psi(z)}
6221 is defined as the derivative of
6222 @texline @math{\ln \Gamma(z)}.
6223 @infoline @expr{ln(gamma(z))}.
6224 For large values of @expr{z}, it can be approximated by the infinite sum
6228 psi(z) ~= ln(z) - 1/2z - sum(bern(2 n) / 2 n z^(2 n), n, 1, inf)
6233 $$ \psi(z) \approx \ln z - {1\over2z} -
6234 \sum_{n=1}^\infty {\code{bern}(2 n) \over 2 n z^{2n}}
6241 @texline @math{\sum}
6242 @infoline @expr{sum}
6243 represents the sum over @expr{n} from 1 to infinity
6244 (or to some limit high enough to give the desired accuracy), and
6245 the @code{bern} function produces (exact) Bernoulli numbers.
6246 While this sum is not guaranteed to converge, in practice it is safe.
6247 An interesting mathematical constant is Euler's gamma, which is equal
6248 to about 0.5772. One way to compute it is by the formula,
6249 @texline @math{\gamma = -\psi(1)}.
6250 @infoline @expr{gamma = -psi(1)}.
6251 Unfortunately, 1 isn't a large enough argument
6252 for the above formula to work (5 is a much safer value for @expr{z}).
6253 Fortunately, we can compute
6254 @texline @math{\psi(1)}
6255 @infoline @expr{psi(1)}
6257 @texline @math{\psi(5)}
6258 @infoline @expr{psi(5)}
6259 using the recurrence
6260 @texline @math{\psi(z+1) = \psi(z) + {1 \over z}}.
6261 @infoline @expr{psi(z+1) = psi(z) + 1/z}.
6262 Your task: Develop a program to compute
6263 @texline @math{\psi(z)};
6264 @infoline @expr{psi(z)};
6265 it should ``pump up'' @expr{z}
6266 if necessary to be greater than 5, then use the above summation
6267 formula. Use looping commands to compute the sum. Use your function
6269 @texline @math{\gamma}
6270 @infoline @expr{gamma}
6271 to twelve decimal places. (Calc has a built-in command
6272 for Euler's constant, @kbd{I P}, which you can use to check your answer.)
6273 @xref{Programming Answer 9, 9}. (@bullet{})
6275 @cindex Polynomial, list of coefficients
6276 (@bullet{}) @strong{Exercise 10.} Given a polynomial in @expr{x} and
6277 a number @expr{m} on the stack, where the polynomial is of degree
6278 @expr{m} or less (i.e., does not have any terms higher than @expr{x^m}),
6279 write a program to convert the polynomial into a list-of-coefficients
6280 notation. For example, @expr{5 x^4 + (x + 1)^2} with @expr{m = 6}
6281 should produce the list @expr{[1, 2, 1, 0, 5, 0, 0]}. Also develop
6282 a way to convert from this form back to the standard algebraic form.
6283 @xref{Programming Answer 10, 10}. (@bullet{})
6286 (@bullet{}) @strong{Exercise 11.} The @dfn{Stirling numbers of the
6287 first kind} are defined by the recurrences,
6291 s(n,n) = 1 for n >= 0,
6292 s(n,0) = 0 for n > 0,
6293 s(n+1,m) = s(n,m-1) - n s(n,m) for n >= m >= 1.
6298 $$ \eqalign{ s(n,n) &= 1 \qquad \hbox{for } n \ge 0, \cr
6299 s(n,0) &= 0 \qquad \hbox{for } n > 0, \cr
6300 s(n+1,m) &= s(n,m-1) - n \, s(n,m) \qquad
6301 \hbox{for } n \ge m \ge 1.}
6305 (These numbers are also sometimes written $\displaystyle{n \brack m}$.)
6308 This can be implemented using a @dfn{recursive} program in Calc; the
6309 program must invoke itself in order to calculate the two righthand
6310 terms in the general formula. Since it always invokes itself with
6311 ``simpler'' arguments, it's easy to see that it must eventually finish
6312 the computation. Recursion is a little difficult with Emacs keyboard
6313 macros since the macro is executed before its definition is complete.
6314 So here's the recommended strategy: Create a ``dummy macro'' and assign
6315 it to a key with, e.g., @kbd{Z K s}. Now enter the true definition,
6316 using the @kbd{z s} command to call itself recursively, then assign it
6317 to the same key with @kbd{Z K s}. Now the @kbd{z s} command will run
6318 the complete recursive program. (Another way is to use @w{@kbd{Z E}}
6319 or @kbd{C-x * m} (@code{read-kbd-macro}) to read the whole macro at once,
6320 thus avoiding the ``training'' phase.) The task: Write a program
6321 that computes Stirling numbers of the first kind, given @expr{n} and
6322 @expr{m} on the stack. Test it with @emph{small} inputs like
6323 @expr{s(4,2)}. (There is a built-in command for Stirling numbers,
6324 @kbd{k s}, which you can use to check your answers.)
6325 @xref{Programming Answer 11, 11}. (@bullet{})
6327 The programming commands we've seen in this part of the tutorial
6328 are low-level, general-purpose operations. Often you will find
6329 that a higher-level function, such as vector mapping or rewrite
6330 rules, will do the job much more easily than a detailed, step-by-step
6333 (@bullet{}) @strong{Exercise 12.} Write another program for
6334 computing Stirling numbers of the first kind, this time using
6335 rewrite rules. Once again, @expr{n} and @expr{m} should be taken
6336 from the stack. @xref{Programming Answer 12, 12}. (@bullet{})
6341 This ends the tutorial section of the Calc manual. Now you know enough
6342 about Calc to use it effectively for many kinds of calculations. But
6343 Calc has many features that were not even touched upon in this tutorial.
6345 The rest of this manual tells the whole story.
6347 @c Volume II of this manual, the @dfn{Calc Reference}, tells the whole story.
6350 @node Answers to Exercises, , Programming Tutorial, Tutorial
6351 @section Answers to Exercises
6354 This section includes answers to all the exercises in the Calc tutorial.
6357 * RPN Answer 1:: 1 @key{RET} 2 @key{RET} 3 @key{RET} 4 + * -
6358 * RPN Answer 2:: 2*4 + 7*9.5 + 5/4
6359 * RPN Answer 3:: Operating on levels 2 and 3
6360 * RPN Answer 4:: Joe's complex problems
6361 * Algebraic Answer 1:: Simulating Q command
6362 * Algebraic Answer 2:: Joe's algebraic woes
6363 * Algebraic Answer 3:: 1 / 0
6364 * Modes Answer 1:: 3#0.1 = 3#0.0222222?
6365 * Modes Answer 2:: 16#f.e8fe15
6366 * Modes Answer 3:: Joe's rounding bug
6367 * Modes Answer 4:: Why floating point?
6368 * Arithmetic Answer 1:: Why the \ command?
6369 * Arithmetic Answer 2:: Tripping up the B command
6370 * Vector Answer 1:: Normalizing a vector
6371 * Vector Answer 2:: Average position
6372 * Matrix Answer 1:: Row and column sums
6373 * Matrix Answer 2:: Symbolic system of equations
6374 * Matrix Answer 3:: Over-determined system
6375 * List Answer 1:: Powers of two
6376 * List Answer 2:: Least-squares fit with matrices
6377 * List Answer 3:: Geometric mean
6378 * List Answer 4:: Divisor function
6379 * List Answer 5:: Duplicate factors
6380 * List Answer 6:: Triangular list
6381 * List Answer 7:: Another triangular list
6382 * List Answer 8:: Maximum of Bessel function
6383 * List Answer 9:: Integers the hard way
6384 * List Answer 10:: All elements equal
6385 * List Answer 11:: Estimating pi with darts
6386 * List Answer 12:: Estimating pi with matchsticks
6387 * List Answer 13:: Hash codes
6388 * List Answer 14:: Random walk
6389 * Types Answer 1:: Square root of pi times rational
6390 * Types Answer 2:: Infinities
6391 * Types Answer 3:: What can "nan" be?
6392 * Types Answer 4:: Abbey Road
6393 * Types Answer 5:: Friday the 13th
6394 * Types Answer 6:: Leap years
6395 * Types Answer 7:: Erroneous donut
6396 * Types Answer 8:: Dividing intervals
6397 * Types Answer 9:: Squaring intervals
6398 * Types Answer 10:: Fermat's primality test
6399 * Types Answer 11:: pi * 10^7 seconds
6400 * Types Answer 12:: Abbey Road on CD
6401 * Types Answer 13:: Not quite pi * 10^7 seconds
6402 * Types Answer 14:: Supercomputers and c
6403 * Types Answer 15:: Sam the Slug
6404 * Algebra Answer 1:: Squares and square roots
6405 * Algebra Answer 2:: Building polynomial from roots
6406 * Algebra Answer 3:: Integral of x sin(pi x)
6407 * Algebra Answer 4:: Simpson's rule
6408 * Rewrites Answer 1:: Multiplying by conjugate
6409 * Rewrites Answer 2:: Alternative fib rule
6410 * Rewrites Answer 3:: Rewriting opt(a) + opt(b) x
6411 * Rewrites Answer 4:: Sequence of integers
6412 * Rewrites Answer 5:: Number of terms in sum
6413 * Rewrites Answer 6:: Truncated Taylor series
6414 * Programming Answer 1:: Fresnel's C(x)
6415 * Programming Answer 2:: Negate third stack element
6416 * Programming Answer 3:: Compute sin(x) / x, etc.
6417 * Programming Answer 4:: Average value of a list
6418 * Programming Answer 5:: Continued fraction phi
6419 * Programming Answer 6:: Matrix Fibonacci numbers
6420 * Programming Answer 7:: Harmonic number greater than 4
6421 * Programming Answer 8:: Newton's method
6422 * Programming Answer 9:: Digamma function
6423 * Programming Answer 10:: Unpacking a polynomial
6424 * Programming Answer 11:: Recursive Stirling numbers
6425 * Programming Answer 12:: Stirling numbers with rewrites
6428 @c The following kludgery prevents the individual answers from
6429 @c being entered on the table of contents.
6431 \global\let\oldwrite=\write
6432 \gdef\skipwrite#1#2{\let\write=\oldwrite}
6433 \global\let\oldchapternofonts=\chapternofonts
6434 \gdef\chapternofonts{\let\write=\skipwrite\oldchapternofonts}
6437 @node RPN Answer 1, RPN Answer 2, Answers to Exercises, Answers to Exercises
6438 @subsection RPN Tutorial Exercise 1
6441 @kbd{1 @key{RET} 2 @key{RET} 3 @key{RET} 4 + * -}
6444 @texline @math{1 - (2 \times (3 + 4)) = -13}.
6445 @infoline @expr{1 - (2 * (3 + 4)) = -13}.
6447 @node RPN Answer 2, RPN Answer 3, RPN Answer 1, Answers to Exercises
6448 @subsection RPN Tutorial Exercise 2
6451 @texline @math{2\times4 + 7\times9.5 + {5\over4} = 75.75}
6452 @infoline @expr{2*4 + 7*9.5 + 5/4 = 75.75}
6454 After computing the intermediate term
6455 @texline @math{2\times4 = 8},
6456 @infoline @expr{2*4 = 8},
6457 you can leave that result on the stack while you compute the second
6458 term. With both of these results waiting on the stack you can then
6459 compute the final term, then press @kbd{+ +} to add everything up.
6468 2 @key{RET} 4 * 7 @key{RET} 9.5 *
6475 4: 8 3: 8 2: 8 1: 75.75
6476 3: 66.5 2: 66.5 1: 67.75 .
6485 Alternatively, you could add the first two terms before going on
6486 with the third term.
6490 2: 8 1: 74.5 3: 74.5 2: 74.5 1: 75.75
6491 1: 66.5 . 2: 5 1: 1.25 .
6495 ... + 5 @key{RET} 4 / +
6499 On an old-style RPN calculator this second method would have the
6500 advantage of using only three stack levels. But since Calc's stack
6501 can grow arbitrarily large this isn't really an issue. Which method
6502 you choose is purely a matter of taste.
6504 @node RPN Answer 3, RPN Answer 4, RPN Answer 2, Answers to Exercises
6505 @subsection RPN Tutorial Exercise 3
6508 The @key{TAB} key provides a way to operate on the number in level 2.
6512 3: 10 3: 10 4: 10 3: 10 3: 10
6513 2: 20 2: 30 3: 30 2: 30 2: 21
6514 1: 30 1: 20 2: 20 1: 21 1: 30
6518 @key{TAB} 1 + @key{TAB}
6522 Similarly, @kbd{M-@key{TAB}} gives you access to the number in level 3.
6526 3: 10 3: 21 3: 21 3: 30 3: 11
6527 2: 21 2: 30 2: 30 2: 11 2: 21
6528 1: 30 1: 10 1: 11 1: 21 1: 30
6531 M-@key{TAB} 1 + M-@key{TAB} M-@key{TAB}
6535 @node RPN Answer 4, Algebraic Answer 1, RPN Answer 3, Answers to Exercises
6536 @subsection RPN Tutorial Exercise 4
6539 Either @kbd{( 2 , 3 )} or @kbd{( 2 @key{SPC} 3 )} would have worked,
6540 but using both the comma and the space at once yields:
6544 1: ( ... 2: ( ... 1: (2, ... 2: (2, ... 2: (2, ...
6545 . 1: 2 . 1: (2, ... 1: (2, 3)
6552 Joe probably tried to type @kbd{@key{TAB} @key{DEL}} to swap the
6553 extra incomplete object to the top of the stack and delete it.
6554 But a feature of Calc is that @key{DEL} on an incomplete object
6555 deletes just one component out of that object, so he had to press
6556 @key{DEL} twice to finish the job.
6560 2: (2, ... 2: (2, 3) 2: (2, 3) 1: (2, 3)
6561 1: (2, 3) 1: (2, ... 1: ( ... .
6564 @key{TAB} @key{DEL} @key{DEL}
6568 (As it turns out, deleting the second-to-top stack entry happens often
6569 enough that Calc provides a special key, @kbd{M-@key{DEL}}, to do just that.
6570 @kbd{M-@key{DEL}} is just like @kbd{@key{TAB} @key{DEL}}, except that it doesn't exhibit
6571 the ``feature'' that tripped poor Joe.)
6573 @node Algebraic Answer 1, Algebraic Answer 2, RPN Answer 4, Answers to Exercises
6574 @subsection Algebraic Entry Tutorial Exercise 1
6577 Type @kbd{' sqrt($) @key{RET}}.
6579 If the @kbd{Q} key is broken, you could use @kbd{' $^0.5 @key{RET}}.
6580 Or, RPN style, @kbd{0.5 ^}.
6582 (Actually, @samp{$^1:2}, using the fraction one-half as the power, is
6583 a closer equivalent, since @samp{9^0.5} yields @expr{3.0} whereas
6584 @samp{sqrt(9)} and @samp{9^1:2} yield the exact integer @expr{3}.)
6586 @node Algebraic Answer 2, Algebraic Answer 3, Algebraic Answer 1, Answers to Exercises
6587 @subsection Algebraic Entry Tutorial Exercise 2
6590 In the formula @samp{2 x (1+y)}, @samp{x} was interpreted as a function
6591 name with @samp{1+y} as its argument. Assigning a value to a variable
6592 has no relation to a function by the same name. Joe needed to use an
6593 explicit @samp{*} symbol here: @samp{2 x*(1+y)}.
6595 @node Algebraic Answer 3, Modes Answer 1, Algebraic Answer 2, Answers to Exercises
6596 @subsection Algebraic Entry Tutorial Exercise 3
6599 The result from @kbd{1 @key{RET} 0 /} will be the formula @expr{1 / 0}.
6600 The ``function'' @samp{/} cannot be evaluated when its second argument
6601 is zero, so it is left in symbolic form. When you now type @kbd{0 *},
6602 the result will be zero because Calc uses the general rule that ``zero
6603 times anything is zero.''
6605 @c [fix-ref Infinities]
6606 The @kbd{m i} command enables an @dfn{Infinite mode} in which @expr{1 / 0}
6607 results in a special symbol that represents ``infinity.'' If you
6608 multiply infinity by zero, Calc uses another special new symbol to
6609 show that the answer is ``indeterminate.'' @xref{Infinities}, for
6610 further discussion of infinite and indeterminate values.
6612 @node Modes Answer 1, Modes Answer 2, Algebraic Answer 3, Answers to Exercises
6613 @subsection Modes Tutorial Exercise 1
6616 Calc always stores its numbers in decimal, so even though one-third has
6617 an exact base-3 representation (@samp{3#0.1}), it is still stored as
6618 0.3333333 (chopped off after 12 or however many decimal digits) inside
6619 the calculator's memory. When this inexact number is converted back
6620 to base 3 for display, it may still be slightly inexact. When we
6621 multiply this number by 3, we get 0.999999, also an inexact value.
6623 When Calc displays a number in base 3, it has to decide how many digits
6624 to show. If the current precision is 12 (decimal) digits, that corresponds
6625 to @samp{12 / log10(3) = 25.15} base-3 digits. Because 25.15 is not an
6626 exact integer, Calc shows only 25 digits, with the result that stored
6627 numbers carry a little bit of extra information that may not show up on
6628 the screen. When Joe entered @samp{3#0.2}, the stored number 0.666666
6629 happened to round to a pleasing value when it lost that last 0.15 of a
6630 digit, but it was still inexact in Calc's memory. When he divided by 2,
6631 he still got the dreaded inexact value 0.333333. (Actually, he divided
6632 0.666667 by 2 to get 0.333334, which is why he got something a little
6633 higher than @code{3#0.1} instead of a little lower.)
6635 If Joe didn't want to be bothered with all this, he could have typed
6636 @kbd{M-24 d n} to display with one less digit than the default. (If
6637 you give @kbd{d n} a negative argument, it uses default-minus-that,
6638 so @kbd{M-- d n} would be an easier way to get the same effect.) Those
6639 inexact results would still be lurking there, but they would now be
6640 rounded to nice, natural-looking values for display purposes. (Remember,
6641 @samp{0.022222} in base 3 is like @samp{0.099999} in base 10; rounding
6642 off one digit will round the number up to @samp{0.1}.) Depending on the
6643 nature of your work, this hiding of the inexactness may be a benefit or
6644 a danger. With the @kbd{d n} command, Calc gives you the choice.
6646 Incidentally, another consequence of all this is that if you type
6647 @kbd{M-30 d n} to display more digits than are ``really there,''
6648 you'll see garbage digits at the end of the number. (In decimal
6649 display mode, with decimally-stored numbers, these garbage digits are
6650 always zero so they vanish and you don't notice them.) Because Calc
6651 rounds off that 0.15 digit, there is the danger that two numbers could
6652 be slightly different internally but still look the same. If you feel
6653 uneasy about this, set the @kbd{d n} precision to be a little higher
6654 than normal; you'll get ugly garbage digits, but you'll always be able
6655 to tell two distinct numbers apart.
6657 An interesting side note is that most computers store their
6658 floating-point numbers in binary, and convert to decimal for display.
6659 Thus everyday programs have the same problem: Decimal 0.1 cannot be
6660 represented exactly in binary (try it: @kbd{0.1 d 2}), so @samp{0.1 * 10}
6661 comes out as an inexact approximation to 1 on some machines (though
6662 they generally arrange to hide it from you by rounding off one digit as
6663 we did above). Because Calc works in decimal instead of binary, you can
6664 be sure that numbers that look exact @emph{are} exact as long as you stay
6665 in decimal display mode.
6667 It's not hard to show that any number that can be represented exactly
6668 in binary, octal, or hexadecimal is also exact in decimal, so the kinds
6669 of problems we saw in this exercise are likely to be severe only when
6670 you use a relatively unusual radix like 3.
6672 @node Modes Answer 2, Modes Answer 3, Modes Answer 1, Answers to Exercises
6673 @subsection Modes Tutorial Exercise 2
6675 If the radix is 15 or higher, we can't use the letter @samp{e} to mark
6676 the exponent because @samp{e} is interpreted as a digit. When Calc
6677 needs to display scientific notation in a high radix, it writes
6678 @samp{16#F.E8F*16.^15}. You can enter a number like this as an
6679 algebraic entry. Also, pressing @kbd{e} without any digits before it
6680 normally types @kbd{1e}, but in a high radix it types @kbd{16.^} and
6681 puts you in algebraic entry: @kbd{16#f.e8f @key{RET} e 15 @key{RET} *} is another
6682 way to enter this number.
6684 The reason Calc puts a decimal point in the @samp{16.^} is to prevent
6685 huge integers from being generated if the exponent is large (consider
6686 @samp{16#1.23*16^1000}, where we compute @samp{16^1000} as a giant
6687 exact integer and then throw away most of the digits when we multiply
6688 it by the floating-point @samp{16#1.23}). While this wouldn't normally
6689 matter for display purposes, it could give you a nasty surprise if you
6690 copied that number into a file and later moved it back into Calc.
6692 @node Modes Answer 3, Modes Answer 4, Modes Answer 2, Answers to Exercises
6693 @subsection Modes Tutorial Exercise 3
6696 The answer he got was @expr{0.5000000000006399}.
6698 The problem is not that the square operation is inexact, but that the
6699 sine of 45 that was already on the stack was accurate to only 12 places.
6700 Arbitrary-precision calculations still only give answers as good as
6703 The real problem is that there is no 12-digit number which, when
6704 squared, comes out to 0.5 exactly. The @kbd{f [} and @kbd{f ]}
6705 commands decrease or increase a number by one unit in the last
6706 place (according to the current precision). They are useful for
6707 determining facts like this.
6711 1: 0.707106781187 1: 0.500000000001
6721 1: 0.707106781187 1: 0.707106781186 1: 0.499999999999
6728 A high-precision calculation must be carried out in high precision
6729 all the way. The only number in the original problem which was known
6730 exactly was the quantity 45 degrees, so the precision must be raised
6731 before anything is done after the number 45 has been entered in order
6732 for the higher precision to be meaningful.
6734 @node Modes Answer 4, Arithmetic Answer 1, Modes Answer 3, Answers to Exercises
6735 @subsection Modes Tutorial Exercise 4
6738 Many calculations involve real-world quantities, like the width and
6739 height of a piece of wood or the volume of a jar. Such quantities
6740 can't be measured exactly anyway, and if the data that is input to
6741 a calculation is inexact, doing exact arithmetic on it is a waste
6744 Fractions become unwieldy after too many calculations have been
6745 done with them. For example, the sum of the reciprocals of the
6746 integers from 1 to 10 is 7381:2520. The sum from 1 to 30 is
6747 9304682830147:2329089562800. After a point it will take a long
6748 time to add even one more term to this sum, but a floating-point
6749 calculation of the sum will not have this problem.
6751 Also, rational numbers cannot express the results of all calculations.
6752 There is no fractional form for the square root of two, so if you type
6753 @w{@kbd{2 Q}}, Calc has no choice but to give you a floating-point answer.
6755 @node Arithmetic Answer 1, Arithmetic Answer 2, Modes Answer 4, Answers to Exercises
6756 @subsection Arithmetic Tutorial Exercise 1
6759 Dividing two integers that are larger than the current precision may
6760 give a floating-point result that is inaccurate even when rounded
6761 down to an integer. Consider @expr{123456789 / 2} when the current
6762 precision is 6 digits. The true answer is @expr{61728394.5}, but
6763 with a precision of 6 this will be rounded to
6764 @texline @math{12345700.0/2.0 = 61728500.0}.
6765 @infoline @expr{12345700.@: / 2.@: = 61728500.}.
6766 The result, when converted to an integer, will be off by 106.
6768 Here are two solutions: Raise the precision enough that the
6769 floating-point round-off error is strictly to the right of the
6770 decimal point. Or, convert to Fraction mode so that @expr{123456789 / 2}
6771 produces the exact fraction @expr{123456789:2}, which can be rounded
6772 down by the @kbd{F} command without ever switching to floating-point
6775 @node Arithmetic Answer 2, Vector Answer 1, Arithmetic Answer 1, Answers to Exercises
6776 @subsection Arithmetic Tutorial Exercise 2
6779 @kbd{27 @key{RET} 9 B} could give the exact result @expr{3:2}, but it
6780 does a floating-point calculation instead and produces @expr{1.5}.
6782 Calc will find an exact result for a logarithm if the result is an integer
6783 or (when in Fraction mode) the reciprocal of an integer. But there is
6784 no efficient way to search the space of all possible rational numbers
6785 for an exact answer, so Calc doesn't try.
6787 @node Vector Answer 1, Vector Answer 2, Arithmetic Answer 2, Answers to Exercises
6788 @subsection Vector Tutorial Exercise 1
6791 Duplicate the vector, compute its length, then divide the vector
6792 by its length: @kbd{@key{RET} A /}.
6796 1: [1, 2, 3] 2: [1, 2, 3] 1: [0.27, 0.53, 0.80] 1: 1.
6797 . 1: 3.74165738677 . .
6804 The final @kbd{A} command shows that the normalized vector does
6805 indeed have unit length.
6807 @node Vector Answer 2, Matrix Answer 1, Vector Answer 1, Answers to Exercises
6808 @subsection Vector Tutorial Exercise 2
6811 The average position is equal to the sum of the products of the
6812 positions times their corresponding probabilities. This is the
6813 definition of the dot product operation. So all you need to do
6814 is to put the two vectors on the stack and press @kbd{*}.
6816 @node Matrix Answer 1, Matrix Answer 2, Vector Answer 2, Answers to Exercises
6817 @subsection Matrix Tutorial Exercise 1
6820 The trick is to multiply by a vector of ones. Use @kbd{r 4 [1 1 1] *} to
6821 get the row sum. Similarly, use @kbd{[1 1] r 4 *} to get the column sum.
6823 @node Matrix Answer 2, Matrix Answer 3, Matrix Answer 1, Answers to Exercises
6824 @subsection Matrix Tutorial Exercise 2
6836 $$ \eqalign{ x &+ a y = 6 \cr
6842 Just enter the righthand side vector, then divide by the lefthand side
6847 1: [6, 10] 2: [6, 10] 1: [4 a / (a - b) + 6, 4 / (b - a) ]
6852 ' [6 10] @key{RET} ' [1 a; 1 b] @key{RET} /
6856 This can be made more readable using @kbd{d B} to enable Big display
6862 1: [----- + 6, -----]
6867 Type @kbd{d N} to return to Normal display mode afterwards.
6869 @node Matrix Answer 3, List Answer 1, Matrix Answer 2, Answers to Exercises
6870 @subsection Matrix Tutorial Exercise 3
6874 @texline @math{A^T A \, X = A^T B},
6875 @infoline @expr{trn(A) * A * X = trn(A) * B},
6877 @texline @math{A' = A^T A}
6878 @infoline @expr{A2 = trn(A) * A}
6880 @texline @math{B' = A^T B};
6881 @infoline @expr{B2 = trn(A) * B};
6882 now, we have a system
6883 @texline @math{A' X = B'}
6884 @infoline @expr{A2 * X = B2}
6885 which we can solve using Calc's @samp{/} command.
6899 $$ \openup1\jot \tabskip=0pt plus1fil
6900 \halign to\displaywidth{\tabskip=0pt
6901 $\hfil#$&$\hfil{}#{}$&
6902 $\hfil#$&$\hfil{}#{}$&
6903 $\hfil#$&${}#\hfil$\tabskip=0pt plus1fil\cr
6907 2a&+&4b&+&6c&=11 \cr}
6912 The first step is to enter the coefficient matrix. We'll store it in
6913 quick variable number 7 for later reference. Next, we compute the
6920 1: [ [ 1, 2, 3 ] 2: [ [ 1, 4, 7, 2 ] 1: [57, 84, 96]
6921 [ 4, 5, 6 ] [ 2, 5, 6, 4 ] .
6922 [ 7, 6, 0 ] [ 3, 6, 0, 6 ] ]
6923 [ 2, 4, 6 ] ] 1: [6, 2, 3, 11]
6926 ' [1 2 3; 4 5 6; 7 6 0; 2 4 6] @key{RET} s 7 v t [6 2 3 11] *
6931 Now we compute the matrix
6938 2: [57, 84, 96] 1: [-11.64, 14.08, -3.64]
6939 1: [ [ 70, 72, 39 ] .
6949 (The actual computed answer will be slightly inexact due to
6952 Notice that the answers are similar to those for the
6953 @texline @math{3\times3}
6955 system solved in the text. That's because the fourth equation that was
6956 added to the system is almost identical to the first one multiplied
6957 by two. (If it were identical, we would have gotten the exact same
6959 @texline @math{4\times3}
6961 system would be equivalent to the original
6962 @texline @math{3\times3}
6966 Since the first and fourth equations aren't quite equivalent, they
6967 can't both be satisfied at once. Let's plug our answers back into
6968 the original system of equations to see how well they match.
6972 2: [-11.64, 14.08, -3.64] 1: [5.6, 2., 3., 11.2]
6984 This is reasonably close to our original @expr{B} vector,
6985 @expr{[6, 2, 3, 11]}.
6987 @node List Answer 1, List Answer 2, Matrix Answer 3, Answers to Exercises
6988 @subsection List Tutorial Exercise 1
6991 We can use @kbd{v x} to build a vector of integers. This needs to be
6992 adjusted to get the range of integers we desire. Mapping @samp{-}
6993 across the vector will accomplish this, although it turns out the
6994 plain @samp{-} key will work just as well.
6999 1: [1, 2, 3, 4, 5, 6, 7, 8, 9] 1: [-4, -3, -2, -1, 0, 1, 2, 3, 4]
7002 2 v x 9 @key{RET} 5 V M - or 5 -
7007 Now we use @kbd{V M ^} to map the exponentiation operator across the
7012 1: [0.0625, 0.125, 0.25, 0.5, 1, 2, 4, 8, 16]
7019 @node List Answer 2, List Answer 3, List Answer 1, Answers to Exercises
7020 @subsection List Tutorial Exercise 2
7023 Given @expr{x} and @expr{y} vectors in quick variables 1 and 2 as before,
7024 the first job is to form the matrix that describes the problem.
7033 $$ m \times x + b \times 1 = y $$
7038 @texline @math{19\times2}
7040 matrix with our @expr{x} vector as one column and
7041 ones as the other column. So, first we build the column of ones, then
7042 we combine the two columns to form our @expr{A} matrix.
7046 2: [1.34, 1.41, 1.49, ... ] 1: [ [ 1.34, 1 ]
7047 1: [1, 1, 1, ...] [ 1.41, 1 ]
7051 r 1 1 v b 19 @key{RET} M-2 v p v t s 3
7057 @texline @math{A^T y}
7058 @infoline @expr{trn(A) * y}
7060 @texline @math{A^T A}
7061 @infoline @expr{trn(A) * A}
7066 1: [33.36554, 13.613] 2: [33.36554, 13.613]
7067 . 1: [ [ 98.0003, 41.63 ]
7071 v t r 2 * r 3 v t r 3 *
7076 (Hey, those numbers look familiar!)
7080 1: [0.52141679, -0.425978]
7087 Since we were solving equations of the form
7088 @texline @math{m \times x + b \times 1 = y},
7089 @infoline @expr{m*x + b*1 = y},
7090 these numbers should be @expr{m} and @expr{b}, respectively. Sure
7091 enough, they agree exactly with the result computed using @kbd{V M} and
7094 The moral of this story: @kbd{V M} and @kbd{V R} will probably solve
7095 your problem, but there is often an easier way using the higher-level
7096 arithmetic functions!
7098 @c [fix-ref Curve Fitting]
7099 In fact, there is a built-in @kbd{a F} command that does least-squares
7100 fits. @xref{Curve Fitting}.
7102 @node List Answer 3, List Answer 4, List Answer 2, Answers to Exercises
7103 @subsection List Tutorial Exercise 3
7106 Move to one end of the list and press @kbd{C-@@} (or @kbd{C-@key{SPC}} or
7107 whatever) to set the mark, then move to the other end of the list
7108 and type @w{@kbd{C-x * g}}.
7112 1: [2.3, 6, 22, 15.1, 7, 15, 14, 7.5, 2.5]
7117 To make things interesting, let's assume we don't know at a glance
7118 how many numbers are in this list. Then we could type:
7122 2: [2.3, 6, 22, ... ] 2: [2.3, 6, 22, ... ]
7123 1: [2.3, 6, 22, ... ] 1: 126356422.5
7133 2: 126356422.5 2: 126356422.5 1: 7.94652913734
7134 1: [2.3, 6, 22, ... ] 1: 9 .
7142 (The @kbd{I ^} command computes the @var{n}th root of a number.
7143 You could also type @kbd{& ^} to take the reciprocal of 9 and
7144 then raise the number to that power.)
7146 @node List Answer 4, List Answer 5, List Answer 3, Answers to Exercises
7147 @subsection List Tutorial Exercise 4
7150 A number @expr{j} is a divisor of @expr{n} if
7151 @texline @math{n \mathbin{\hbox{\code{\%}}} j = 0}.
7152 @infoline @samp{n % j = 0}.
7153 The first step is to get a vector that identifies the divisors.
7157 2: 30 2: [0, 0, 0, 2, ...] 1: [1, 1, 1, 0, ...]
7158 1: [1, 2, 3, 4, ...] 1: 0 .
7161 30 @key{RET} v x 30 @key{RET} s 1 V M % 0 V M a = s 2
7166 This vector has 1's marking divisors of 30 and 0's marking non-divisors.
7168 The zeroth divisor function is just the total number of divisors.
7169 The first divisor function is the sum of the divisors.
7174 2: [1, 2, 3, 4, ...] 1: [1, 2, 3, 0, ...] 1: 72
7175 1: [1, 1, 1, 0, ...] . .
7178 V R + r 1 r 2 V M * V R +
7183 Once again, the last two steps just compute a dot product for which
7184 a simple @kbd{*} would have worked equally well.
7186 @node List Answer 5, List Answer 6, List Answer 4, Answers to Exercises
7187 @subsection List Tutorial Exercise 5
7190 The obvious first step is to obtain the list of factors with @kbd{k f}.
7191 This list will always be in sorted order, so if there are duplicates
7192 they will be right next to each other. A suitable method is to compare
7193 the list with a copy of itself shifted over by one.
7197 1: [3, 7, 7, 7, 19] 2: [3, 7, 7, 7, 19] 2: [3, 7, 7, 7, 19, 0]
7198 . 1: [3, 7, 7, 7, 19, 0] 1: [0, 3, 7, 7, 7, 19]
7201 19551 k f @key{RET} 0 | @key{TAB} 0 @key{TAB} |
7208 1: [0, 0, 1, 1, 0, 0] 1: 2 1: 0
7216 Note that we have to arrange for both vectors to have the same length
7217 so that the mapping operation works; no prime factor will ever be
7218 zero, so adding zeros on the left and right is safe. From then on
7219 the job is pretty straightforward.
7221 Incidentally, Calc provides the
7222 @texline @dfn{M@"obius} @math{\mu}
7223 @infoline @dfn{Moebius mu}
7224 function which is zero if and only if its argument is square-free. It
7225 would be a much more convenient way to do the above test in practice.
7227 @node List Answer 6, List Answer 7, List Answer 5, Answers to Exercises
7228 @subsection List Tutorial Exercise 6
7231 First use @kbd{v x 6 @key{RET}} to get a list of integers, then @kbd{V M v x}
7232 to get a list of lists of integers!
7234 @node List Answer 7, List Answer 8, List Answer 6, Answers to Exercises
7235 @subsection List Tutorial Exercise 7
7238 Here's one solution. First, compute the triangular list from the previous
7239 exercise and type @kbd{1 -} to subtract one from all the elements.
7252 The numbers down the lefthand edge of the list we desire are called
7253 the ``triangular numbers'' (now you know why!). The @expr{n}th
7254 triangular number is the sum of the integers from 1 to @expr{n}, and
7255 can be computed directly by the formula
7256 @texline @math{n (n+1) \over 2}.
7257 @infoline @expr{n * (n+1) / 2}.
7261 2: [ [0], [0, 1], ... ] 2: [ [0], [0, 1], ... ]
7262 1: [0, 1, 2, 3, 4, 5] 1: [0, 1, 3, 6, 10, 15]
7265 v x 6 @key{RET} 1 - V M ' $ ($+1)/2 @key{RET}
7270 Adding this list to the above list of lists produces the desired
7279 [10, 11, 12, 13, 14],
7280 [15, 16, 17, 18, 19, 20] ]
7287 If we did not know the formula for triangular numbers, we could have
7288 computed them using a @kbd{V U +} command. We could also have
7289 gotten them the hard way by mapping a reduction across the original
7294 2: [ [0], [0, 1], ... ] 2: [ [0], [0, 1], ... ]
7295 1: [ [0], [0, 1], ... ] 1: [0, 1, 3, 6, 10, 15]
7303 (This means ``map a @kbd{V R +} command across the vector,'' and
7304 since each element of the main vector is itself a small vector,
7305 @kbd{V R +} computes the sum of its elements.)
7307 @node List Answer 8, List Answer 9, List Answer 7, Answers to Exercises
7308 @subsection List Tutorial Exercise 8
7311 The first step is to build a list of values of @expr{x}.
7315 1: [1, 2, 3, ..., 21] 1: [0, 1, 2, ..., 20] 1: [0, 0.25, 0.5, ..., 5]
7318 v x 21 @key{RET} 1 - 4 / s 1
7322 Next, we compute the Bessel function values.
7326 1: [0., 0.124, 0.242, ..., -0.328]
7329 V M ' besJ(1,$) @key{RET}
7334 (Another way to do this would be @kbd{1 @key{TAB} V M f j}.)
7336 A way to isolate the maximum value is to compute the maximum using
7337 @kbd{V R X}, then compare all the Bessel values with that maximum.
7341 2: [0., 0.124, 0.242, ... ] 1: [0, 0, 0, ... ] 2: [0, 0, 0, ... ]
7345 @key{RET} V R X V M a = @key{RET} V R + @key{DEL}
7350 It's a good idea to verify, as in the last step above, that only
7351 one value is equal to the maximum. (After all, a plot of
7352 @texline @math{\sin x}
7353 @infoline @expr{sin(x)}
7354 might have many points all equal to the maximum value, 1.)
7356 The vector we have now has a single 1 in the position that indicates
7357 the maximum value of @expr{x}. Now it is a simple matter to convert
7358 this back into the corresponding value itself.
7362 2: [0, 0, 0, ... ] 1: [0, 0., 0., ... ] 1: 1.75
7363 1: [0, 0.25, 0.5, ... ] . .
7370 If @kbd{a =} had produced more than one @expr{1} value, this method
7371 would have given the sum of all maximum @expr{x} values; not very
7372 useful! In this case we could have used @kbd{v m} (@code{calc-mask-vector})
7373 instead. This command deletes all elements of a ``data'' vector that
7374 correspond to zeros in a ``mask'' vector, leaving us with, in this
7375 example, a vector of maximum @expr{x} values.
7377 The built-in @kbd{a X} command maximizes a function using more
7378 efficient methods. Just for illustration, let's use @kbd{a X}
7379 to maximize @samp{besJ(1,x)} over this same interval.
7383 2: besJ(1, x) 1: [1.84115, 0.581865]
7387 ' besJ(1,x), [0..5] @key{RET} a X x @key{RET}
7392 The output from @kbd{a X} is a vector containing the value of @expr{x}
7393 that maximizes the function, and the function's value at that maximum.
7394 As you can see, our simple search got quite close to the right answer.
7396 @node List Answer 9, List Answer 10, List Answer 8, Answers to Exercises
7397 @subsection List Tutorial Exercise 9
7400 Step one is to convert our integer into vector notation.
7404 1: 25129925999 3: 25129925999
7406 1: [11, 10, 9, ..., 1, 0]
7409 25129925999 @key{RET} 10 @key{RET} 12 @key{RET} v x 12 @key{RET} -
7416 1: 25129925999 1: [0, 2, 25, 251, 2512, ... ]
7417 2: [100000000000, ... ] .
7425 (Recall, the @kbd{\} command computes an integer quotient.)
7429 1: [0, 2, 5, 1, 2, 9, 9, 2, 5, 9, 9, 9]
7436 Next we must increment this number. This involves adding one to
7437 the last digit, plus handling carries. There is a carry to the
7438 left out of a digit if that digit is a nine and all the digits to
7439 the right of it are nines.
7443 1: [0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1] 1: [1, 1, 1, 0, 0, 1, ... ]
7453 1: [1, 1, 1, 0, 0, 0, ... ] 1: [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1]
7461 Accumulating @kbd{*} across a vector of ones and zeros will preserve
7462 only the initial run of ones. These are the carries into all digits
7463 except the rightmost digit. Concatenating a one on the right takes
7464 care of aligning the carries properly, and also adding one to the
7469 2: [0, 0, 0, 0, ... ] 1: [0, 0, 2, 5, 1, 2, 9, 9, 2, 6, 0, 0, 0]
7470 1: [0, 0, 2, 5, ... ] .
7473 0 r 2 | V M + 10 V M %
7478 Here we have concatenated 0 to the @emph{left} of the original number;
7479 this takes care of shifting the carries by one with respect to the
7480 digits that generated them.
7482 Finally, we must convert this list back into an integer.
7486 3: [0, 0, 2, 5, ... ] 2: [0, 0, 2, 5, ... ]
7487 2: 1000000000000 1: [1000000000000, 100000000000, ... ]
7488 1: [100000000000, ... ] .
7491 10 @key{RET} 12 ^ r 1 |
7498 1: [0, 0, 20000000000, 5000000000, ... ] 1: 25129926000
7506 Another way to do this final step would be to reduce the formula
7507 @w{@samp{10 $$ + $}} across the vector of digits.
7511 1: [0, 0, 2, 5, ... ] 1: 25129926000
7514 V R ' 10 $$ + $ @key{RET}
7518 @node List Answer 10, List Answer 11, List Answer 9, Answers to Exercises
7519 @subsection List Tutorial Exercise 10
7522 For the list @expr{[a, b, c, d]}, the result is @expr{((a = b) = c) = d},
7523 which will compare @expr{a} and @expr{b} to produce a 1 or 0, which is
7524 then compared with @expr{c} to produce another 1 or 0, which is then
7525 compared with @expr{d}. This is not at all what Joe wanted.
7527 Here's a more correct method:
7531 1: [7, 7, 7, 8, 7] 2: [7, 7, 7, 8, 7]
7535 ' [7,7,7,8,7] @key{RET} @key{RET} v r 1 @key{RET}
7542 1: [1, 1, 1, 0, 1] 1: 0
7549 @node List Answer 11, List Answer 12, List Answer 10, Answers to Exercises
7550 @subsection List Tutorial Exercise 11
7553 The circle of unit radius consists of those points @expr{(x,y)} for which
7554 @expr{x^2 + y^2 < 1}. We start by generating a vector of @expr{x^2}
7555 and a vector of @expr{y^2}.
7557 We can make this go a bit faster by using the @kbd{v .} and @kbd{t .}
7562 2: [2., 2., ..., 2.] 2: [2., 2., ..., 2.]
7563 1: [2., 2., ..., 2.] 1: [1.16, 1.98, ..., 0.81]
7566 v . t . 2. v b 100 @key{RET} @key{RET} V M k r
7573 2: [2., 2., ..., 2.] 1: [0.026, 0.96, ..., 0.036]
7574 1: [0.026, 0.96, ..., 0.036] 2: [0.53, 0.81, ..., 0.094]
7577 1 - 2 V M ^ @key{TAB} V M k r 1 - 2 V M ^
7581 Now we sum the @expr{x^2} and @expr{y^2} values, compare with 1 to
7582 get a vector of 1/0 truth values, then sum the truth values.
7586 1: [0.56, 1.78, ..., 0.13] 1: [1, 0, ..., 1] 1: 84
7594 The ratio @expr{84/100} should approximate the ratio @cpiover{4}.
7598 1: 0.84 1: 3.36 2: 3.36 1: 1.0695
7606 Our estimate, 3.36, is off by about 7%. We could get a better estimate
7607 by taking more points (say, 1000), but it's clear that this method is
7610 (Naturally, since this example uses random numbers your own answer
7611 will be slightly different from the one shown here!)
7613 If you typed @kbd{v .} and @kbd{t .} before, type them again to
7614 return to full-sized display of vectors.
7616 @node List Answer 12, List Answer 13, List Answer 11, Answers to Exercises
7617 @subsection List Tutorial Exercise 12
7620 This problem can be made a lot easier by taking advantage of some
7621 symmetries. First of all, after some thought it's clear that the
7622 @expr{y} axis can be ignored altogether. Just pick a random @expr{x}
7623 component for one end of the match, pick a random direction
7624 @texline @math{\theta},
7625 @infoline @expr{theta},
7626 and see if @expr{x} and
7627 @texline @math{x + \cos \theta}
7628 @infoline @expr{x + cos(theta)}
7629 (which is the @expr{x} coordinate of the other endpoint) cross a line.
7630 The lines are at integer coordinates, so this happens when the two
7631 numbers surround an integer.
7633 Since the two endpoints are equivalent, we may as well choose the leftmost
7634 of the two endpoints as @expr{x}. Then @expr{theta} is an angle pointing
7635 to the right, in the range -90 to 90 degrees. (We could use radians, but
7636 it would feel like cheating to refer to @cpiover{2} radians while trying
7637 to estimate @cpi{}!)
7639 In fact, since the field of lines is infinite we can choose the
7640 coordinates 0 and 1 for the lines on either side of the leftmost
7641 endpoint. The rightmost endpoint will be between 0 and 1 if the
7642 match does not cross a line, or between 1 and 2 if it does. So:
7643 Pick random @expr{x} and
7644 @texline @math{\theta},
7645 @infoline @expr{theta},
7647 @texline @math{x + \cos \theta},
7648 @infoline @expr{x + cos(theta)},
7649 and count how many of the results are greater than one. Simple!
7651 We can make this go a bit faster by using the @kbd{v .} and @kbd{t .}
7656 1: [0.52, 0.71, ..., 0.72] 2: [0.52, 0.71, ..., 0.72]
7657 . 1: [78.4, 64.5, ..., -42.9]
7660 v . t . 1. v b 100 @key{RET} V M k r 180. v b 100 @key{RET} V M k r 90 -
7665 (The next step may be slow, depending on the speed of your computer.)
7669 2: [0.52, 0.71, ..., 0.72] 1: [0.72, 1.14, ..., 1.45]
7670 1: [0.20, 0.43, ..., 0.73] .
7680 1: [0, 1, ..., 1] 1: 0.64 1: 3.125
7683 1 V M a > V R + 100 / 2 @key{TAB} /
7687 Let's try the third method, too. We'll use random integers up to
7688 one million. The @kbd{k r} command with an integer argument picks
7693 2: [1000000, 1000000, ..., 1000000] 2: [78489, 527587, ..., 814975]
7694 1: [1000000, 1000000, ..., 1000000] 1: [324014, 358783, ..., 955450]
7697 1000000 v b 100 @key{RET} @key{RET} V M k r @key{TAB} V M k r
7704 1: [1, 1, ..., 25] 1: [1, 1, ..., 0] 1: 0.56
7707 V M k g 1 V M a = V R + 100 /
7721 For a proof of this property of the GCD function, see section 4.5.2,
7722 exercise 10, of Knuth's @emph{Art of Computer Programming}, volume II.
7724 If you typed @kbd{v .} and @kbd{t .} before, type them again to
7725 return to full-sized display of vectors.
7727 @node List Answer 13, List Answer 14, List Answer 12, Answers to Exercises
7728 @subsection List Tutorial Exercise 13
7731 First, we put the string on the stack as a vector of ASCII codes.
7735 1: [84, 101, 115, ..., 51]
7738 "Testing, 1, 2, 3 @key{RET}
7743 Note that the @kbd{"} key, like @kbd{$}, initiates algebraic entry so
7744 there was no need to type an apostrophe. Also, Calc didn't mind that
7745 we omitted the closing @kbd{"}. (The same goes for all closing delimiters
7746 like @kbd{)} and @kbd{]} at the end of a formula.
7748 We'll show two different approaches here. In the first, we note that
7749 if the input vector is @expr{[a, b, c, d]}, then the hash code is
7750 @expr{3 (3 (3a + b) + c) + d = 27a + 9b + 3c + d}. In other words,
7751 it's a sum of descending powers of three times the ASCII codes.
7755 2: [84, 101, 115, ..., 51] 2: [84, 101, 115, ..., 51]
7756 1: 16 1: [15, 14, 13, ..., 0]
7759 @key{RET} v l v x 16 @key{RET} -
7766 2: [84, 101, 115, ..., 51] 1: 1960915098 1: 121
7767 1: [14348907, ..., 1] . .
7770 3 @key{TAB} V M ^ * 511 %
7775 Once again, @kbd{*} elegantly summarizes most of the computation.
7776 But there's an even more elegant approach: Reduce the formula
7777 @kbd{3 $$ + $} across the vector. Recall that this represents a
7778 function of two arguments that computes its first argument times three
7779 plus its second argument.
7783 1: [84, 101, 115, ..., 51] 1: 1960915098
7786 "Testing, 1, 2, 3 @key{RET} V R ' 3$$+$ @key{RET}
7791 If you did the decimal arithmetic exercise, this will be familiar.
7792 Basically, we're turning a base-3 vector of digits into an integer,
7793 except that our ``digits'' are much larger than real digits.
7795 Instead of typing @kbd{511 %} again to reduce the result, we can be
7796 cleverer still and notice that rather than computing a huge integer
7797 and taking the modulo at the end, we can take the modulo at each step
7798 without affecting the result. While this means there are more
7799 arithmetic operations, the numbers we operate on remain small so
7800 the operations are faster.
7804 1: [84, 101, 115, ..., 51] 1: 121
7807 "Testing, 1, 2, 3 @key{RET} V R ' (3$$+$)%511 @key{RET}
7811 Why does this work? Think about a two-step computation:
7812 @w{@expr{3 (3a + b) + c}}. Taking a result modulo 511 basically means
7813 subtracting off enough 511's to put the result in the desired range.
7814 So the result when we take the modulo after every step is,
7818 3 (3 a + b - 511 m) + c - 511 n
7823 $$ 3 (3 a + b - 511 m) + c - 511 n $$
7828 for some suitable integers @expr{m} and @expr{n}. Expanding out by
7829 the distributive law yields
7833 9 a + 3 b + c - 511*3 m - 511 n
7838 $$ 9 a + 3 b + c - 511\times3 m - 511 n $$
7843 The @expr{m} term in the latter formula is redundant because any
7844 contribution it makes could just as easily be made by the @expr{n}
7845 term. So we can take it out to get an equivalent formula with
7850 9 a + 3 b + c - 511 n'
7855 $$ 9 a + 3 b + c - 511 n^{\prime} $$
7860 which is just the formula for taking the modulo only at the end of
7861 the calculation. Therefore the two methods are essentially the same.
7863 Later in the tutorial we will encounter @dfn{modulo forms}, which
7864 basically automate the idea of reducing every intermediate result
7865 modulo some value @var{m}.
7867 @node List Answer 14, Types Answer 1, List Answer 13, Answers to Exercises
7868 @subsection List Tutorial Exercise 14
7870 We want to use @kbd{H V U} to nest a function which adds a random
7871 step to an @expr{(x,y)} coordinate. The function is a bit long, but
7872 otherwise the problem is quite straightforward.
7876 2: [0, 0] 1: [ [ 0, 0 ]
7877 1: 50 [ 0.4288, -0.1695 ]
7878 . [ -0.4787, -0.9027 ]
7881 [0,0] 50 H V U ' <# + [random(2.0)-1, random(2.0)-1]> @key{RET}
7885 Just as the text recommended, we used @samp{< >} nameless function
7886 notation to keep the two @code{random} calls from being evaluated
7887 before nesting even begins.
7889 We now have a vector of @expr{[x, y]} sub-vectors, which by Calc's
7890 rules acts like a matrix. We can transpose this matrix and unpack
7891 to get a pair of vectors, @expr{x} and @expr{y}, suitable for graphing.
7895 2: [ 0, 0.4288, -0.4787, ... ]
7896 1: [ 0, -0.1696, -0.9027, ... ]
7903 Incidentally, because the @expr{x} and @expr{y} are completely
7904 independent in this case, we could have done two separate commands
7905 to create our @expr{x} and @expr{y} vectors of numbers directly.
7907 To make a random walk of unit steps, we note that @code{sincos} of
7908 a random direction exactly gives us an @expr{[x, y]} step of unit
7909 length; in fact, the new nesting function is even briefer, though
7910 we might want to lower the precision a bit for it.
7914 2: [0, 0] 1: [ [ 0, 0 ]
7915 1: 50 [ 0.1318, 0.9912 ]
7916 . [ -0.5965, 0.3061 ]
7919 [0,0] 50 m d p 6 @key{RET} H V U ' <# + sincos(random(360.0))> @key{RET}
7923 Another @kbd{v t v u g f} sequence will graph this new random walk.
7925 An interesting twist on these random walk functions would be to use
7926 complex numbers instead of 2-vectors to represent points on the plane.
7927 In the first example, we'd use something like @samp{random + random*(0,1)},
7928 and in the second we could use polar complex numbers with random phase
7929 angles. (This exercise was first suggested in this form by Randal
7932 @node Types Answer 1, Types Answer 2, List Answer 14, Answers to Exercises
7933 @subsection Types Tutorial Exercise 1
7936 If the number is the square root of @cpi{} times a rational number,
7937 then its square, divided by @cpi{}, should be a rational number.
7941 1: 1.26508260337 1: 0.509433962268 1: 2486645810:4881193627
7949 Technically speaking this is a rational number, but not one that is
7950 likely to have arisen in the original problem. More likely, it just
7951 happens to be the fraction which most closely represents some
7952 irrational number to within 12 digits.
7954 But perhaps our result was not quite exact. Let's reduce the
7955 precision slightly and try again:
7959 1: 0.509433962268 1: 27:53
7962 U p 10 @key{RET} c F
7967 Aha! It's unlikely that an irrational number would equal a fraction
7968 this simple to within ten digits, so our original number was probably
7969 @texline @math{\sqrt{27 \pi / 53}}.
7970 @infoline @expr{sqrt(27 pi / 53)}.
7972 Notice that we didn't need to re-round the number when we reduced the
7973 precision. Remember, arithmetic operations always round their inputs
7974 to the current precision before they begin.
7976 @node Types Answer 2, Types Answer 3, Types Answer 1, Answers to Exercises
7977 @subsection Types Tutorial Exercise 2
7980 @samp{inf / inf = nan}. Perhaps @samp{1} is the ``obvious'' answer.
7981 But if @w{@samp{17 inf = inf}}, then @samp{17 inf / inf = inf / inf = 17}, too.
7983 @samp{exp(inf) = inf}. It's tempting to say that the exponential
7984 of infinity must be ``bigger'' than ``regular'' infinity, but as
7985 far as Calc is concerned all infinities are the same size.
7986 In other words, as @expr{x} goes to infinity, @expr{e^x} also goes
7987 to infinity, but the fact the @expr{e^x} grows much faster than
7988 @expr{x} is not relevant here.
7990 @samp{exp(-inf) = 0}. Here we have a finite answer even though
7991 the input is infinite.
7993 @samp{sqrt(-inf) = (0, 1) inf}. Remember that @expr{(0, 1)}
7994 represents the imaginary number @expr{i}. Here's a derivation:
7995 @samp{sqrt(-inf) = @w{sqrt((-1) * inf)} = sqrt(-1) * sqrt(inf)}.
7996 The first part is, by definition, @expr{i}; the second is @code{inf}
7997 because, once again, all infinities are the same size.
7999 @samp{sqrt(uinf) = uinf}. In fact, we do know something about the
8000 direction because @code{sqrt} is defined to return a value in the
8001 right half of the complex plane. But Calc has no notation for this,
8002 so it settles for the conservative answer @code{uinf}.
8004 @samp{abs(uinf) = inf}. No matter which direction @expr{x} points,
8005 @samp{abs(x)} always points along the positive real axis.
8007 @samp{ln(0) = -inf}. Here we have an infinite answer to a finite
8008 input. As in the @expr{1 / 0} case, Calc will only use infinities
8009 here if you have turned on Infinite mode. Otherwise, it will
8010 treat @samp{ln(0)} as an error.
8012 @node Types Answer 3, Types Answer 4, Types Answer 2, Answers to Exercises
8013 @subsection Types Tutorial Exercise 3
8016 We can make @samp{inf - inf} be any real number we like, say,
8017 @expr{a}, just by claiming that we added @expr{a} to the first
8018 infinity but not to the second. This is just as true for complex
8019 values of @expr{a}, so @code{nan} can stand for a complex number.
8020 (And, similarly, @code{uinf} can stand for an infinity that points
8021 in any direction in the complex plane, such as @samp{(0, 1) inf}).
8023 In fact, we can multiply the first @code{inf} by two. Surely
8024 @w{@samp{2 inf - inf = inf}}, but also @samp{2 inf - inf = inf - inf = nan}.
8025 So @code{nan} can even stand for infinity. Obviously it's just
8026 as easy to make it stand for minus infinity as for plus infinity.
8028 The moral of this story is that ``infinity'' is a slippery fish
8029 indeed, and Calc tries to handle it by having a very simple model
8030 for infinities (only the direction counts, not the ``size''); but
8031 Calc is careful to write @code{nan} any time this simple model is
8032 unable to tell what the true answer is.
8034 @node Types Answer 4, Types Answer 5, Types Answer 3, Answers to Exercises
8035 @subsection Types Tutorial Exercise 4
8039 2: 0@@ 47' 26" 1: 0@@ 2' 47.411765"
8043 0@@ 47' 26" @key{RET} 17 /
8048 The average song length is two minutes and 47.4 seconds.
8052 2: 0@@ 2' 47.411765" 1: 0@@ 3' 7.411765" 1: 0@@ 53' 6.000005"
8061 The album would be 53 minutes and 6 seconds long.
8063 @node Types Answer 5, Types Answer 6, Types Answer 4, Answers to Exercises
8064 @subsection Types Tutorial Exercise 5
8067 Let's suppose it's January 14, 1991. The easiest thing to do is
8068 to keep trying 13ths of months until Calc reports a Friday.
8069 We can do this by manually entering dates, or by using @kbd{t I}:
8073 1: <Wed Feb 13, 1991> 1: <Wed Mar 13, 1991> 1: <Sat Apr 13, 1991>
8076 ' <2/13> @key{RET} @key{DEL} ' <3/13> @key{RET} t I
8081 (Calc assumes the current year if you don't say otherwise.)
8083 This is getting tedious---we can keep advancing the date by typing
8084 @kbd{t I} over and over again, but let's automate the job by using
8085 vector mapping. The @kbd{t I} command actually takes a second
8086 ``how-many-months'' argument, which defaults to one. This
8087 argument is exactly what we want to map over:
8091 2: <Sat Apr 13, 1991> 1: [<Mon May 13, 1991>, <Thu Jun 13, 1991>,
8092 1: [1, 2, 3, 4, 5, 6] <Sat Jul 13, 1991>, <Tue Aug 13, 1991>,
8093 . <Fri Sep 13, 1991>, <Sun Oct 13, 1991>]
8096 v x 6 @key{RET} V M t I
8101 Et voil@`a, September 13, 1991 is a Friday.
8108 ' <sep 13> - <jan 14> @key{RET}
8113 And the answer to our original question: 242 days to go.
8115 @node Types Answer 6, Types Answer 7, Types Answer 5, Answers to Exercises
8116 @subsection Types Tutorial Exercise 6
8119 The full rule for leap years is that they occur in every year divisible
8120 by four, except that they don't occur in years divisible by 100, except
8121 that they @emph{do} in years divisible by 400. We could work out the
8122 answer by carefully counting the years divisible by four and the
8123 exceptions, but there is a much simpler way that works even if we
8124 don't know the leap year rule.
8126 Let's assume the present year is 1991. Years have 365 days, except
8127 that leap years (whenever they occur) have 366 days. So let's count
8128 the number of days between now and then, and compare that to the
8129 number of years times 365. The number of extra days we find must be
8130 equal to the number of leap years there were.
8134 1: <Mon Jan 1, 10001> 2: <Mon Jan 1, 10001> 1: 2925593
8135 . 1: <Tue Jan 1, 1991> .
8138 ' <jan 1 10001> @key{RET} ' <jan 1 1991> @key{RET} -
8145 3: 2925593 2: 2925593 2: 2925593 1: 1943
8146 2: 10001 1: 8010 1: 2923650 .
8150 10001 @key{RET} 1991 - 365 * -
8154 @c [fix-ref Date Forms]
8156 There will be 1943 leap years before the year 10001. (Assuming,
8157 of course, that the algorithm for computing leap years remains
8158 unchanged for that long. @xref{Date Forms}, for some interesting
8159 background information in that regard.)
8161 @node Types Answer 7, Types Answer 8, Types Answer 6, Answers to Exercises
8162 @subsection Types Tutorial Exercise 7
8165 The relative errors must be converted to absolute errors so that
8166 @samp{+/-} notation may be used.
8174 20 @key{RET} .05 * 4 @key{RET} .05 *
8178 Now we simply chug through the formula.
8182 1: 19.7392088022 1: 394.78 +/- 19.739 1: 6316.5 +/- 706.21
8185 2 P 2 ^ * 20 p 1 * 4 p .2 @key{RET} 2 ^ *
8189 It turns out the @kbd{v u} command will unpack an error form as
8190 well as a vector. This saves us some retyping of numbers.
8194 3: 6316.5 +/- 706.21 2: 6316.5 +/- 706.21
8199 @key{RET} v u @key{TAB} /
8204 Thus the volume is 6316 cubic centimeters, within about 11 percent.
8206 @node Types Answer 8, Types Answer 9, Types Answer 7, Answers to Exercises
8207 @subsection Types Tutorial Exercise 8
8210 The first answer is pretty simple: @samp{1 / (0 .. 10) = (0.1 .. inf)}.
8211 Since a number in the interval @samp{(0 .. 10)} can get arbitrarily
8212 close to zero, its reciprocal can get arbitrarily large, so the answer
8213 is an interval that effectively means, ``any number greater than 0.1''
8214 but with no upper bound.
8216 The second answer, similarly, is @samp{1 / (-10 .. 0) = (-inf .. -0.1)}.
8218 Calc normally treats division by zero as an error, so that the formula
8219 @w{@samp{1 / 0}} is left unsimplified. Our third problem,
8220 @w{@samp{1 / [0 .. 10]}}, also (potentially) divides by zero because zero
8221 is now a member of the interval. So Calc leaves this one unevaluated, too.
8223 If you turn on Infinite mode by pressing @kbd{m i}, you will
8224 instead get the answer @samp{[0.1 .. inf]}, which includes infinity
8225 as a possible value.
8227 The fourth calculation, @samp{1 / (-10 .. 10)}, has the same problem.
8228 Zero is buried inside the interval, but it's still a possible value.
8229 It's not hard to see that the actual result of @samp{1 / (-10 .. 10)}
8230 will be either greater than @mathit{0.1}, or less than @mathit{-0.1}. Thus
8231 the interval goes from minus infinity to plus infinity, with a ``hole''
8232 in it from @mathit{-0.1} to @mathit{0.1}. Calc doesn't have any way to
8233 represent this, so it just reports @samp{[-inf .. inf]} as the answer.
8234 It may be disappointing to hear ``the answer lies somewhere between
8235 minus infinity and plus infinity, inclusive,'' but that's the best
8236 that interval arithmetic can do in this case.
8238 @node Types Answer 9, Types Answer 10, Types Answer 8, Answers to Exercises
8239 @subsection Types Tutorial Exercise 9
8243 1: [-3 .. 3] 2: [-3 .. 3] 2: [0 .. 9]
8244 . 1: [0 .. 9] 1: [-9 .. 9]
8247 [ 3 n .. 3 ] @key{RET} 2 ^ @key{TAB} @key{RET} *
8252 In the first case the result says, ``if a number is between @mathit{-3} and
8253 3, its square is between 0 and 9.'' The second case says, ``the product
8254 of two numbers each between @mathit{-3} and 3 is between @mathit{-9} and 9.''
8256 An interval form is not a number; it is a symbol that can stand for
8257 many different numbers. Two identical-looking interval forms can stand
8258 for different numbers.
8260 The same issue arises when you try to square an error form.
8262 @node Types Answer 10, Types Answer 11, Types Answer 9, Answers to Exercises
8263 @subsection Types Tutorial Exercise 10
8266 Testing the first number, we might arbitrarily choose 17 for @expr{x}.
8270 1: 17 mod 811749613 2: 17 mod 811749613 1: 533694123 mod 811749613
8274 17 M 811749613 @key{RET} 811749612 ^
8279 Since 533694123 is (considerably) different from 1, the number 811749613
8282 It's awkward to type the number in twice as we did above. There are
8283 various ways to avoid this, and algebraic entry is one. In fact, using
8284 a vector mapping operation we can perform several tests at once. Let's
8285 use this method to test the second number.
8289 2: [17, 42, 100000] 1: [1 mod 15485863, 1 mod ... ]
8293 [17 42 100000] 15485863 @key{RET} V M ' ($$ mod $)^($-1) @key{RET}
8298 The result is three ones (modulo @expr{n}), so it's very probable that
8299 15485863 is prime. (In fact, this number is the millionth prime.)
8301 Note that the functions @samp{($$^($-1)) mod $} or @samp{$$^($-1) % $}
8302 would have been hopelessly inefficient, since they would have calculated
8303 the power using full integer arithmetic.
8305 Calc has a @kbd{k p} command that does primality testing. For small
8306 numbers it does an exact test; for large numbers it uses a variant
8307 of the Fermat test we used here. You can use @kbd{k p} repeatedly
8308 to prove that a large integer is prime with any desired probability.
8310 @node Types Answer 11, Types Answer 12, Types Answer 10, Answers to Exercises
8311 @subsection Types Tutorial Exercise 11
8314 There are several ways to insert a calculated number into an HMS form.
8315 One way to convert a number of seconds to an HMS form is simply to
8316 multiply the number by an HMS form representing one second:
8320 1: 31415926.5359 2: 31415926.5359 1: 8726@@ 38' 46.5359"
8331 2: 8726@@ 38' 46.5359" 1: 6@@ 6' 2.5359" mod 24@@ 0' 0"
8332 1: 15@@ 27' 16" mod 24@@ 0' 0" .
8340 It will be just after six in the morning.
8342 The algebraic @code{hms} function can also be used to build an
8347 1: hms(0, 0, 10000000. pi) 1: 8726@@ 38' 46.5359"
8350 ' hms(0, 0, 1e7 pi) @key{RET} =
8355 The @kbd{=} key is necessary to evaluate the symbol @samp{pi} to
8356 the actual number 3.14159...
8358 @node Types Answer 12, Types Answer 13, Types Answer 11, Answers to Exercises
8359 @subsection Types Tutorial Exercise 12
8362 As we recall, there are 17 songs of about 2 minutes and 47 seconds
8367 2: 0@@ 2' 47" 1: [0@@ 3' 7" .. 0@@ 3' 47"]
8368 1: [0@@ 0' 20" .. 0@@ 1' 0"] .
8371 [ 0@@ 20" .. 0@@ 1' ] +
8378 1: [0@@ 52' 59." .. 1@@ 4' 19."]
8386 No matter how long it is, the album will fit nicely on one CD.
8388 @node Types Answer 13, Types Answer 14, Types Answer 12, Answers to Exercises
8389 @subsection Types Tutorial Exercise 13
8392 Type @kbd{' 1 yr @key{RET} u c s @key{RET}}. The answer is 31557600 seconds.
8394 @node Types Answer 14, Types Answer 15, Types Answer 13, Answers to Exercises
8395 @subsection Types Tutorial Exercise 14
8398 How long will it take for a signal to get from one end of the computer
8403 1: m / c 1: 3.3356 ns
8406 ' 1 m / c @key{RET} u c ns @key{RET}
8411 (Recall, @samp{c} is a ``unit'' corresponding to the speed of light.)
8415 1: 3.3356 ns 1: 0.81356
8419 ' 4.1 ns @key{RET} /
8424 Thus a signal could take up to 81 percent of a clock cycle just to
8425 go from one place to another inside the computer, assuming the signal
8426 could actually attain the full speed of light. Pretty tight!
8428 @node Types Answer 15, Algebra Answer 1, Types Answer 14, Answers to Exercises
8429 @subsection Types Tutorial Exercise 15
8432 The speed limit is 55 miles per hour on most highways. We want to
8433 find the ratio of Sam's speed to the US speed limit.
8437 1: 55 mph 2: 55 mph 3: 11 hr mph / yd
8441 ' 55 mph @key{RET} ' 5 yd/hr @key{RET} /
8445 The @kbd{u s} command cancels out these units to get a plain
8446 number. Now we take the logarithm base two to find the final
8447 answer, assuming that each successive pill doubles his speed.
8451 1: 19360. 2: 19360. 1: 14.24
8460 Thus Sam can take up to 14 pills without a worry.
8462 @node Algebra Answer 1, Algebra Answer 2, Types Answer 15, Answers to Exercises
8463 @subsection Algebra Tutorial Exercise 1
8466 @c [fix-ref Declarations]
8467 The result @samp{sqrt(x)^2} is simplified back to @expr{x} by the
8468 Calculator, but @samp{sqrt(x^2)} is not. (Consider what happens
8469 if @w{@expr{x = -4}}.) If @expr{x} is real, this formula could be
8470 simplified to @samp{abs(x)}, but for general complex arguments even
8471 that is not safe. (@xref{Declarations}, for a way to tell Calc
8472 that @expr{x} is known to be real.)
8474 @node Algebra Answer 2, Algebra Answer 3, Algebra Answer 1, Answers to Exercises
8475 @subsection Algebra Tutorial Exercise 2
8478 Suppose our roots are @expr{[a, b, c]}. We want a polynomial which
8479 is zero when @expr{x} is any of these values. The trivial polynomial
8480 @expr{x-a} is zero when @expr{x=a}, so the product @expr{(x-a)(x-b)(x-c)}
8481 will do the job. We can use @kbd{a c x} to write this in a more
8486 1: 34 x - 24 x^3 1: [1.19023, -1.19023, 0]
8496 1: [x - 1.19023, x + 1.19023, x] 1: x*(x + 1.19023) (x - 1.19023)
8499 V M ' x-$ @key{RET} V R *
8506 1: x^3 - 1.41666 x 1: 34 x - 24 x^3
8509 a c x @key{RET} 24 n * a x
8514 Sure enough, our answer (multiplied by a suitable constant) is the
8515 same as the original polynomial.
8517 @node Algebra Answer 3, Algebra Answer 4, Algebra Answer 2, Answers to Exercises
8518 @subsection Algebra Tutorial Exercise 3
8522 1: x sin(pi x) 1: sin(pi x) / pi^2 - x cos(pi x) / pi
8525 ' x sin(pi x) @key{RET} m r a i x @key{RET}
8533 2: sin(pi x) / pi^2 - x cos(pi x) / pi
8536 ' [y,1] @key{RET} @key{TAB}
8543 1: [sin(pi y) / pi^2 - y cos(pi y) / pi, 1 / pi]
8553 1: sin(pi y) / pi^2 - y cos(pi y) / pi - 1 / pi
8563 1: sin(3.14159 y) / 9.8696 - y cos(3.14159 y) / 3.14159 - 0.3183
8573 1: [0., -0.95493, 0.63662, -1.5915, 1.2732]
8576 v x 5 @key{RET} @key{TAB} V M $ @key{RET}
8580 @node Algebra Answer 4, Rewrites Answer 1, Algebra Answer 3, Answers to Exercises
8581 @subsection Algebra Tutorial Exercise 4
8584 The hard part is that @kbd{V R +} is no longer sufficient to add up all
8585 the contributions from the slices, since the slices have varying
8586 coefficients. So first we must come up with a vector of these
8587 coefficients. Here's one way:
8591 2: -1 2: 3 1: [4, 2, ..., 4]
8592 1: [1, 2, ..., 9] 1: [-1, 1, ..., -1] .
8595 1 n v x 9 @key{RET} V M ^ 3 @key{TAB} -
8602 1: [4, 2, ..., 4, 1] 1: [1, 4, 2, ..., 4, 1]
8610 Now we compute the function values. Note that for this method we need
8611 eleven values, including both endpoints of the desired interval.
8615 2: [1, 4, 2, ..., 4, 1]
8616 1: [1, 1.1, 1.2, ... , 1.8, 1.9, 2.]
8619 11 @key{RET} 1 @key{RET} .1 @key{RET} C-u v x
8626 2: [1, 4, 2, ..., 4, 1]
8627 1: [0., 0.084941, 0.16993, ... ]
8630 ' sin(x) ln(x) @key{RET} m r p 5 @key{RET} V M $ @key{RET}
8635 Once again this calls for @kbd{V M * V R +}; a simple @kbd{*} does the
8640 1: 11.22 1: 1.122 1: 0.374
8648 Wow! That's even better than the result from the Taylor series method.
8650 @node Rewrites Answer 1, Rewrites Answer 2, Algebra Answer 4, Answers to Exercises
8651 @subsection Rewrites Tutorial Exercise 1
8654 We'll use Big mode to make the formulas more readable.
8660 1: (2 + sqrt(2)) / (1 + sqrt(2)) 1: ---------
8666 ' (2+sqrt(2)) / (1+sqrt(2)) @key{RET} d B
8671 Multiplying by the conjugate helps because @expr{(a+b) (a-b) = a^2 - b^2}.
8676 1: (2 + V 2 ) (V 2 - 1)
8679 a r a/(b+c) := a*(b-c) / (b^2-c^2) @key{RET}
8690 a r a*(b+c) := a*b + a*c
8695 (We could have used @kbd{a x} instead of a rewrite rule for the
8698 The multiply-by-conjugate rule turns out to be useful in many
8699 different circumstances, such as when the denominator involves
8700 sines and cosines or the imaginary constant @code{i}.
8702 @node Rewrites Answer 2, Rewrites Answer 3, Rewrites Answer 1, Answers to Exercises
8703 @subsection Rewrites Tutorial Exercise 2
8706 Here is the rule set:
8710 [ fib(n) := fib(n, 1, 1) :: integer(n) :: n >= 1,
8712 fib(n, x, y) := fib(n-1, y, x+y) ]
8717 The first rule turns a one-argument @code{fib} that people like to write
8718 into a three-argument @code{fib} that makes computation easier. The
8719 second rule converts back from three-argument form once the computation
8720 is done. The third rule does the computation itself. It basically
8721 says that if @expr{x} and @expr{y} are two consecutive Fibonacci numbers,
8722 then @expr{y} and @expr{x+y} are the next (overlapping) pair of Fibonacci
8725 Notice that because the number @expr{n} was ``validated'' by the
8726 conditions on the first rule, there is no need to put conditions on
8727 the other rules because the rule set would never get that far unless
8728 the input were valid. That further speeds computation, since no
8729 extra conditions need to be checked at every step.
8731 Actually, a user with a nasty sense of humor could enter a bad
8732 three-argument @code{fib} call directly, say, @samp{fib(0, 1, 1)},
8733 which would get the rules into an infinite loop. One thing that would
8734 help keep this from happening by accident would be to use something like
8735 @samp{ZzFib} instead of @code{fib} as the name of the three-argument
8738 @node Rewrites Answer 3, Rewrites Answer 4, Rewrites Answer 2, Answers to Exercises
8739 @subsection Rewrites Tutorial Exercise 3
8742 He got an infinite loop. First, Calc did as expected and rewrote
8743 @w{@samp{2 + 3 x}} to @samp{f(2, 3, x)}. Then it looked for ways to
8744 apply the rule again, and found that @samp{f(2, 3, x)} looks like
8745 @samp{a + b x} with @w{@samp{a = 0}} and @samp{b = 1}, so it rewrote to
8746 @samp{f(0, 1, f(2, 3, x))}. It then wrapped another @samp{f(0, 1, ...)}
8747 around that, and so on, ad infinitum. Joe should have used @kbd{M-1 a r}
8748 to make sure the rule applied only once.
8750 (Actually, even the first step didn't work as he expected. What Calc
8751 really gives for @kbd{M-1 a r} in this situation is @samp{f(3 x, 1, 2)},
8752 treating 2 as the ``variable,'' and @samp{3 x} as a constant being added
8753 to it. While this may seem odd, it's just as valid a solution as the
8754 ``obvious'' one. One way to fix this would be to add the condition
8755 @samp{:: variable(x)} to the rule, to make sure the thing that matches
8756 @samp{x} is indeed a variable, or to change @samp{x} to @samp{quote(x)}
8757 on the lefthand side, so that the rule matches the actual variable
8758 @samp{x} rather than letting @samp{x} stand for something else.)
8760 @node Rewrites Answer 4, Rewrites Answer 5, Rewrites Answer 3, Answers to Exercises
8761 @subsection Rewrites Tutorial Exercise 4
8768 Here is a suitable set of rules to solve the first part of the problem:
8772 [ seq(n, c) := seq(n/2, c+1) :: n%2 = 0,
8773 seq(n, c) := seq(3n+1, c+1) :: n%2 = 1 :: n > 1 ]
8777 Given the initial formula @samp{seq(6, 0)}, application of these
8778 rules produces the following sequence of formulas:
8792 whereupon neither of the rules match, and rewriting stops.
8794 We can pretty this up a bit with a couple more rules:
8798 [ seq(n) := seq(n, 0),
8805 Now, given @samp{seq(6)} as the starting configuration, we get 8
8808 The change to return a vector is quite simple:
8812 [ seq(n) := seq(n, []) :: integer(n) :: n > 0,
8814 seq(n, v) := seq(n/2, v | n) :: n%2 = 0,
8815 seq(n, v) := seq(3n+1, v | n) :: n%2 = 1 ]
8820 Given @samp{seq(6)}, the result is @samp{[6, 3, 10, 5, 16, 8, 4, 2, 1]}.
8822 Notice that the @expr{n > 1} guard is no longer necessary on the last
8823 rule since the @expr{n = 1} case is now detected by another rule.
8824 But a guard has been added to the initial rule to make sure the
8825 initial value is suitable before the computation begins.
8827 While still a good idea, this guard is not as vitally important as it
8828 was for the @code{fib} function, since calling, say, @samp{seq(x, [])}
8829 will not get into an infinite loop. Calc will not be able to prove
8830 the symbol @samp{x} is either even or odd, so none of the rules will
8831 apply and the rewrites will stop right away.
8833 @node Rewrites Answer 5, Rewrites Answer 6, Rewrites Answer 4, Answers to Exercises
8834 @subsection Rewrites Tutorial Exercise 5
8841 If @expr{x} is the sum @expr{a + b}, then `@tfn{nterms(}@var{x}@tfn{)}' must
8842 be `@tfn{nterms(}@var{a}@tfn{)}' plus `@tfn{nterms(}@var{b}@tfn{)}'. If @expr{x}
8843 is not a sum, then `@tfn{nterms(}@var{x}@tfn{)}' = 1.
8847 [ nterms(a + b) := nterms(a) + nterms(b),
8853 Here we have taken advantage of the fact that earlier rules always
8854 match before later rules; @samp{nterms(x)} will only be tried if we
8855 already know that @samp{x} is not a sum.
8857 @node Rewrites Answer 6, Programming Answer 1, Rewrites Answer 5, Answers to Exercises
8858 @subsection Rewrites Tutorial Exercise 6
8861 Here is a rule set that will do the job:
8865 [ a*(b + c) := a*b + a*c,
8866 opt(a) O(x^n) + opt(b) O(x^m) := O(x^n) :: n <= m
8867 :: constant(a) :: constant(b),
8868 opt(a) O(x^n) + opt(b) x^m := O(x^n) :: n <= m
8869 :: constant(a) :: constant(b),
8870 a O(x^n) := O(x^n) :: constant(a),
8871 x^opt(m) O(x^n) := O(x^(n+m)),
8872 O(x^n) O(x^m) := O(x^(n+m)) ]
8876 If we really want the @kbd{+} and @kbd{*} keys to operate naturally
8877 on power series, we should put these rules in @code{EvalRules}. For
8878 testing purposes, it is better to put them in a different variable,
8879 say, @code{O}, first.
8881 The first rule just expands products of sums so that the rest of the
8882 rules can assume they have an expanded-out polynomial to work with.
8883 Note that this rule does not mention @samp{O} at all, so it will
8884 apply to any product-of-sum it encounters---this rule may surprise
8885 you if you put it into @code{EvalRules}!
8887 In the second rule, the sum of two O's is changed to the smaller O@.
8888 The optional constant coefficients are there mostly so that
8889 @samp{O(x^2) - O(x^3)} and @samp{O(x^3) - O(x^2)} are handled
8890 as well as @samp{O(x^2) + O(x^3)}.
8892 The third rule absorbs higher powers of @samp{x} into O's.
8894 The fourth rule says that a constant times a negligible quantity
8895 is still negligible. (This rule will also match @samp{O(x^3) / 4},
8896 with @samp{a = 1/4}.)
8898 The fifth rule rewrites, for example, @samp{x^2 O(x^3)} to @samp{O(x^5)}.
8899 (It is easy to see that if one of these forms is negligible, the other
8900 is, too.) Notice the @samp{x^opt(m)} to pick up terms like
8901 @w{@samp{x O(x^3)}}. Optional powers will match @samp{x} as @samp{x^1}
8902 but not 1 as @samp{x^0}. This turns out to be exactly what we want here.
8904 The sixth rule is the corresponding rule for products of two O's.
8906 Another way to solve this problem would be to create a new ``data type''
8907 that represents truncated power series. We might represent these as
8908 function calls @samp{series(@var{coefs}, @var{x})} where @var{coefs} is
8909 a vector of coefficients for @expr{x^0}, @expr{x^1}, @expr{x^2}, and so
8910 on. Rules would exist for sums and products of such @code{series}
8911 objects, and as an optional convenience could also know how to combine a
8912 @code{series} object with a normal polynomial. (With this, and with a
8913 rule that rewrites @samp{O(x^n)} to the equivalent @code{series} form,
8914 you could still enter power series in exactly the same notation as
8915 before.) Operations on such objects would probably be more efficient,
8916 although the objects would be a bit harder to read.
8918 @c [fix-ref Compositions]
8919 Some other symbolic math programs provide a power series data type
8920 similar to this. Mathematica, for example, has an object that looks
8921 like @samp{PowerSeries[@var{x}, @var{x0}, @var{coefs}, @var{nmin},
8922 @var{nmax}, @var{den}]}, where @var{x0} is the point about which the
8923 power series is taken (we've been assuming this was always zero),
8924 and @var{nmin}, @var{nmax}, and @var{den} allow pseudo-power-series
8925 with fractional or negative powers. Also, the @code{PowerSeries}
8926 objects have a special display format that makes them look like
8927 @samp{2 x^2 + O(x^4)} when they are printed out. (@xref{Compositions},
8928 for a way to do this in Calc, although for something as involved as
8929 this it would probably be better to write the formatting routine
8932 @node Programming Answer 1, Programming Answer 2, Rewrites Answer 6, Answers to Exercises
8933 @subsection Programming Tutorial Exercise 1
8936 Just enter the formula @samp{ninteg(sin(t)/t, t, 0, x)}, type
8937 @kbd{Z F}, and answer the questions. Since this formula contains two
8938 variables, the default argument list will be @samp{(t x)}. We want to
8939 change this to @samp{(x)} since @expr{t} is really a dummy variable
8940 to be used within @code{ninteg}.
8942 The exact keystrokes are @kbd{Z F s Si @key{RET} @key{RET} C-b C-b @key{DEL} @key{DEL} @key{RET} y}.
8943 (The @kbd{C-b C-b @key{DEL} @key{DEL}} are what fix the argument list.)
8945 @node Programming Answer 2, Programming Answer 3, Programming Answer 1, Answers to Exercises
8946 @subsection Programming Tutorial Exercise 2
8949 One way is to move the number to the top of the stack, operate on
8950 it, then move it back: @kbd{C-x ( M-@key{TAB} n M-@key{TAB} M-@key{TAB} C-x )}.
8952 Another way is to negate the top three stack entries, then negate
8953 again the top two stack entries: @kbd{C-x ( M-3 n M-2 n C-x )}.
8955 Finally, it turns out that a negative prefix argument causes a
8956 command like @kbd{n} to operate on the specified stack entry only,
8957 which is just what we want: @kbd{C-x ( M-- 3 n C-x )}.
8959 Just for kicks, let's also do it algebraically:
8960 @w{@kbd{C-x ( ' -$$$, $$, $ @key{RET} C-x )}}.
8962 @node Programming Answer 3, Programming Answer 4, Programming Answer 2, Answers to Exercises
8963 @subsection Programming Tutorial Exercise 3
8966 Each of these functions can be computed using the stack, or using
8967 algebraic entry, whichever way you prefer:
8971 @texline @math{\displaystyle{\sin x \over x}}:
8972 @infoline @expr{sin(x) / x}:
8974 Using the stack: @kbd{C-x ( @key{RET} S @key{TAB} / C-x )}.
8976 Using algebraic entry: @kbd{C-x ( ' sin($)/$ @key{RET} C-x )}.
8979 Computing the logarithm:
8981 Using the stack: @kbd{C-x ( @key{TAB} B C-x )}
8983 Using algebraic entry: @kbd{C-x ( ' log($,$$) @key{RET} C-x )}.
8986 Computing the vector of integers:
8988 Using the stack: @kbd{C-x ( 1 @key{RET} 1 C-u v x C-x )}. (Recall that
8989 @kbd{C-u v x} takes the vector size, starting value, and increment
8992 Alternatively: @kbd{C-x ( ~ v x C-x )}. (The @kbd{~} key pops a
8993 number from the stack and uses it as the prefix argument for the
8996 Using algebraic entry: @kbd{C-x ( ' index($) @key{RET} C-x )}.
8998 @node Programming Answer 4, Programming Answer 5, Programming Answer 3, Answers to Exercises
8999 @subsection Programming Tutorial Exercise 4
9002 Here's one way: @kbd{C-x ( @key{RET} V R + @key{TAB} v l / C-x )}.
9004 @node Programming Answer 5, Programming Answer 6, Programming Answer 4, Answers to Exercises
9005 @subsection Programming Tutorial Exercise 5
9009 2: 1 1: 1.61803398502 2: 1.61803398502
9010 1: 20 . 1: 1.61803398875
9013 1 @key{RET} 20 Z < & 1 + Z > I H P
9018 This answer is quite accurate.
9020 @node Programming Answer 6, Programming Answer 7, Programming Answer 5, Answers to Exercises
9021 @subsection Programming Tutorial Exercise 6
9027 [ [ 0, 1 ] * [a, b] = [b, a + b]
9032 Thus @samp{[0, 1; 1, 1]^n * [1, 1]} computes Fibonacci numbers @expr{n+1}
9033 and @expr{n+2}. Here's one program that does the job:
9036 C-x ( ' [0, 1; 1, 1] ^ ($-1) * [1, 1] @key{RET} v u @key{DEL} C-x )
9040 This program is quite efficient because Calc knows how to raise a
9041 matrix (or other value) to the power @expr{n} in only
9042 @texline @math{\log_2 n}
9043 @infoline @expr{log(n,2)}
9044 steps. For example, this program can compute the 1000th Fibonacci
9045 number (a 209-digit integer!) in about 10 steps; even though the
9046 @kbd{Z < ... Z >} solution had much simpler steps, it would have
9047 required so many steps that it would not have been practical.
9049 @node Programming Answer 7, Programming Answer 8, Programming Answer 6, Answers to Exercises
9050 @subsection Programming Tutorial Exercise 7
9053 The trick here is to compute the harmonic numbers differently, so that
9054 the loop counter itself accumulates the sum of reciprocals. We use
9055 a separate variable to hold the integer counter.
9063 1 t 1 1 @key{RET} 4 Z ( t 2 r 1 1 + s 1 & Z )
9068 The body of the loop goes as follows: First save the harmonic sum
9069 so far in variable 2. Then delete it from the stack; the for loop
9070 itself will take care of remembering it for us. Next, recall the
9071 count from variable 1, add one to it, and feed its reciprocal to
9072 the for loop to use as the step value. The for loop will increase
9073 the ``loop counter'' by that amount and keep going until the
9074 loop counter exceeds 4.
9079 1: 3.99498713092 2: 3.99498713092
9083 r 1 r 2 @key{RET} 31 & +
9087 Thus we find that the 30th harmonic number is 3.99, and the 31st
9088 harmonic number is 4.02.
9090 @node Programming Answer 8, Programming Answer 9, Programming Answer 7, Answers to Exercises
9091 @subsection Programming Tutorial Exercise 8
9094 The first step is to compute the derivative @expr{f'(x)} and thus
9096 @texline @math{\displaystyle{x - {f(x) \over f'(x)}}}.
9097 @infoline @expr{x - f(x)/f'(x)}.
9099 (Because this definition is long, it will be repeated in concise form
9100 below. You can use @w{@kbd{C-x * m}} to load it from there. While you are
9101 entering a @kbd{Z ` Z '} body in a macro, Calc simply collects
9102 keystrokes without executing them. In the following diagrams we'll
9103 pretend Calc actually executed the keystrokes as you typed them,
9104 just for purposes of illustration.)
9108 2: sin(cos(x)) - 0.5 3: 4.5
9109 1: 4.5 2: sin(cos(x)) - 0.5
9110 . 1: -(sin(x) cos(cos(x)))
9113 ' sin(cos(x))-0.5 @key{RET} 4.5 m r C-x ( Z ` @key{TAB} @key{RET} a d x @key{RET}
9121 1: x + (sin(cos(x)) - 0.5) / sin(x) cos(cos(x))
9124 / ' x @key{RET} @key{TAB} - t 1
9128 Now, we enter the loop. We'll use a repeat loop with a 20-repetition
9129 limit just in case the method fails to converge for some reason.
9130 (Normally, the @w{@kbd{Z /}} command will stop the loop before all 20
9131 repetitions are done.)
9135 1: 4.5 3: 4.5 2: 4.5
9136 . 2: x + (sin(cos(x)) ... 1: 5.24196456928
9140 20 Z < @key{RET} r 1 @key{TAB} s l x @key{RET}
9144 This is the new guess for @expr{x}. Now we compare it with the
9145 old one to see if we've converged.
9149 3: 5.24196 2: 5.24196 1: 5.24196 1: 5.26345856348
9154 @key{RET} M-@key{TAB} a = Z / Z > Z ' C-x )
9158 The loop converges in just a few steps to this value. To check
9159 the result, we can simply substitute it back into the equation.
9167 @key{RET} ' sin(cos($)) @key{RET}
9171 Let's test the new definition again:
9179 ' x^2-9 @key{RET} 1 X
9183 Once again, here's the full Newton's Method definition:
9187 C-x ( Z ` @key{TAB} @key{RET} a d x @key{RET} / ' x @key{RET} @key{TAB} - t 1
9188 20 Z < @key{RET} r 1 @key{TAB} s l x @key{RET}
9189 @key{RET} M-@key{TAB} a = Z /
9196 @c [fix-ref Nesting and Fixed Points]
9197 It turns out that Calc has a built-in command for applying a formula
9198 repeatedly until it converges to a number. @xref{Nesting and Fixed Points},
9199 to see how to use it.
9201 @c [fix-ref Root Finding]
9202 Also, of course, @kbd{a R} is a built-in command that uses Newton's
9203 method (among others) to look for numerical solutions to any equation.
9204 @xref{Root Finding}.
9206 @node Programming Answer 9, Programming Answer 10, Programming Answer 8, Answers to Exercises
9207 @subsection Programming Tutorial Exercise 9
9210 The first step is to adjust @expr{z} to be greater than 5. A simple
9211 ``for'' loop will do the job here. If @expr{z} is less than 5, we
9212 reduce the problem using
9213 @texline @math{\psi(z) = \psi(z+1) - 1/z}.
9214 @infoline @expr{psi(z) = psi(z+1) - 1/z}. We go
9216 @texline @math{\psi(z+1)},
9217 @infoline @expr{psi(z+1)},
9218 and remember to add back a factor of @expr{-1/z} when we're done. This
9219 step is repeated until @expr{z > 5}.
9221 (Because this definition is long, it will be repeated in concise form
9222 below. You can use @w{@kbd{C-x * m}} to load it from there. While you are
9223 entering a @kbd{Z ` Z '} body in a macro, Calc simply collects
9224 keystrokes without executing them. In the following diagrams we'll
9225 pretend Calc actually executed the keystrokes as you typed them,
9226 just for purposes of illustration.)
9233 1.0 @key{RET} C-x ( Z ` s 1 0 t 2
9237 Here, variable 1 holds @expr{z} and variable 2 holds the adjustment
9238 factor. If @expr{z < 5}, we use a loop to increase it.
9240 (By the way, we started with @samp{1.0} instead of the integer 1 because
9241 otherwise the calculation below will try to do exact fractional arithmetic,
9242 and will never converge because fractions compare equal only if they
9243 are exactly equal, not just equal to within the current precision.)
9252 @key{RET} 5 a < Z [ 5 Z ( & s + 2 1 s + 1 1 Z ) r 1 Z ]
9256 Now we compute the initial part of the sum:
9257 @texline @math{\ln z - {1 \over 2z}}
9258 @infoline @expr{ln(z) - 1/2z}
9259 minus the adjustment factor.
9263 2: 1.79175946923 2: 1.7084261359 1: -0.57490719743
9264 1: 0.0833333333333 1: 2.28333333333 .
9271 Now we evaluate the series. We'll use another ``for'' loop counting
9272 up the value of @expr{2 n}. (Calc does have a summation command,
9273 @kbd{a +}, but we'll use loops just to get more practice with them.)
9277 3: -0.5749 3: -0.5749 4: -0.5749 2: -0.5749
9278 2: 2 2: 1:6 3: 1:6 1: 2.3148e-3
9283 2 @key{RET} 40 Z ( @key{RET} k b @key{TAB} @key{RET} r 1 @key{TAB} ^ * /
9290 3: -0.5749 3: -0.5772 2: -0.5772 1: -0.577215664892
9291 2: -0.5749 2: -0.5772 1: 0 .
9292 1: 2.3148e-3 1: -0.5749 .
9295 @key{TAB} @key{RET} M-@key{TAB} - @key{RET} M-@key{TAB} a = Z / 2 Z ) Z ' C-x )
9299 This is the value of
9300 @texline @math{-\gamma},
9301 @infoline @expr{- gamma},
9302 with a slight bit of roundoff error. To get a full 12 digits, let's use
9307 2: -0.577215664892 2: -0.577215664892
9308 1: 1. 1: -0.577215664901532
9310 1. @key{RET} p 16 @key{RET} X
9314 Here's the complete sequence of keystrokes:
9319 @key{RET} 5 a < Z [ 5 Z ( & s + 2 1 s + 1 1 Z ) r 1 Z ]
9321 2 @key{RET} 40 Z ( @key{RET} k b @key{TAB} @key{RET} r 1 @key{TAB} ^ * /
9322 @key{TAB} @key{RET} M-@key{TAB} - @key{RET} M-@key{TAB} a = Z /
9329 @node Programming Answer 10, Programming Answer 11, Programming Answer 9, Answers to Exercises
9330 @subsection Programming Tutorial Exercise 10
9333 Taking the derivative of a term of the form @expr{x^n} will produce
9335 @texline @math{n x^{n-1}}.
9336 @infoline @expr{n x^(n-1)}.
9337 Taking the derivative of a constant
9338 produces zero. From this it is easy to see that the @expr{n}th
9339 derivative of a polynomial, evaluated at @expr{x = 0}, will equal the
9340 coefficient on the @expr{x^n} term times @expr{n!}.
9342 (Because this definition is long, it will be repeated in concise form
9343 below. You can use @w{@kbd{C-x * m}} to load it from there. While you are
9344 entering a @kbd{Z ` Z '} body in a macro, Calc simply collects
9345 keystrokes without executing them. In the following diagrams we'll
9346 pretend Calc actually executed the keystrokes as you typed them,
9347 just for purposes of illustration.)
9351 2: 5 x^4 + (x + 1)^2 3: 5 x^4 + (x + 1)^2
9356 ' 5 x^4 + (x+1)^2 @key{RET} 6 C-x ( Z ` [ ] t 1 0 @key{TAB}
9361 Variable 1 will accumulate the vector of coefficients.
9365 2: 0 3: 0 2: 5 x^4 + ...
9366 1: 5 x^4 + ... 2: 5 x^4 + ... 1: 1
9370 Z ( @key{TAB} @key{RET} 0 s l x @key{RET} M-@key{TAB} ! / s | 1
9375 Note that @kbd{s | 1} appends the top-of-stack value to the vector
9376 in a variable; it is completely analogous to @kbd{s + 1}. We could
9377 have written instead, @kbd{r 1 @key{TAB} | t 1}.
9381 1: 20 x^3 + 2 x + 2 1: 0 1: [1, 2, 1, 0, 5, 0, 0]
9384 a d x @key{RET} 1 Z ) @key{DEL} r 1 Z ' C-x )
9388 To convert back, a simple method is just to map the coefficients
9389 against a table of powers of @expr{x}.
9393 2: [1, 2, 1, 0, 5, 0, 0] 2: [1, 2, 1, 0, 5, 0, 0]
9394 1: 6 1: [0, 1, 2, 3, 4, 5, 6]
9397 6 @key{RET} 1 + 0 @key{RET} 1 C-u v x
9404 2: [1, 2, 1, 0, 5, 0, 0] 2: 1 + 2 x + x^2 + 5 x^4
9405 1: [1, x, x^2, x^3, ... ] .
9408 ' x @key{RET} @key{TAB} V M ^ *
9412 Once again, here are the whole polynomial to/from vector programs:
9416 C-x ( Z ` [ ] t 1 0 @key{TAB}
9417 Z ( @key{TAB} @key{RET} 0 s l x @key{RET} M-@key{TAB} ! / s | 1
9423 C-x ( 1 + 0 @key{RET} 1 C-u v x ' x @key{RET} @key{TAB} V M ^ * C-x )
9427 @node Programming Answer 11, Programming Answer 12, Programming Answer 10, Answers to Exercises
9428 @subsection Programming Tutorial Exercise 11
9431 First we define a dummy program to go on the @kbd{z s} key. The true
9432 @w{@kbd{z s}} key is supposed to take two numbers from the stack and
9433 return one number, so @key{DEL} as a dummy definition will make
9434 sure the stack comes out right.
9442 4 @key{RET} 2 C-x ( @key{DEL} C-x ) Z K s @key{RET} 2
9446 The last step replaces the 2 that was eaten during the creation
9447 of the dummy @kbd{z s} command. Now we move on to the real
9448 definition. The recurrence needs to be rewritten slightly,
9449 to the form @expr{s(n,m) = s(n-1,m-1) - (n-1) s(n-1,m)}.
9451 (Because this definition is long, it will be repeated in concise form
9452 below. You can use @kbd{C-x * m} to load it from there.)
9462 C-x ( M-2 @key{RET} a = Z [ @key{DEL} @key{DEL} 1 Z :
9469 4: 4 2: 4 2: 3 4: 3 4: 3 3: 3
9470 3: 2 1: 2 1: 2 3: 2 3: 2 2: 2
9471 2: 2 . . 2: 3 2: 3 1: 3
9475 @key{RET} 0 a = Z [ @key{DEL} @key{DEL} 0 Z : @key{TAB} 1 - @key{TAB} M-2 @key{RET} 1 - z s
9480 (Note that the value 3 that our dummy @kbd{z s} produces is not correct;
9481 it is merely a placeholder that will do just as well for now.)
9485 3: 3 4: 3 3: 3 2: 3 1: -6
9486 2: 3 3: 3 2: 3 1: 9 .
9491 M-@key{TAB} M-@key{TAB} @key{TAB} @key{RET} M-@key{TAB} z s * -
9498 1: -6 2: 4 1: 11 2: 11
9502 Z ] Z ] C-x ) Z K s @key{RET} @key{DEL} 4 @key{RET} 2 z s M-@key{RET} k s
9506 Even though the result that we got during the definition was highly
9507 bogus, once the definition is complete the @kbd{z s} command gets
9510 Here's the full program once again:
9514 C-x ( M-2 @key{RET} a =
9515 Z [ @key{DEL} @key{DEL} 1
9517 Z [ @key{DEL} @key{DEL} 0
9518 Z : @key{TAB} 1 - @key{TAB} M-2 @key{RET} 1 - z s
9519 M-@key{TAB} M-@key{TAB} @key{TAB} @key{RET} M-@key{TAB} z s * -
9526 You can read this definition using @kbd{C-x * m} (@code{read-kbd-macro})
9527 followed by @kbd{Z K s}, without having to make a dummy definition
9528 first, because @code{read-kbd-macro} doesn't need to execute the
9529 definition as it reads it in. For this reason, @code{C-x * m} is often
9530 the easiest way to create recursive programs in Calc.
9532 @node Programming Answer 12, , Programming Answer 11, Answers to Exercises
9533 @subsection Programming Tutorial Exercise 12
9536 This turns out to be a much easier way to solve the problem. Let's
9537 denote Stirling numbers as calls of the function @samp{s}.
9539 First, we store the rewrite rules corresponding to the definition of
9540 Stirling numbers in a convenient variable:
9543 s e StirlingRules @key{RET}
9544 [ s(n,n) := 1 :: n >= 0,
9545 s(n,0) := 0 :: n > 0,
9546 s(n,m) := s(n-1,m-1) - (n-1) s(n-1,m) :: n >= m :: m >= 1 ]
9550 Now, it's just a matter of applying the rules:
9554 2: 4 1: s(4, 2) 1: 11
9558 4 @key{RET} 2 C-x ( ' s($$,$) @key{RET} a r StirlingRules @key{RET} C-x )
9562 As in the case of the @code{fib} rules, it would be useful to put these
9563 rules in @code{EvalRules} and to add a @samp{:: remember} condition to
9566 @c This ends the table-of-contents kludge from above:
9568 \global\let\chapternofonts=\oldchapternofonts
9573 @node Introduction, Data Types, Tutorial, Top
9574 @chapter Introduction
9577 This chapter is the beginning of the Calc reference manual.
9578 It covers basic concepts such as the stack, algebraic and
9579 numeric entry, undo, numeric prefix arguments, etc.
9582 @c (Chapter 2, the Tutorial, has been printed in a separate volume.)
9590 * Quick Calculator::
9591 * Prefix Arguments::
9594 * Multiple Calculators::
9595 * Troubleshooting Commands::
9598 @node Basic Commands, Help Commands, Introduction, Introduction
9599 @section Basic Commands
9604 @cindex Starting the Calculator
9605 @cindex Running the Calculator
9606 To start the Calculator in its standard interface, type @kbd{M-x calc}.
9607 By default this creates a pair of small windows, @file{*Calculator*}
9608 and @file{*Calc Trail*}. The former displays the contents of the
9609 Calculator stack and is manipulated exclusively through Calc commands.
9610 It is possible (though not usually necessary) to create several Calc
9611 mode buffers each of which has an independent stack, undo list, and
9612 mode settings. There is exactly one Calc Trail buffer; it records a
9613 list of the results of all calculations that have been done. The
9614 Calc Trail buffer uses a variant of Calc mode, so Calculator commands
9615 still work when the trail buffer's window is selected. It is possible
9616 to turn the trail window off, but the @file{*Calc Trail*} buffer itself
9617 still exists and is updated silently. @xref{Trail Commands}.
9624 In most installations, the @kbd{C-x * c} key sequence is a more
9625 convenient way to start the Calculator. Also, @kbd{C-x * *}
9626 is a synonym for @kbd{C-x * c} unless you last used Calc
9631 @pindex calc-execute-extended-command
9632 Most Calc commands use one or two keystrokes. Lower- and upper-case
9633 letters are distinct. Commands may also be entered in full @kbd{M-x} form;
9634 for some commands this is the only form. As a convenience, the @kbd{x}
9635 key (@code{calc-execute-extended-command})
9636 is like @kbd{M-x} except that it enters the initial string @samp{calc-}
9637 for you. For example, the following key sequences are equivalent:
9638 @kbd{S}, @kbd{M-x calc-sin @key{RET}}, @kbd{x sin @key{RET}}.
9640 Although Calc is designed to be used from the keyboard, some of
9641 Calc's more common commands are available from a menu. In the menu, the
9642 arguments to the functions are given by referring to their stack level
9645 @cindex Extensions module
9646 @cindex @file{calc-ext} module
9647 The Calculator exists in many parts. When you type @kbd{C-x * c}, the
9648 Emacs ``auto-load'' mechanism will bring in only the first part, which
9649 contains the basic arithmetic functions. The other parts will be
9650 auto-loaded the first time you use the more advanced commands like trig
9651 functions or matrix operations. This is done to improve the response time
9652 of the Calculator in the common case when all you need to do is a
9653 little arithmetic. If for some reason the Calculator fails to load an
9654 extension module automatically, you can force it to load all the
9655 extensions by using the @kbd{C-x * L} (@code{calc-load-everything})
9656 command. @xref{Mode Settings}.
9658 If you type @kbd{M-x calc} or @kbd{C-x * c} with any numeric prefix argument,
9659 the Calculator is loaded if necessary, but it is not actually started.
9660 If the argument is positive, the @file{calc-ext} extensions are also
9661 loaded if necessary. User-written Lisp code that wishes to make use
9662 of Calc's arithmetic routines can use @samp{(calc 0)} or @samp{(calc 1)}
9663 to auto-load the Calculator.
9667 If you type @kbd{C-x * b}, then next time you use @kbd{C-x * c} you
9668 will get a Calculator that uses the full height of the Emacs screen.
9669 When full-screen mode is on, @kbd{C-x * c} runs the @code{full-calc}
9670 command instead of @code{calc}. From the Unix shell you can type
9671 @samp{emacs -f full-calc} to start a new Emacs specifically for use
9672 as a calculator. When Calc is started from the Emacs command line
9673 like this, Calc's normal ``quit'' commands actually quit Emacs itself.
9676 @pindex calc-other-window
9677 The @kbd{C-x * o} command is like @kbd{C-x * c} except that the Calc
9678 window is not actually selected. If you are already in the Calc
9679 window, @kbd{C-x * o} switches you out of it. (The regular Emacs
9680 @kbd{C-x o} command would also work for this, but it has a
9681 tendency to drop you into the Calc Trail window instead, which
9682 @kbd{C-x * o} takes care not to do.)
9687 For one quick calculation, you can type @kbd{C-x * q} (@code{quick-calc})
9688 which prompts you for a formula (like @samp{2+3/4}). The result is
9689 displayed at the bottom of the Emacs screen without ever creating
9690 any special Calculator windows. @xref{Quick Calculator}.
9695 Finally, if you are using the X window system you may want to try
9696 @kbd{C-x * k} (@code{calc-keypad}) which runs Calc with a
9697 ``calculator keypad'' picture as well as a stack display. Click on
9698 the keys with the mouse to operate the calculator. @xref{Keypad Mode}.
9702 @cindex Quitting the Calculator
9703 @cindex Exiting the Calculator
9704 The @kbd{q} key (@code{calc-quit}) exits Calc mode and closes the
9705 Calculator's window(s). It does not delete the Calculator buffers.
9706 If you type @kbd{M-x calc} again, the Calculator will reappear with the
9707 contents of the stack intact. Typing @kbd{C-x * c} or @kbd{C-x * *}
9708 again from inside the Calculator buffer is equivalent to executing
9709 @code{calc-quit}; you can think of @kbd{C-x * *} as toggling the
9710 Calculator on and off.
9713 The @kbd{C-x * x} command also turns the Calculator off, no matter which
9714 user interface (standard, Keypad, or Embedded) is currently active.
9715 It also cancels @code{calc-edit} mode if used from there.
9718 @pindex calc-refresh
9719 @cindex Refreshing a garbled display
9720 @cindex Garbled displays, refreshing
9721 The @kbd{d @key{SPC}} key sequence (@code{calc-refresh}) redraws the contents
9722 of the Calculator buffer from memory. Use this if the contents of the
9723 buffer have been damaged somehow.
9728 The @kbd{o} key (@code{calc-realign}) moves the cursor back to its
9729 ``home'' position at the bottom of the Calculator buffer.
9733 @pindex calc-scroll-left
9734 @pindex calc-scroll-right
9735 @cindex Horizontal scrolling
9737 @cindex Wide text, scrolling
9738 The @kbd{<} and @kbd{>} keys are bound to @code{calc-scroll-left} and
9739 @code{calc-scroll-right}. These are just like the normal horizontal
9740 scrolling commands except that they scroll one half-screen at a time by
9741 default. (Calc formats its output to fit within the bounds of the
9742 window whenever it can.)
9746 @pindex calc-scroll-down
9747 @pindex calc-scroll-up
9748 @cindex Vertical scrolling
9749 The @kbd{@{} and @kbd{@}} keys are bound to @code{calc-scroll-down}
9750 and @code{calc-scroll-up}. They scroll up or down by one-half the
9751 height of the Calc window.
9755 The @kbd{C-x * 0} command (@code{calc-reset}; that's @kbd{C-x *} followed
9756 by a zero) resets the Calculator to its initial state. This clears
9757 the stack, resets all the modes to their initial values (the values
9758 that were saved with @kbd{m m} (@code{calc-save-modes})), clears the
9759 caches (@pxref{Caches}), and so on. (It does @emph{not} erase the
9760 values of any variables.) With an argument of 0, Calc will be reset to
9761 its default state; namely, the modes will be given their default values.
9762 With a positive prefix argument, @kbd{C-x * 0} preserves the contents of
9763 the stack but resets everything else to its initial state; with a
9764 negative prefix argument, @kbd{C-x * 0} preserves the contents of the
9765 stack but resets everything else to its default state.
9767 @node Help Commands, Stack Basics, Basic Commands, Introduction
9768 @section Help Commands
9771 @cindex Help commands
9791 The @kbd{?} key (@code{calc-help}) displays a series of brief help messages.
9792 Some keys (such as @kbd{b} and @kbd{d}) are prefix keys, like Emacs's
9793 @key{ESC} and @kbd{C-x} prefixes. You can type
9794 @kbd{?} after a prefix to see a list of commands beginning with that
9795 prefix. (If the message includes @samp{[MORE]}, press @kbd{?} again
9796 to see additional commands for that prefix.)
9799 @pindex calc-full-help
9800 The @kbd{h h} (@code{calc-full-help}) command displays all the @kbd{?}
9801 responses at once. When printed, this makes a nice, compact (three pages)
9802 summary of Calc keystrokes.
9804 In general, the @kbd{h} key prefix introduces various commands that
9805 provide help within Calc. Many of the @kbd{h} key functions are
9806 Calc-specific analogues to the @kbd{C-h} functions for Emacs help.
9812 The @kbd{h i} (@code{calc-info}) command runs the Emacs Info system
9813 to read this manual on-line. This is basically the same as typing
9814 @kbd{C-h i} (the regular way to run the Info system), then, if Info
9815 is not already in the Calc manual, selecting the beginning of the
9816 manual. The @kbd{C-x * i} command is another way to read the Calc
9817 manual; it is different from @kbd{h i} in that it works any time,
9818 not just inside Calc. The plain @kbd{i} key is also equivalent to
9819 @kbd{h i}, though this key is obsolete and may be replaced with a
9820 different command in a future version of Calc.
9824 @pindex calc-tutorial
9825 The @kbd{h t} (@code{calc-tutorial}) command runs the Info system on
9826 the Tutorial section of the Calc manual. It is like @kbd{h i},
9827 except that it selects the starting node of the tutorial rather
9828 than the beginning of the whole manual. (It actually selects the
9829 node ``Interactive Tutorial'' which tells a few things about
9830 using the Info system before going on to the actual tutorial.)
9831 The @kbd{C-x * t} key is equivalent to @kbd{h t} (but it works at
9836 @pindex calc-info-summary
9837 The @kbd{h s} (@code{calc-info-summary}) command runs the Info system
9838 on the Summary node of the Calc manual. @xref{Summary}. The @kbd{C-x * s}
9839 key is equivalent to @kbd{h s}.
9842 @pindex calc-describe-key
9843 The @kbd{h k} (@code{calc-describe-key}) command looks up a key
9844 sequence in the Calc manual. For example, @kbd{h k H a S} looks
9845 up the documentation on the @kbd{H a S} (@code{calc-solve-for})
9846 command. This works by looking up the textual description of
9847 the key(s) in the Key Index of the manual, then jumping to the
9848 node indicated by the index.
9850 Most Calc commands do not have traditional Emacs documentation
9851 strings, since the @kbd{h k} command is both more convenient and
9852 more instructive. This means the regular Emacs @kbd{C-h k}
9853 (@code{describe-key}) command will not be useful for Calc keystrokes.
9856 @pindex calc-describe-key-briefly
9857 The @kbd{h c} (@code{calc-describe-key-briefly}) command reads a
9858 key sequence and displays a brief one-line description of it at
9859 the bottom of the screen. It looks for the key sequence in the
9860 Summary node of the Calc manual; if it doesn't find the sequence
9861 there, it acts just like its regular Emacs counterpart @kbd{C-h c}
9862 (@code{describe-key-briefly}). For example, @kbd{h c H a S}
9863 gives the description:
9866 H a S runs calc-solve-for: a `H a S' v => fsolve(a,v) (?=notes)
9870 which means the command @kbd{H a S} or @kbd{H M-x calc-solve-for}
9871 takes a value @expr{a} from the stack, prompts for a value @expr{v},
9872 then applies the algebraic function @code{fsolve} to these values.
9873 The @samp{?=notes} message means you can now type @kbd{?} to see
9874 additional notes from the summary that apply to this command.
9877 @pindex calc-describe-function
9878 The @kbd{h f} (@code{calc-describe-function}) command looks up an
9879 algebraic function or a command name in the Calc manual. Enter an
9880 algebraic function name to look up that function in the Function
9881 Index or enter a command name beginning with @samp{calc-} to look it
9882 up in the Command Index. This command will also look up operator
9883 symbols that can appear in algebraic formulas, like @samp{%} and
9887 @pindex calc-describe-variable
9888 The @kbd{h v} (@code{calc-describe-variable}) command looks up a
9889 variable in the Calc manual. Enter a variable name like @code{pi} or
9893 @pindex describe-bindings
9894 The @kbd{h b} (@code{calc-describe-bindings}) command is just like
9895 @kbd{C-h b}, except that only local (Calc-related) key bindings are
9899 The @kbd{h n} or @kbd{h C-n} (@code{calc-view-news}) command displays
9900 the ``news'' or change history of Emacs, and jumps to the most recent
9901 portion concerning Calc (if present). For older history, see the file
9902 @file{etc/CALC-NEWS} in the Emacs distribution.
9907 The @kbd{h C-c}, @kbd{h C-d}, and @kbd{h C-w} keys display copying,
9908 distribution, and warranty information about Calc. These work by
9909 pulling up the appropriate parts of the ``Copying'' or ``Reporting
9910 Bugs'' sections of the manual.
9912 @node Stack Basics, Numeric Entry, Help Commands, Introduction
9913 @section Stack Basics
9916 @cindex Stack basics
9917 @c [fix-tut RPN Calculations and the Stack]
9918 Calc uses RPN notation. If you are not familiar with RPN, @pxref{RPN
9921 To add the numbers 1 and 2 in Calc you would type the keys:
9922 @kbd{1 @key{RET} 2 +}.
9923 (@key{RET} corresponds to the @key{ENTER} key on most calculators.)
9924 The first three keystrokes ``push'' the numbers 1 and 2 onto the stack. The
9925 @kbd{+} key always ``pops'' the top two numbers from the stack, adds them,
9926 and pushes the result (3) back onto the stack. This number is ready for
9927 further calculations: @kbd{5 -} pushes 5 onto the stack, then pops the
9928 3 and 5, subtracts them, and pushes the result (@mathit{-2}).
9930 Note that the ``top'' of the stack actually appears at the @emph{bottom}
9931 of the buffer. A line containing a single @samp{.} character signifies
9932 the end of the buffer; Calculator commands operate on the number(s)
9933 directly above this line. The @kbd{d t} (@code{calc-truncate-stack})
9934 command allows you to move the @samp{.} marker up and down in the stack;
9935 @pxref{Truncating the Stack}.
9938 @pindex calc-line-numbering
9939 Stack elements are numbered consecutively, with number 1 being the top of
9940 the stack. These line numbers are ordinarily displayed on the lefthand side
9941 of the window. The @kbd{d l} (@code{calc-line-numbering}) command controls
9942 whether these numbers appear. (Line numbers may be turned off since they
9943 slow the Calculator down a bit and also clutter the display.)
9946 @pindex calc-realign
9947 The unshifted letter @kbd{o} (@code{calc-realign}) command repositions
9948 the cursor to its top-of-stack ``home'' position. It also undoes any
9949 horizontal scrolling in the window. If you give it a numeric prefix
9950 argument, it instead moves the cursor to the specified stack element.
9952 The @key{RET} (or equivalent @key{SPC}) key is only required to separate
9953 two consecutive numbers.
9954 (After all, if you typed @kbd{1 2} by themselves the Calculator
9955 would enter the number 12.) If you press @key{RET} or @key{SPC} @emph{not}
9956 right after typing a number, the key duplicates the number on the top of
9957 the stack. @kbd{@key{RET} *} is thus a handy way to square a number.
9959 The @key{DEL} key pops and throws away the top number on the stack.
9960 The @key{TAB} key swaps the top two objects on the stack.
9961 @xref{Stack and Trail}, for descriptions of these and other stack-related
9964 @node Numeric Entry, Algebraic Entry, Stack Basics, Introduction
9965 @section Numeric Entry
9971 @cindex Numeric entry
9972 @cindex Entering numbers
9973 Pressing a digit or other numeric key begins numeric entry using the
9974 minibuffer. The number is pushed on the stack when you press the @key{RET}
9975 or @key{SPC} keys. If you press any other non-numeric key, the number is
9976 pushed onto the stack and the appropriate operation is performed. If
9977 you press a numeric key which is not valid, the key is ignored.
9980 @cindex Negative numbers, entering
9982 There are three different concepts corresponding to the word ``minus,''
9983 typified by @expr{a-b} (subtraction), @expr{-x}
9984 (change-sign), and @expr{-5} (negative number). Calc uses three
9985 different keys for these operations, respectively:
9986 @kbd{-}, @kbd{n}, and @kbd{_} (the underscore). The @kbd{-} key subtracts
9987 the two numbers on the top of the stack. The @kbd{n} key changes the sign
9988 of the number on the top of the stack or the number currently being entered.
9989 The @kbd{_} key begins entry of a negative number or changes the sign of
9990 the number currently being entered. The following sequences all enter the
9991 number @mathit{-5} onto the stack: @kbd{0 @key{RET} 5 -}, @kbd{5 n @key{RET}},
9992 @kbd{5 @key{RET} n}, @kbd{_ 5 @key{RET}}, @kbd{5 _ @key{RET}}.
9994 Some other keys are active during numeric entry, such as @kbd{#} for
9995 non-decimal numbers, @kbd{:} for fractions, and @kbd{@@} for HMS forms.
9996 These notations are described later in this manual with the corresponding
9997 data types. @xref{Data Types}.
9999 During numeric entry, the only editing key available is @key{DEL}.
10001 @node Algebraic Entry, Quick Calculator, Numeric Entry, Introduction
10002 @section Algebraic Entry
10006 @pindex calc-algebraic-entry
10007 @cindex Algebraic notation
10008 @cindex Formulas, entering
10009 The @kbd{'} (@code{calc-algebraic-entry}) command can be used to enter
10010 calculations in algebraic form. This is accomplished by typing the
10011 apostrophe key, ', followed by the expression in standard format:
10019 @texline @math{2+(3\times4) = 14}
10020 @infoline @expr{2+(3*4) = 14}
10021 and push it on the stack. If you wish you can
10022 ignore the RPN aspect of Calc altogether and simply enter algebraic
10023 expressions in this way. You may want to use @key{DEL} every so often to
10024 clear previous results off the stack.
10026 You can press the apostrophe key during normal numeric entry to switch
10027 the half-entered number into Algebraic entry mode. One reason to do
10028 this would be to fix a typo, as the full Emacs cursor motion and editing
10029 keys are available during algebraic entry but not during numeric entry.
10031 In the same vein, during either numeric or algebraic entry you can
10032 press @kbd{`} (backquote) to switch to @code{calc-edit} mode, where
10033 you complete your half-finished entry in a separate buffer.
10034 @xref{Editing Stack Entries}.
10037 @pindex calc-algebraic-mode
10038 @cindex Algebraic Mode
10039 If you prefer algebraic entry, you can use the command @kbd{m a}
10040 (@code{calc-algebraic-mode}) to set Algebraic mode. In this mode,
10041 digits and other keys that would normally start numeric entry instead
10042 start full algebraic entry; as long as your formula begins with a digit
10043 you can omit the apostrophe. Open parentheses and square brackets also
10044 begin algebraic entry. You can still do RPN calculations in this mode,
10045 but you will have to press @key{RET} to terminate every number:
10046 @kbd{2 @key{RET} 3 @key{RET} * 4 @key{RET} +} would accomplish the same
10047 thing as @kbd{2*3+4 @key{RET}}.
10049 @cindex Incomplete Algebraic Mode
10050 If you give a numeric prefix argument like @kbd{C-u} to the @kbd{m a}
10051 command, it enables Incomplete Algebraic mode; this is like regular
10052 Algebraic mode except that it applies to the @kbd{(} and @kbd{[} keys
10053 only. Numeric keys still begin a numeric entry in this mode.
10056 @pindex calc-total-algebraic-mode
10057 @cindex Total Algebraic Mode
10058 The @kbd{m t} (@code{calc-total-algebraic-mode}) gives you an even
10059 stronger algebraic-entry mode, in which @emph{all} regular letter and
10060 punctuation keys begin algebraic entry. Use this if you prefer typing
10061 @w{@kbd{sqrt( )}} instead of @kbd{Q}, @w{@kbd{factor( )}} instead of
10062 @kbd{a f}, and so on. To type regular Calc commands when you are in
10063 Total Algebraic mode, hold down the @key{META} key. Thus @kbd{M-q}
10064 is the command to quit Calc, @kbd{M-p} sets the precision, and
10065 @kbd{M-m t} (or @kbd{M-m M-t}, if you prefer) turns Total Algebraic
10066 mode back off again. Meta keys also terminate algebraic entry, so
10067 that @kbd{2+3 M-S} is equivalent to @kbd{2+3 @key{RET} M-S}. The symbol
10068 @samp{Alg*} will appear in the mode line whenever you are in this mode.
10070 Pressing @kbd{'} (the apostrophe) a second time re-enters the previous
10071 algebraic formula. You can then use the normal Emacs editing keys to
10072 modify this formula to your liking before pressing @key{RET}.
10075 @cindex Formulas, referring to stack
10076 Within a formula entered from the keyboard, the symbol @kbd{$}
10077 represents the number on the top of the stack. If an entered formula
10078 contains any @kbd{$} characters, the Calculator replaces the top of
10079 stack with that formula rather than simply pushing the formula onto the
10080 stack. Thus, @kbd{' 1+2 @key{RET}} pushes 3 on the stack, and @kbd{$*2
10081 @key{RET}} replaces it with 6. Note that the @kbd{$} key always
10082 initiates algebraic entry; the @kbd{'} is unnecessary if @kbd{$} is the
10083 first character in the new formula.
10085 Higher stack elements can be accessed from an entered formula with the
10086 symbols @kbd{$$}, @kbd{$$$}, and so on. The number of stack elements
10087 removed (to be replaced by the entered values) equals the number of dollar
10088 signs in the longest such symbol in the formula. For example, @samp{$$+$$$}
10089 adds the second and third stack elements, replacing the top three elements
10090 with the answer. (All information about the top stack element is thus lost
10091 since no single @samp{$} appears in this formula.)
10093 A slightly different way to refer to stack elements is with a dollar
10094 sign followed by a number: @samp{$1}, @samp{$2}, and so on are much
10095 like @samp{$}, @samp{$$}, etc., except that stack entries referred
10096 to numerically are not replaced by the algebraic entry. That is, while
10097 @samp{$+1} replaces 5 on the stack with 6, @samp{$1+1} leaves the 5
10098 on the stack and pushes an additional 6.
10100 If a sequence of formulas are entered separated by commas, each formula
10101 is pushed onto the stack in turn. For example, @samp{1,2,3} pushes
10102 those three numbers onto the stack (leaving the 3 at the top), and
10103 @samp{$+1,$-1} replaces a 5 on the stack with 4 followed by 6. Also,
10104 @samp{$,$$} exchanges the top two elements of the stack, just like the
10107 You can finish an algebraic entry with @kbd{M-=} or @kbd{M-@key{RET}} instead
10108 of @key{RET}. This uses @kbd{=} to evaluate the variables in each
10109 formula that goes onto the stack. (Thus @kbd{' pi @key{RET}} pushes
10110 the variable @samp{pi}, but @kbd{' pi M-@key{RET}} pushes 3.1415.)
10112 If you finish your algebraic entry by pressing @key{LFD} (or @kbd{C-j})
10113 instead of @key{RET}, Calc disables simplification
10114 (as if by @kbd{m O}; @pxref{Simplification Modes}) while the entry
10115 is being pushed on the stack. Thus @kbd{' 1+2 @key{RET}} pushes 3
10116 on the stack, but @kbd{' 1+2 @key{LFD}} pushes the formula @expr{1+2};
10117 you might then press @kbd{=} when it is time to evaluate this formula.
10119 @node Quick Calculator, Prefix Arguments, Algebraic Entry, Introduction
10120 @section ``Quick Calculator'' Mode
10125 @cindex Quick Calculator
10126 There is another way to invoke the Calculator if all you need to do
10127 is make one or two quick calculations. Type @kbd{C-x * q} (or
10128 @kbd{M-x quick-calc}), then type any formula as an algebraic entry.
10129 The Calculator will compute the result and display it in the echo
10130 area, without ever actually putting up a Calc window.
10132 You can use the @kbd{$} character in a Quick Calculator formula to
10133 refer to the previous Quick Calculator result. Older results are
10134 not retained; the Quick Calculator has no effect on the full
10135 Calculator's stack or trail. If you compute a result and then
10136 forget what it was, just run @code{C-x * q} again and enter
10137 @samp{$} as the formula.
10139 If this is the first time you have used the Calculator in this Emacs
10140 session, the @kbd{C-x * q} command will create the @file{*Calculator*}
10141 buffer and perform all the usual initializations; it simply will
10142 refrain from putting that buffer up in a new window. The Quick
10143 Calculator refers to the @file{*Calculator*} buffer for all mode
10144 settings. Thus, for example, to set the precision that the Quick
10145 Calculator uses, simply run the full Calculator momentarily and use
10146 the regular @kbd{p} command.
10148 If you use @code{C-x * q} from inside the Calculator buffer, the
10149 effect is the same as pressing the apostrophe key (algebraic entry).
10151 The result of a Quick calculation is placed in the Emacs ``kill ring''
10152 as well as being displayed. A subsequent @kbd{C-y} command will
10153 yank the result into the editing buffer. You can also use this
10154 to yank the result into the next @kbd{C-x * q} input line as a more
10155 explicit alternative to @kbd{$} notation, or to yank the result
10156 into the Calculator stack after typing @kbd{C-x * c}.
10158 If you give a prefix argument to @kbd{C-x * q} or finish your formula
10159 by typing @key{LFD} (or @kbd{C-j}) instead of @key{RET}, the result is
10160 inserted immediately into the current buffer rather than going into
10163 Quick Calculator results are actually evaluated as if by the @kbd{=}
10164 key (which replaces variable names by their stored values, if any).
10165 If the formula you enter is an assignment to a variable using the
10166 @samp{:=} operator, say, @samp{foo := 2 + 3} or @samp{foo := foo + 1},
10167 then the result of the evaluation is stored in that Calc variable.
10168 @xref{Store and Recall}.
10170 If the result is an integer and the current display radix is decimal,
10171 the number will also be displayed in hex, octal and binary formats. If
10172 the integer is in the range from 1 to 126, it will also be displayed as
10173 an ASCII character.
10175 For example, the quoted character @samp{"x"} produces the vector
10176 result @samp{[120]} (because 120 is the ASCII code of the lower-case
10177 `x'; @pxref{Strings}). Since this is a vector, not an integer, it
10178 is displayed only according to the current mode settings. But
10179 running Quick Calc again and entering @samp{120} will produce the
10180 result @samp{120 (16#78, 8#170, x)} which shows the number in its
10181 decimal, hexadecimal, octal, and ASCII forms.
10183 Please note that the Quick Calculator is not any faster at loading
10184 or computing the answer than the full Calculator; the name ``quick''
10185 merely refers to the fact that it's much less hassle to use for
10186 small calculations.
10188 @node Prefix Arguments, Undo, Quick Calculator, Introduction
10189 @section Numeric Prefix Arguments
10192 Many Calculator commands use numeric prefix arguments. Some, such as
10193 @kbd{d s} (@code{calc-sci-notation}), set a parameter to the value of
10194 the prefix argument or use a default if you don't use a prefix.
10195 Others (like @kbd{d f} (@code{calc-fix-notation})) require an argument
10196 and prompt for a number if you don't give one as a prefix.
10198 As a rule, stack-manipulation commands accept a numeric prefix argument
10199 which is interpreted as an index into the stack. A positive argument
10200 operates on the top @var{n} stack entries; a negative argument operates
10201 on the @var{n}th stack entry in isolation; and a zero argument operates
10202 on the entire stack.
10204 Most commands that perform computations (such as the arithmetic and
10205 scientific functions) accept a numeric prefix argument that allows the
10206 operation to be applied across many stack elements. For unary operations
10207 (that is, functions of one argument like absolute value or complex
10208 conjugate), a positive prefix argument applies that function to the top
10209 @var{n} stack entries simultaneously, and a negative argument applies it
10210 to the @var{n}th stack entry only. For binary operations (functions of
10211 two arguments like addition, GCD, and vector concatenation), a positive
10212 prefix argument ``reduces'' the function across the top @var{n}
10213 stack elements (for example, @kbd{C-u 5 +} sums the top 5 stack entries;
10214 @pxref{Reducing and Mapping}), and a negative argument maps the next-to-top
10215 @var{n} stack elements with the top stack element as a second argument
10216 (for example, @kbd{7 c-u -5 +} adds 7 to the top 5 stack elements).
10217 This feature is not available for operations which use the numeric prefix
10218 argument for some other purpose.
10220 Numeric prefixes are specified the same way as always in Emacs: Press
10221 a sequence of @key{META}-digits, or press @key{ESC} followed by digits,
10222 or press @kbd{C-u} followed by digits. Some commands treat plain
10223 @kbd{C-u} (without any actual digits) specially.
10226 @pindex calc-num-prefix
10227 You can type @kbd{~} (@code{calc-num-prefix}) to pop an integer from the
10228 top of the stack and enter it as the numeric prefix for the next command.
10229 For example, @kbd{C-u 16 p} sets the precision to 16 digits; an alternate
10230 (silly) way to do this would be @kbd{2 @key{RET} 4 ^ ~ p}, i.e., compute 2
10231 to the fourth power and set the precision to that value.
10233 Conversely, if you have typed a numeric prefix argument the @kbd{~} key
10234 pushes it onto the stack in the form of an integer.
10236 @node Undo, Error Messages, Prefix Arguments, Introduction
10237 @section Undoing Mistakes
10243 @cindex Mistakes, undoing
10244 @cindex Undoing mistakes
10245 @cindex Errors, undoing
10246 The shift-@kbd{U} key (@code{calc-undo}) undoes the most recent operation.
10247 If that operation added or dropped objects from the stack, those objects
10248 are removed or restored. If it was a ``store'' operation, you are
10249 queried whether or not to restore the variable to its original value.
10250 The @kbd{U} key may be pressed any number of times to undo successively
10251 farther back in time; with a numeric prefix argument it undoes a
10252 specified number of operations. When the Calculator is quit, as with
10253 the @kbd{q} (@code{calc-quit}) command, the undo history will be
10254 truncated to the length of the customizable variable
10255 @code{calc-undo-length} (@pxref{Customizing Calc}), which by default
10256 is @expr{100}. (Recall that @kbd{C-x * c} is synonymous with
10257 @code{calc-quit} while inside the Calculator; this also truncates the
10260 Currently the mode-setting commands (like @code{calc-precision}) are not
10261 undoable. You can undo past a point where you changed a mode, but you
10262 will need to reset the mode yourself.
10266 @cindex Redoing after an Undo
10267 The shift-@kbd{D} key (@code{calc-redo}) redoes an operation that was
10268 mistakenly undone. Pressing @kbd{U} with a negative prefix argument is
10269 equivalent to executing @code{calc-redo}. You can redo any number of
10270 times, up to the number of recent consecutive undo commands. Redo
10271 information is cleared whenever you give any command that adds new undo
10272 information, i.e., if you undo, then enter a number on the stack or make
10273 any other change, then it will be too late to redo.
10275 @kindex M-@key{RET}
10276 @pindex calc-last-args
10277 @cindex Last-arguments feature
10278 @cindex Arguments, restoring
10279 The @kbd{M-@key{RET}} key (@code{calc-last-args}) is like undo in that
10280 it restores the arguments of the most recent command onto the stack;
10281 however, it does not remove the result of that command. Given a numeric
10282 prefix argument, this command applies to the @expr{n}th most recent
10283 command which removed items from the stack; it pushes those items back
10286 The @kbd{K} (@code{calc-keep-args}) command provides a related function
10287 to @kbd{M-@key{RET}}. @xref{Stack and Trail}.
10289 It is also possible to recall previous results or inputs using the trail.
10290 @xref{Trail Commands}.
10292 The standard Emacs @kbd{C-_} undo key is recognized as a synonym for @kbd{U}.
10294 @node Error Messages, Multiple Calculators, Undo, Introduction
10295 @section Error Messages
10300 @cindex Errors, messages
10301 @cindex Why did an error occur?
10302 Many situations that would produce an error message in other calculators
10303 simply create unsimplified formulas in the Emacs Calculator. For example,
10304 @kbd{1 @key{RET} 0 /} pushes the formula @expr{1 / 0}; @w{@kbd{0 L}} pushes
10305 the formula @samp{ln(0)}. Floating-point overflow and underflow are also
10306 reasons for this to happen.
10308 When a function call must be left in symbolic form, Calc usually
10309 produces a message explaining why. Messages that are probably
10310 surprising or indicative of user errors are displayed automatically.
10311 Other messages are simply kept in Calc's memory and are displayed only
10312 if you type @kbd{w} (@code{calc-why}). You can also press @kbd{w} if
10313 the same computation results in several messages. (The first message
10314 will end with @samp{[w=more]} in this case.)
10317 @pindex calc-auto-why
10318 The @kbd{d w} (@code{calc-auto-why}) command controls when error messages
10319 are displayed automatically. (Calc effectively presses @kbd{w} for you
10320 after your computation finishes.) By default, this occurs only for
10321 ``important'' messages. The other possible modes are to report
10322 @emph{all} messages automatically, or to report none automatically (so
10323 that you must always press @kbd{w} yourself to see the messages).
10325 @node Multiple Calculators, Troubleshooting Commands, Error Messages, Introduction
10326 @section Multiple Calculators
10329 @pindex another-calc
10330 It is possible to have any number of Calc mode buffers at once.
10331 Usually this is done by executing @kbd{M-x another-calc}, which
10332 is similar to @kbd{C-x * c} except that if a @file{*Calculator*}
10333 buffer already exists, a new, independent one with a name of the
10334 form @file{*Calculator*<@var{n}>} is created. You can also use the
10335 command @code{calc-mode} to put any buffer into Calculator mode, but
10336 this would ordinarily never be done.
10338 The @kbd{q} (@code{calc-quit}) command does not destroy a Calculator buffer;
10339 it only closes its window. Use @kbd{M-x kill-buffer} to destroy a
10342 Each Calculator buffer keeps its own stack, undo list, and mode settings
10343 such as precision, angular mode, and display formats. In Emacs terms,
10344 variables such as @code{calc-stack} are buffer-local variables. The
10345 global default values of these variables are used only when a new
10346 Calculator buffer is created. The @code{calc-quit} command saves
10347 the stack and mode settings of the buffer being quit as the new defaults.
10349 There is only one trail buffer, @file{*Calc Trail*}, used by all
10350 Calculator buffers.
10352 @node Troubleshooting Commands, , Multiple Calculators, Introduction
10353 @section Troubleshooting Commands
10356 This section describes commands you can use in case a computation
10357 incorrectly fails or gives the wrong answer.
10359 @xref{Reporting Bugs}, if you find a problem that appears to be due
10360 to a bug or deficiency in Calc.
10363 * Autoloading Problems::
10364 * Recursion Depth::
10369 @node Autoloading Problems, Recursion Depth, Troubleshooting Commands, Troubleshooting Commands
10370 @subsection Autoloading Problems
10373 The Calc program is split into many component files; components are
10374 loaded automatically as you use various commands that require them.
10375 Occasionally Calc may lose track of when a certain component is
10376 necessary; typically this means you will type a command and it won't
10377 work because some function you've never heard of was undefined.
10380 @pindex calc-load-everything
10381 If this happens, the easiest workaround is to type @kbd{C-x * L}
10382 (@code{calc-load-everything}) to force all the parts of Calc to be
10383 loaded right away. This will cause Emacs to take up a lot more
10384 memory than it would otherwise, but it's guaranteed to fix the problem.
10386 @node Recursion Depth, Caches, Autoloading Problems, Troubleshooting Commands
10387 @subsection Recursion Depth
10392 @pindex calc-more-recursion-depth
10393 @pindex calc-less-recursion-depth
10394 @cindex Recursion depth
10395 @cindex ``Computation got stuck'' message
10396 @cindex @code{max-lisp-eval-depth}
10397 @cindex @code{max-specpdl-size}
10398 Calc uses recursion in many of its calculations. Emacs Lisp keeps a
10399 variable @code{max-lisp-eval-depth} which limits the amount of recursion
10400 possible in an attempt to recover from program bugs. If a calculation
10401 ever halts incorrectly with the message ``Computation got stuck or
10402 ran too long,'' use the @kbd{M} command (@code{calc-more-recursion-depth})
10403 to increase this limit. (Of course, this will not help if the
10404 calculation really did get stuck due to some problem inside Calc.)
10406 The limit is always increased (multiplied) by a factor of two. There
10407 is also an @kbd{I M} (@code{calc-less-recursion-depth}) command which
10408 decreases this limit by a factor of two, down to a minimum value of 200.
10409 The default value is 1000.
10411 These commands also double or halve @code{max-specpdl-size}, another
10412 internal Lisp recursion limit. The minimum value for this limit is 600.
10414 @node Caches, Debugging Calc, Recursion Depth, Troubleshooting Commands
10419 @cindex Flushing caches
10420 Calc saves certain values after they have been computed once. For
10421 example, the @kbd{P} (@code{calc-pi}) command initially ``knows'' the
10422 constant @cpi{} to about 20 decimal places; if the current precision
10423 is greater than this, it will recompute @cpi{} using a series
10424 approximation. This value will not need to be recomputed ever again
10425 unless you raise the precision still further. Many operations such as
10426 logarithms and sines make use of similarly cached values such as
10428 @texline @math{\ln 2}.
10429 @infoline @expr{ln(2)}.
10430 The visible effect of caching is that
10431 high-precision computations may seem to do extra work the first time.
10432 Other things cached include powers of two (for the binary arithmetic
10433 functions), matrix inverses and determinants, symbolic integrals, and
10434 data points computed by the graphing commands.
10436 @pindex calc-flush-caches
10437 If you suspect a Calculator cache has become corrupt, you can use the
10438 @code{calc-flush-caches} command to reset all caches to the empty state.
10439 (This should only be necessary in the event of bugs in the Calculator.)
10440 The @kbd{C-x * 0} (with the zero key) command also resets caches along
10441 with all other aspects of the Calculator's state.
10443 @node Debugging Calc, , Caches, Troubleshooting Commands
10444 @subsection Debugging Calc
10447 A few commands exist to help in the debugging of Calc commands.
10448 @xref{Programming}, to see the various ways that you can write
10449 your own Calc commands.
10452 @pindex calc-timing
10453 The @kbd{Z T} (@code{calc-timing}) command turns on and off a mode
10454 in which the timing of slow commands is reported in the Trail.
10455 Any Calc command that takes two seconds or longer writes a line
10456 to the Trail showing how many seconds it took. This value is
10457 accurate only to within one second.
10459 All steps of executing a command are included; in particular, time
10460 taken to format the result for display in the stack and trail is
10461 counted. Some prompts also count time taken waiting for them to
10462 be answered, while others do not; this depends on the exact
10463 implementation of the command. For best results, if you are timing
10464 a sequence that includes prompts or multiple commands, define a
10465 keyboard macro to run the whole sequence at once. Calc's @kbd{X}
10466 command (@pxref{Keyboard Macros}) will then report the time taken
10467 to execute the whole macro.
10469 Another advantage of the @kbd{X} command is that while it is
10470 executing, the stack and trail are not updated from step to step.
10471 So if you expect the output of your test sequence to leave a result
10472 that may take a long time to format and you don't wish to count
10473 this formatting time, end your sequence with a @key{DEL} keystroke
10474 to clear the result from the stack. When you run the sequence with
10475 @kbd{X}, Calc will never bother to format the large result.
10477 Another thing @kbd{Z T} does is to increase the Emacs variable
10478 @code{gc-cons-threshold} to a much higher value (two million; the
10479 usual default in Calc is 250,000) for the duration of each command.
10480 This generally prevents garbage collection during the timing of
10481 the command, though it may cause your Emacs process to grow
10482 abnormally large. (Garbage collection time is a major unpredictable
10483 factor in the timing of Emacs operations.)
10485 Another command that is useful when debugging your own Lisp
10486 extensions to Calc is @kbd{M-x calc-pass-errors}, which disables
10487 the error handler that changes the ``@code{max-lisp-eval-depth}
10488 exceeded'' message to the much more friendly ``Computation got
10489 stuck or ran too long.'' This handler interferes with the Emacs
10490 Lisp debugger's @code{debug-on-error} mode. Errors are reported
10491 in the handler itself rather than at the true location of the
10492 error. After you have executed @code{calc-pass-errors}, Lisp
10493 errors will be reported correctly but the user-friendly message
10496 @node Data Types, Stack and Trail, Introduction, Top
10497 @chapter Data Types
10500 This chapter discusses the various types of objects that can be placed
10501 on the Calculator stack, how they are displayed, and how they are
10502 entered. (@xref{Data Type Formats}, for information on how these data
10503 types are represented as underlying Lisp objects.)
10505 Integers, fractions, and floats are various ways of describing real
10506 numbers. HMS forms also for many purposes act as real numbers. These
10507 types can be combined to form complex numbers, modulo forms, error forms,
10508 or interval forms. (But these last four types cannot be combined
10509 arbitrarily: error forms may not contain modulo forms, for example.)
10510 Finally, all these types of numbers may be combined into vectors,
10511 matrices, or algebraic formulas.
10514 * Integers:: The most basic data type.
10515 * Fractions:: This and above are called @dfn{rationals}.
10516 * Floats:: This and above are called @dfn{reals}.
10517 * Complex Numbers:: This and above are called @dfn{numbers}.
10519 * Vectors and Matrices::
10526 * Incomplete Objects::
10531 @node Integers, Fractions, Data Types, Data Types
10536 The Calculator stores integers to arbitrary precision. Addition,
10537 subtraction, and multiplication of integers always yields an exact
10538 integer result. (If the result of a division or exponentiation of
10539 integers is not an integer, it is expressed in fractional or
10540 floating-point form according to the current Fraction mode.
10541 @xref{Fraction Mode}.)
10543 A decimal integer is represented as an optional sign followed by a
10544 sequence of digits. Grouping (@pxref{Grouping Digits}) can be used to
10545 insert a comma at every third digit for display purposes, but you
10546 must not type commas during the entry of numbers.
10549 A non-decimal integer is represented as an optional sign, a radix
10550 between 2 and 36, a @samp{#} symbol, and one or more digits. For radix 11
10551 and above, the letters A through Z (upper- or lower-case) count as
10552 digits and do not terminate numeric entry mode. @xref{Radix Modes}, for how
10553 to set the default radix for display of integers. Numbers of any radix
10554 may be entered at any time. If you press @kbd{#} at the beginning of a
10555 number, the current display radix is used.
10557 @node Fractions, Floats, Integers, Data Types
10562 A @dfn{fraction} is a ratio of two integers. Fractions are traditionally
10563 written ``2/3'' but Calc uses the notation @samp{2:3}. (The @kbd{/} key
10564 performs RPN division; the following two sequences push the number
10565 @samp{2:3} on the stack: @kbd{2 :@: 3 @key{RET}}, or @kbd{2 @key{RET} 3 /}
10566 assuming Fraction mode has been enabled.)
10567 When the Calculator produces a fractional result it always reduces it to
10568 simplest form, which may in fact be an integer.
10570 Fractions may also be entered in a three-part form, where @samp{2:3:4}
10571 represents two-and-three-quarters. @xref{Fraction Formats}, for fraction
10574 Non-decimal fractions are entered and displayed as
10575 @samp{@var{radix}#@var{num}:@var{denom}} (or in the analogous three-part
10576 form). The numerator and denominator always use the same radix.
10578 @node Floats, Complex Numbers, Fractions, Data Types
10582 @cindex Floating-point numbers
10583 A floating-point number or @dfn{float} is a number stored in scientific
10584 notation. The number of significant digits in the fractional part is
10585 governed by the current floating precision (@pxref{Precision}). The
10586 range of acceptable values is from
10587 @texline @math{10^{-3999999}}
10588 @infoline @expr{10^-3999999}
10590 @texline @math{10^{4000000}}
10591 @infoline @expr{10^4000000}
10592 (exclusive), plus the corresponding negative values and zero.
10594 Calculations that would exceed the allowable range of values (such
10595 as @samp{exp(exp(20))}) are left in symbolic form by Calc. The
10596 messages ``floating-point overflow'' or ``floating-point underflow''
10597 indicate that during the calculation a number would have been produced
10598 that was too large or too close to zero, respectively, to be represented
10599 by Calc. This does not necessarily mean the final result would have
10600 overflowed, just that an overflow occurred while computing the result.
10601 (In fact, it could report an underflow even though the final result
10602 would have overflowed!)
10604 If a rational number and a float are mixed in a calculation, the result
10605 will in general be expressed as a float. Commands that require an integer
10606 value (such as @kbd{k g} [@code{gcd}]) will also accept integer-valued
10607 floats, i.e., floating-point numbers with nothing after the decimal point.
10609 Floats are identified by the presence of a decimal point and/or an
10610 exponent. In general a float consists of an optional sign, digits
10611 including an optional decimal point, and an optional exponent consisting
10612 of an @samp{e}, an optional sign, and up to seven exponent digits.
10613 For example, @samp{23.5e-2} is 23.5 times ten to the minus-second power,
10616 Floating-point numbers are normally displayed in decimal notation with
10617 all significant figures shown. Exceedingly large or small numbers are
10618 displayed in scientific notation. Various other display options are
10619 available. @xref{Float Formats}.
10621 @cindex Accuracy of calculations
10622 Floating-point numbers are stored in decimal, not binary. The result
10623 of each operation is rounded to the nearest value representable in the
10624 number of significant digits specified by the current precision,
10625 rounding away from zero in the case of a tie. Thus (in the default
10626 display mode) what you see is exactly what you get. Some operations such
10627 as square roots and transcendental functions are performed with several
10628 digits of extra precision and then rounded down, in an effort to make the
10629 final result accurate to the full requested precision. However,
10630 accuracy is not rigorously guaranteed. If you suspect the validity of a
10631 result, try doing the same calculation in a higher precision. The
10632 Calculator's arithmetic is not intended to be IEEE-conformant in any
10635 While floats are always @emph{stored} in decimal, they can be entered
10636 and displayed in any radix just like integers and fractions. Since a
10637 float that is entered in a radix other that 10 will be converted to
10638 decimal, the number that Calc stores may not be exactly the number that
10639 was entered, it will be the closest decimal approximation given the
10640 current precision. The notation @samp{@var{radix}#@var{ddd}.@var{ddd}}
10641 is a floating-point number whose digits are in the specified radix.
10642 Note that the @samp{.} is more aptly referred to as a ``radix point''
10643 than as a decimal point in this case. The number @samp{8#123.4567} is
10644 defined as @samp{8#1234567 * 8^-4}. If the radix is 14 or less, you can
10645 use @samp{e} notation to write a non-decimal number in scientific
10646 notation. The exponent is written in decimal, and is considered to be a
10647 power of the radix: @samp{8#1234567e-4}. If the radix is 15 or above,
10648 the letter @samp{e} is a digit, so scientific notation must be written
10649 out, e.g., @samp{16#123.4567*16^2}. The first two exercises of the
10650 Modes Tutorial explore some of the properties of non-decimal floats.
10652 @node Complex Numbers, Infinities, Floats, Data Types
10653 @section Complex Numbers
10656 @cindex Complex numbers
10657 There are two supported formats for complex numbers: rectangular and
10658 polar. The default format is rectangular, displayed in the form
10659 @samp{(@var{real},@var{imag})} where @var{real} is the real part and
10660 @var{imag} is the imaginary part, each of which may be any real number.
10661 Rectangular complex numbers can also be displayed in @samp{@var{a}+@var{b}i}
10662 notation; @pxref{Complex Formats}.
10664 Polar complex numbers are displayed in the form
10665 @texline `@tfn{(}@var{r}@tfn{;}@math{\theta}@tfn{)}'
10666 @infoline `@tfn{(}@var{r}@tfn{;}@var{theta}@tfn{)}'
10667 where @var{r} is the nonnegative magnitude and
10668 @texline @math{\theta}
10669 @infoline @var{theta}
10670 is the argument or phase angle. The range of
10671 @texline @math{\theta}
10672 @infoline @var{theta}
10673 depends on the current angular mode (@pxref{Angular Modes}); it is
10674 generally between @mathit{-180} and @mathit{+180} degrees or the equivalent range
10677 Complex numbers are entered in stages using incomplete objects.
10678 @xref{Incomplete Objects}.
10680 Operations on rectangular complex numbers yield rectangular complex
10681 results, and similarly for polar complex numbers. Where the two types
10682 are mixed, or where new complex numbers arise (as for the square root of
10683 a negative real), the current @dfn{Polar mode} is used to determine the
10684 type. @xref{Polar Mode}.
10686 A complex result in which the imaginary part is zero (or the phase angle
10687 is 0 or 180 degrees or @cpi{} radians) is automatically converted to a real
10690 @node Infinities, Vectors and Matrices, Complex Numbers, Data Types
10691 @section Infinities
10695 @cindex @code{inf} variable
10696 @cindex @code{uinf} variable
10697 @cindex @code{nan} variable
10701 The word @code{inf} represents the mathematical concept of @dfn{infinity}.
10702 Calc actually has three slightly different infinity-like values:
10703 @code{inf}, @code{uinf}, and @code{nan}. These are just regular
10704 variable names (@pxref{Variables}); you should avoid using these
10705 names for your own variables because Calc gives them special
10706 treatment. Infinities, like all variable names, are normally
10707 entered using algebraic entry.
10709 Mathematically speaking, it is not rigorously correct to treat
10710 ``infinity'' as if it were a number, but mathematicians often do
10711 so informally. When they say that @samp{1 / inf = 0}, what they
10712 really mean is that @expr{1 / x}, as @expr{x} becomes larger and
10713 larger, becomes arbitrarily close to zero. So you can imagine
10714 that if @expr{x} got ``all the way to infinity,'' then @expr{1 / x}
10715 would go all the way to zero. Similarly, when they say that
10716 @samp{exp(inf) = inf}, they mean that
10717 @texline @math{e^x}
10718 @infoline @expr{exp(x)}
10719 grows without bound as @expr{x} grows. The symbol @samp{-inf} likewise
10720 stands for an infinitely negative real value; for example, we say that
10721 @samp{exp(-inf) = 0}. You can have an infinity pointing in any
10722 direction on the complex plane: @samp{sqrt(-inf) = i inf}.
10724 The same concept of limits can be used to define @expr{1 / 0}. We
10725 really want the value that @expr{1 / x} approaches as @expr{x}
10726 approaches zero. But if all we have is @expr{1 / 0}, we can't
10727 tell which direction @expr{x} was coming from. If @expr{x} was
10728 positive and decreasing toward zero, then we should say that
10729 @samp{1 / 0 = inf}. But if @expr{x} was negative and increasing
10730 toward zero, the answer is @samp{1 / 0 = -inf}. In fact, @expr{x}
10731 could be an imaginary number, giving the answer @samp{i inf} or
10732 @samp{-i inf}. Calc uses the special symbol @samp{uinf} to mean
10733 @dfn{undirected infinity}, i.e., a value which is infinitely
10734 large but with an unknown sign (or direction on the complex plane).
10736 Calc actually has three modes that say how infinities are handled.
10737 Normally, infinities never arise from calculations that didn't
10738 already have them. Thus, @expr{1 / 0} is treated simply as an
10739 error and left unevaluated. The @kbd{m i} (@code{calc-infinite-mode})
10740 command (@pxref{Infinite Mode}) enables a mode in which
10741 @expr{1 / 0} evaluates to @code{uinf} instead. There is also
10742 an alternative type of infinite mode which says to treat zeros
10743 as if they were positive, so that @samp{1 / 0 = inf}. While this
10744 is less mathematically correct, it may be the answer you want in
10747 Since all infinities are ``as large'' as all others, Calc simplifies,
10748 e.g., @samp{5 inf} to @samp{inf}. Another example is
10749 @samp{5 - inf = -inf}, where the @samp{-inf} is so large that
10750 adding a finite number like five to it does not affect it.
10751 Note that @samp{a - inf} also results in @samp{-inf}; Calc assumes
10752 that variables like @code{a} always stand for finite quantities.
10753 Just to show that infinities really are all the same size,
10754 note that @samp{sqrt(inf) = inf^2 = exp(inf) = inf} in Calc's
10757 It's not so easy to define certain formulas like @samp{0 * inf} and
10758 @samp{inf / inf}. Depending on where these zeros and infinities
10759 came from, the answer could be literally anything. The latter
10760 formula could be the limit of @expr{x / x} (giving a result of one),
10761 or @expr{2 x / x} (giving two), or @expr{x^2 / x} (giving @code{inf}),
10762 or @expr{x / x^2} (giving zero). Calc uses the symbol @code{nan}
10763 to represent such an @dfn{indeterminate} value. (The name ``nan''
10764 comes from analogy with the ``NAN'' concept of IEEE standard
10765 arithmetic; it stands for ``Not A Number.'' This is somewhat of a
10766 misnomer, since @code{nan} @emph{does} stand for some number or
10767 infinity, it's just that @emph{which} number it stands for
10768 cannot be determined.) In Calc's notation, @samp{0 * inf = nan}
10769 and @samp{inf / inf = nan}. A few other common indeterminate
10770 expressions are @samp{inf - inf} and @samp{inf ^ 0}. Also,
10771 @samp{0 / 0 = nan} if you have turned on Infinite mode
10772 (as described above).
10774 Infinities are especially useful as parts of @dfn{intervals}.
10775 @xref{Interval Forms}.
10777 @node Vectors and Matrices, Strings, Infinities, Data Types
10778 @section Vectors and Matrices
10782 @cindex Plain vectors
10784 The @dfn{vector} data type is flexible and general. A vector is simply a
10785 list of zero or more data objects. When these objects are numbers, the
10786 whole is a vector in the mathematical sense. When these objects are
10787 themselves vectors of equal (nonzero) length, the whole is a @dfn{matrix}.
10788 A vector which is not a matrix is referred to here as a @dfn{plain vector}.
10790 A vector is displayed as a list of values separated by commas and enclosed
10791 in square brackets: @samp{[1, 2, 3]}. Thus the following is a 2 row by
10792 3 column matrix: @samp{[[1, 2, 3], [4, 5, 6]]}. Vectors, like complex
10793 numbers, are entered as incomplete objects. @xref{Incomplete Objects}.
10794 During algebraic entry, vectors are entered all at once in the usual
10795 brackets-and-commas form. Matrices may be entered algebraically as nested
10796 vectors, or using the shortcut notation @w{@samp{[1, 2, 3; 4, 5, 6]}},
10797 with rows separated by semicolons. The commas may usually be omitted
10798 when entering vectors: @samp{[1 2 3]}. Curly braces may be used in
10799 place of brackets: @samp{@{1, 2, 3@}}, but the commas are required in
10802 Traditional vector and matrix arithmetic is also supported;
10803 @pxref{Basic Arithmetic} and @pxref{Matrix Functions}.
10804 Many other operations are applied to vectors element-wise. For example,
10805 the complex conjugate of a vector is a vector of the complex conjugates
10812 Algebraic functions for building vectors include @samp{vec(a, b, c)}
10813 to build @samp{[a, b, c]}, @samp{cvec(a, n, m)} to build an
10814 @texline @math{n\times m}
10815 @infoline @var{n}x@var{m}
10816 matrix of @samp{a}s, and @samp{index(n)} to build a vector of integers
10817 from 1 to @samp{n}.
10819 @node Strings, HMS Forms, Vectors and Matrices, Data Types
10825 @cindex Character strings
10826 Character strings are not a special data type in the Calculator.
10827 Rather, a string is represented simply as a vector all of whose
10828 elements are integers in the range 0 to 255 (ASCII codes). You can
10829 enter a string at any time by pressing the @kbd{"} key. Quotation
10830 marks and backslashes are written @samp{\"} and @samp{\\}, respectively,
10831 inside strings. Other notations introduced by backslashes are:
10847 Finally, a backslash followed by three octal digits produces any
10848 character from its ASCII code.
10851 @pindex calc-display-strings
10852 Strings are normally displayed in vector-of-integers form. The
10853 @w{@kbd{d "}} (@code{calc-display-strings}) command toggles a mode in
10854 which any vectors of small integers are displayed as quoted strings
10857 The backslash notations shown above are also used for displaying
10858 strings. Characters 128 and above are not translated by Calc; unless
10859 you have an Emacs modified for 8-bit fonts, these will show up in
10860 backslash-octal-digits notation. For characters below 32, and
10861 for character 127, Calc uses the backslash-letter combination if
10862 there is one, or otherwise uses a @samp{\^} sequence.
10864 The only Calc feature that uses strings is @dfn{compositions};
10865 @pxref{Compositions}. Strings also provide a convenient
10866 way to do conversions between ASCII characters and integers.
10872 There is a @code{string} function which provides a different display
10873 format for strings. Basically, @samp{string(@var{s})}, where @var{s}
10874 is a vector of integers in the proper range, is displayed as the
10875 corresponding string of characters with no surrounding quotation
10876 marks or other modifications. Thus @samp{string("ABC")} (or
10877 @samp{string([65 66 67])}) will look like @samp{ABC} on the stack.
10878 This happens regardless of whether @w{@kbd{d "}} has been used. The
10879 only way to turn it off is to use @kbd{d U} (unformatted language
10880 mode) which will display @samp{string("ABC")} instead.
10882 Control characters are displayed somewhat differently by @code{string}.
10883 Characters below 32, and character 127, are shown using @samp{^} notation
10884 (same as shown above, but without the backslash). The quote and
10885 backslash characters are left alone, as are characters 128 and above.
10891 The @code{bstring} function is just like @code{string} except that
10892 the resulting string is breakable across multiple lines if it doesn't
10893 fit all on one line. Potential break points occur at every space
10894 character in the string.
10896 @node HMS Forms, Date Forms, Strings, Data Types
10900 @cindex Hours-minutes-seconds forms
10901 @cindex Degrees-minutes-seconds forms
10902 @dfn{HMS} stands for Hours-Minutes-Seconds; when used as an angular
10903 argument, the interpretation is Degrees-Minutes-Seconds. All functions
10904 that operate on angles accept HMS forms. These are interpreted as
10905 degrees regardless of the current angular mode. It is also possible to
10906 use HMS as the angular mode so that calculated angles are expressed in
10907 degrees, minutes, and seconds.
10913 @kindex ' (HMS forms)
10917 @kindex " (HMS forms)
10921 @kindex h (HMS forms)
10925 @kindex o (HMS forms)
10929 @kindex m (HMS forms)
10933 @kindex s (HMS forms)
10934 The default format for HMS values is
10935 @samp{@var{hours}@@ @var{mins}' @var{secs}"}. During entry, the letters
10936 @samp{h} (for ``hours'') or
10937 @samp{o} (approximating the ``degrees'' symbol) are accepted as well as
10938 @samp{@@}, @samp{m} is accepted in place of @samp{'}, and @samp{s} is
10939 accepted in place of @samp{"}.
10940 The @var{hours} value is an integer (or integer-valued float).
10941 The @var{mins} value is an integer or integer-valued float between 0 and 59.
10942 The @var{secs} value is a real number between 0 (inclusive) and 60
10943 (exclusive). A positive HMS form is interpreted as @var{hours} +
10944 @var{mins}/60 + @var{secs}/3600. A negative HMS form is interpreted
10945 as @mathit{- @var{hours}} @mathit{-} @var{mins}/60 @mathit{-} @var{secs}/3600.
10946 Display format for HMS forms is quite flexible. @xref{HMS Formats}.
10948 HMS forms can be added and subtracted. When they are added to numbers,
10949 the numbers are interpreted according to the current angular mode. HMS
10950 forms can also be multiplied and divided by real numbers. Dividing
10951 two HMS forms produces a real-valued ratio of the two angles.
10954 @cindex Time of day
10955 Just for kicks, @kbd{M-x calc-time} pushes the current time of day on
10956 the stack as an HMS form.
10958 @node Date Forms, Modulo Forms, HMS Forms, Data Types
10959 @section Date Forms
10963 A @dfn{date form} represents a date and possibly an associated time.
10964 Simple date arithmetic is supported: Adding a number to a date
10965 produces a new date shifted by that many days; adding an HMS form to
10966 a date shifts it by that many hours. Subtracting two date forms
10967 computes the number of days between them (represented as a simple
10968 number). Many other operations, such as multiplying two date forms,
10969 are nonsensical and are not allowed by Calc.
10971 Date forms are entered and displayed enclosed in @samp{< >} brackets.
10972 The default format is, e.g., @samp{<Wed Jan 9, 1991>} for dates,
10973 or @samp{<3:32:20pm Wed Jan 9, 1991>} for dates with times.
10974 Input is flexible; date forms can be entered in any of the usual
10975 notations for dates and times. @xref{Date Formats}.
10977 Date forms are stored internally as numbers, specifically the number
10978 of days since midnight on the morning of December 31 of the year 1 BC@.
10979 If the internal number is an integer, the form represents a date only;
10980 if the internal number is a fraction or float, the form represents
10981 a date and time. For example, @samp{<6:00am Thu Jan 10, 1991>}
10982 is represented by the number 726842.25. The standard precision of
10983 12 decimal digits is enough to ensure that a (reasonable) date and
10984 time can be stored without roundoff error.
10986 If the current precision is greater than 12, date forms will keep
10987 additional digits in the seconds position. For example, if the
10988 precision is 15, the seconds will keep three digits after the
10989 decimal point. Decreasing the precision below 12 may cause the
10990 time part of a date form to become inaccurate. This can also happen
10991 if astronomically high years are used, though this will not be an
10992 issue in everyday (or even everymillennium) use. Note that date
10993 forms without times are stored as exact integers, so roundoff is
10994 never an issue for them.
10996 You can use the @kbd{v p} (@code{calc-pack}) and @kbd{v u}
10997 (@code{calc-unpack}) commands to get at the numerical representation
10998 of a date form. @xref{Packing and Unpacking}.
11000 Date forms can go arbitrarily far into the future or past. Negative
11001 year numbers represent years BC@. There is no ``year 0''; the day
11002 before @samp{<Mon Jan 1, +1>} is @samp{<Sun Dec 31, -1>}. These are
11003 days 1 and 0 respectively in Calc's internal numbering scheme. The
11004 Gregorian calendar is used for all dates, including dates before the
11005 Gregorian calendar was invented (although that can be configured; see
11006 below). Thus Calc's use of the day number @mathit{-10000} to
11007 represent August 15, 28 BC should be taken with a grain of salt.
11009 @cindex Julian calendar
11010 @cindex Gregorian calendar
11011 Some historical background: The Julian calendar was created by
11012 Julius Caesar in the year 46 BC as an attempt to fix the confusion
11013 caused by the irregular Roman calendar that was used before that time.
11014 The Julian calendar introduced an extra day in all years divisible by
11015 four. After some initial confusion, the calendar was adopted around
11016 the year we call 8 AD@. Some centuries later it became
11017 apparent that the Julian year of 365.25 days was itself not quite
11018 right. In 1582 Pope Gregory XIII introduced the Gregorian calendar,
11019 which added the new rule that years divisible by 100, but not by 400,
11020 were not to be considered leap years despite being divisible by four.
11021 Many countries delayed adoption of the Gregorian calendar
11022 because of religious differences. For example, Great Britain and the
11023 British colonies switched to the Gregorian calendar in September
11024 1752, when the Julian calendar was eleven days behind the
11025 Gregorian calendar. That year in Britain, the day after September 2
11026 was September 14. To take another example, Russia did not adopt the
11027 Gregorian calendar until 1918, and that year in Russia the day after
11028 January 31 was February 14. Calc's reckoning therefore matches English
11029 practice starting in 1752 and Russian practice starting in 1918, but
11030 disagrees with earlier dates in both countries.
11032 When the Julian calendar was introduced, it had January 1 as the first
11033 day of the year. By the Middle Ages, many European countries
11034 had changed the beginning of a new year to a different date, often to
11035 a religious festival. Almost all countries reverted to using January 1
11036 as the beginning of the year by the time they adopted the Gregorian
11039 Some calendars attempt to mimic the historical situation by using the
11040 Gregorian calendar for recent dates and the Julian calendar for older
11041 dates. The @code{cal} program in most Unix implementations does this,
11042 for example. While January 1 wasn't always the beginning of a calendar
11043 year, these hybrid calendars still use January 1 as the beginning of
11044 the year even for older dates. The customizable variable
11045 @code{calc-gregorian-switch} (@pxref{Customizing Calc}) can be set to
11046 have Calc's date forms switch from the Julian to Gregorian calendar at
11047 any specified date.
11049 Today's timekeepers introduce an occasional ``leap second''.
11050 These do not occur regularly and Calc does not take these minor
11051 effects into account. (If it did, it would have to report a
11052 non-integer number of days between, say,
11053 @samp{<12:00am Mon Jan 1, 1900>} and
11054 @samp{<12:00am Sat Jan 1, 2000>}.)
11056 @cindex Julian day counting
11057 Another day counting system in common use is, confusingly, also called
11058 ``Julian.'' Julian days go from noon to noon. The Julian day number
11059 is the numbers of days since 12:00 noon (GMT) on November 24, 4714 BC
11060 in the Gregorian calendar (i.e., January 1, 4713 BC in the Julian
11061 calendar). In Calc's scheme (in GMT) the Julian day origin is
11062 @mathit{-1721422.5}, because Calc starts at midnight instead of noon.
11063 Thus to convert a Calc date code obtained by unpacking a
11064 date form into a Julian day number, simply add 1721422.5 after
11065 compensating for the time zone difference. The built-in @kbd{t J}
11066 command performs this conversion for you.
11068 The Julian day number is based on the Julian cycle, which was invented
11069 in 1583 by Joseph Justus Scaliger. Scaliger named it the Julian cycle
11070 since it involves the Julian calendar, but some have suggested that
11071 Scaliger named it in honor of his father, Julius Caesar Scaliger. The
11072 Julian cycle is based on three other cycles: the indiction cycle, the
11073 Metonic cycle, and the solar cycle. The indiction cycle is a 15 year
11074 cycle originally used by the Romans for tax purposes but later used to
11075 date medieval documents. The Metonic cycle is a 19 year cycle; 19
11076 years is close to being a common multiple of a solar year and a lunar
11077 month, and so every 19 years the phases of the moon will occur on the
11078 same days of the year. The solar cycle is a 28 year cycle; the Julian
11079 calendar repeats itself every 28 years. The smallest time period
11080 which contains multiples of all three cycles is the least common
11081 multiple of 15 years, 19 years and 28 years, which (since they're
11082 pairwise relatively prime) is
11083 @texline @math{15\times 19\times 28 = 7980} years.
11084 @infoline 15*19*28 = 7980 years.
11085 This is the length of a Julian cycle. Working backwards, the previous
11086 year in which all three cycles began was 4713 BC, and so Scaliger
11087 chose that year as the beginning of a Julian cycle. Since at the time
11088 there were no historical records from before 4713 BC, using this year
11089 as a starting point had the advantage of avoiding negative year
11090 numbers. In 1849, the astronomer John Herschel (son of William
11091 Herschel) suggested using the number of days since the beginning of
11092 the Julian cycle as an astronomical dating system; this idea was taken
11093 up by other astronomers. (At the time, noon was the start of the
11094 astronomical day. Herschel originally suggested counting the days
11095 since Jan 1, 4713 BC at noon Alexandria time; this was later amended to
11096 noon GMT@.) Julian day numbering is largely used in astronomy.
11098 @cindex Unix time format
11099 The Unix operating system measures time as an integer number of
11100 seconds since midnight, Jan 1, 1970. To convert a Calc date
11101 value into a Unix time stamp, first subtract 719164 (the code
11102 for @samp{<Jan 1, 1970>}), then multiply by 86400 (the number of
11103 seconds in a day) and press @kbd{R} to round to the nearest
11104 integer. If you have a date form, you can simply subtract the
11105 day @samp{<Jan 1, 1970>} instead of unpacking and subtracting
11106 719164. Likewise, divide by 86400 and add @samp{<Jan 1, 1970>}
11107 to convert from Unix time to a Calc date form. (Note that
11108 Unix normally maintains the time in the GMT time zone; you may
11109 need to subtract five hours to get New York time, or eight hours
11110 for California time. The same is usually true of Julian day
11111 counts.) The built-in @kbd{t U} command performs these
11114 @node Modulo Forms, Error Forms, Date Forms, Data Types
11115 @section Modulo Forms
11118 @cindex Modulo forms
11119 A @dfn{modulo form} is a real number which is taken modulo (i.e., within
11120 an integer multiple of) some value @var{M}. Arithmetic modulo @var{M}
11121 often arises in number theory. Modulo forms are written
11122 `@var{a} @tfn{mod} @var{M}',
11123 where @var{a} and @var{M} are real numbers or HMS forms, and
11124 @texline @math{0 \le a < M}.
11125 @infoline @expr{0 <= a < @var{M}}.
11126 In many applications @expr{a} and @expr{M} will be
11127 integers but this is not required.
11132 @kindex M (modulo forms)
11136 @tindex mod (operator)
11137 To create a modulo form during numeric entry, press the shift-@kbd{M}
11138 key to enter the word @samp{mod}. As a special convenience, pressing
11139 shift-@kbd{M} a second time automatically enters the value of @expr{M}
11140 that was most recently used before. During algebraic entry, either
11141 type @samp{mod} by hand or press @kbd{M-m} (that's @kbd{@key{META}-m}).
11142 Once again, pressing this a second time enters the current modulo.
11144 Modulo forms are not to be confused with the modulo operator @samp{%}.
11145 The expression @samp{27 % 10} means to compute 27 modulo 10 to produce
11146 the result 7. Further computations treat this 7 as just a regular integer.
11147 The expression @samp{27 mod 10} produces the result @samp{7 mod 10};
11148 further computations with this value are again reduced modulo 10 so that
11149 the result always lies in the desired range.
11151 When two modulo forms with identical @expr{M}'s are added or multiplied,
11152 the Calculator simply adds or multiplies the values, then reduces modulo
11153 @expr{M}. If one argument is a modulo form and the other a plain number,
11154 the plain number is treated like a compatible modulo form. It is also
11155 possible to raise modulo forms to powers; the result is the value raised
11156 to the power, then reduced modulo @expr{M}. (When all values involved
11157 are integers, this calculation is done much more efficiently than
11158 actually computing the power and then reducing.)
11160 @cindex Modulo division
11161 Two modulo forms `@var{a} @tfn{mod} @var{M}' and `@var{b} @tfn{mod} @var{M}'
11162 can be divided if @expr{a}, @expr{b}, and @expr{M} are all
11163 integers. The result is the modulo form which, when multiplied by
11164 `@var{b} @tfn{mod} @var{M}', produces `@var{a} @tfn{mod} @var{M}'. If
11165 there is no solution to this equation (which can happen only when
11166 @expr{M} is non-prime), or if any of the arguments are non-integers, the
11167 division is left in symbolic form. Other operations, such as square
11168 roots, are not yet supported for modulo forms. (Note that, although
11169 @w{`@tfn{(}@var{a} @tfn{mod} @var{M}@tfn{)^.5}'} will compute a ``modulo square root''
11170 in the sense of reducing
11171 @texline @math{\sqrt a}
11172 @infoline @expr{sqrt(a)}
11173 modulo @expr{M}, this is not a useful definition from the
11174 number-theoretical point of view.)
11176 It is possible to mix HMS forms and modulo forms. For example, an
11177 HMS form modulo 24 could be used to manipulate clock times; an HMS
11178 form modulo 360 would be suitable for angles. Making the modulo @expr{M}
11179 also be an HMS form eliminates troubles that would arise if the angular
11180 mode were inadvertently set to Radians, in which case
11181 @w{@samp{2@@ 0' 0" mod 24}} would be interpreted as two degrees modulo
11184 Modulo forms cannot have variables or formulas for components. If you
11185 enter the formula @samp{(x + 2) mod 5}, Calc propagates the modulus
11186 to each of the coefficients: @samp{(1 mod 5) x + (2 mod 5)}.
11188 You can use @kbd{v p} and @kbd{%} to modify modulo forms.
11189 @xref{Packing and Unpacking}. @xref{Basic Arithmetic}.
11195 The algebraic function @samp{makemod(a, m)} builds the modulo form
11196 @w{@samp{a mod m}}.
11198 @node Error Forms, Interval Forms, Modulo Forms, Data Types
11199 @section Error Forms
11202 @cindex Error forms
11203 @cindex Standard deviations
11204 An @dfn{error form} is a number with an associated standard
11205 deviation, as in @samp{2.3 +/- 0.12}. The notation
11206 @texline `@var{x} @tfn{+/-} @math{\sigma}'
11207 @infoline `@var{x} @tfn{+/-} sigma'
11208 stands for an uncertain value which follows
11209 a normal or Gaussian distribution of mean @expr{x} and standard
11210 deviation or ``error''
11211 @texline @math{\sigma}.
11212 @infoline @expr{sigma}.
11213 Both the mean and the error can be either numbers or
11214 formulas. Generally these are real numbers but the mean may also be
11215 complex. If the error is negative or complex, it is changed to its
11216 absolute value. An error form with zero error is converted to a
11217 regular number by the Calculator.
11219 All arithmetic and transcendental functions accept error forms as input.
11220 Operations on the mean-value part work just like operations on regular
11221 numbers. The error part for any function @expr{f(x)} (such as
11222 @texline @math{\sin x}
11223 @infoline @expr{sin(x)})
11224 is defined by the error of @expr{x} times the derivative of @expr{f}
11225 evaluated at the mean value of @expr{x}. For a two-argument function
11226 @expr{f(x,y)} (such as addition) the error is the square root of the sum
11227 of the squares of the errors due to @expr{x} and @expr{y}.
11230 f(x \hbox{\code{ +/- }} \sigma)
11231 &= f(x) \hbox{\code{ +/- }} \sigma \left| {df(x) \over dx} \right| \cr
11232 f(x \hbox{\code{ +/- }} \sigma_x, y \hbox{\code{ +/- }} \sigma_y)
11233 &= f(x,y) \hbox{\code{ +/- }}
11234 \sqrt{\left(\sigma_x \left| {\partial f(x,y) \over \partial x}
11236 +\left(\sigma_y \left| {\partial f(x,y) \over \partial y}
11237 \right| \right)^2 } \cr
11241 definition assumes the errors in @expr{x} and @expr{y} are uncorrelated.
11242 A side effect of this definition is that @samp{(2 +/- 1) * (2 +/- 1)}
11243 is not the same as @samp{(2 +/- 1)^2}; the former represents the product
11244 of two independent values which happen to have the same probability
11245 distributions, and the latter is the product of one random value with itself.
11246 The former will produce an answer with less error, since on the average
11247 the two independent errors can be expected to cancel out.
11249 Consult a good text on error analysis for a discussion of the proper use
11250 of standard deviations. Actual errors often are neither Gaussian-distributed
11251 nor uncorrelated, and the above formulas are valid only when errors
11252 are small. As an example, the error arising from
11253 @texline `@tfn{sin(}@var{x} @tfn{+/-} @math{\sigma}@tfn{)}'
11254 @infoline `@tfn{sin(}@var{x} @tfn{+/-} @var{sigma}@tfn{)}'
11256 @texline `@math{\sigma} @tfn{abs(cos(}@var{x}@tfn{))}'.
11257 @infoline `@var{sigma} @tfn{abs(cos(}@var{x}@tfn{))}'.
11258 When @expr{x} is close to zero,
11259 @texline @math{\cos x}
11260 @infoline @expr{cos(x)}
11261 is close to one so the error in the sine is close to
11262 @texline @math{\sigma};
11263 @infoline @expr{sigma};
11264 this makes sense, since
11265 @texline @math{\sin x}
11266 @infoline @expr{sin(x)}
11267 is approximately @expr{x} near zero, so a given error in @expr{x} will
11268 produce about the same error in the sine. Likewise, near 90 degrees
11269 @texline @math{\cos x}
11270 @infoline @expr{cos(x)}
11271 is nearly zero and so the computed error is
11272 small: The sine curve is nearly flat in that region, so an error in @expr{x}
11273 has relatively little effect on the value of
11274 @texline @math{\sin x}.
11275 @infoline @expr{sin(x)}.
11276 However, consider @samp{sin(90 +/- 1000)}. The cosine of 90 is zero, so
11277 Calc will report zero error! We get an obviously wrong result because
11278 we have violated the small-error approximation underlying the error
11279 analysis. If the error in @expr{x} had been small, the error in
11280 @texline @math{\sin x}
11281 @infoline @expr{sin(x)}
11282 would indeed have been negligible.
11287 @kindex p (error forms)
11289 To enter an error form during regular numeric entry, use the @kbd{p}
11290 (``plus-or-minus'') key to type the @samp{+/-} symbol. (If you try actually
11291 typing @samp{+/-} the @kbd{+} key will be interpreted as the Calculator's
11292 @kbd{+} command!) Within an algebraic formula, you can press @kbd{M-+} to
11293 type the @samp{+/-} symbol, or type it out by hand.
11295 Error forms and complex numbers can be mixed; the formulas shown above
11296 are used for complex numbers, too; note that if the error part evaluates
11297 to a complex number its absolute value (or the square root of the sum of
11298 the squares of the absolute values of the two error contributions) is
11299 used. Mathematically, this corresponds to a radially symmetric Gaussian
11300 distribution of numbers on the complex plane. However, note that Calc
11301 considers an error form with real components to represent a real number,
11302 not a complex distribution around a real mean.
11304 Error forms may also be composed of HMS forms. For best results, both
11305 the mean and the error should be HMS forms if either one is.
11311 The algebraic function @samp{sdev(a, b)} builds the error form @samp{a +/- b}.
11313 @node Interval Forms, Incomplete Objects, Error Forms, Data Types
11314 @section Interval Forms
11317 @cindex Interval forms
11318 An @dfn{interval} is a subset of consecutive real numbers. For example,
11319 the interval @samp{[2 ..@: 4]} represents all the numbers from 2 to 4,
11320 inclusive. If you multiply it by the interval @samp{[0.5 ..@: 2]} you
11321 obtain @samp{[1 ..@: 8]}. This calculation represents the fact that if
11322 you multiply some number in the range @samp{[2 ..@: 4]} by some other
11323 number in the range @samp{[0.5 ..@: 2]}, your result will lie in the range
11324 from 1 to 8. Interval arithmetic is used to get a worst-case estimate
11325 of the possible range of values a computation will produce, given the
11326 set of possible values of the input.
11329 Calc supports several varieties of intervals, including @dfn{closed}
11330 intervals of the type shown above, @dfn{open} intervals such as
11331 @samp{(2 ..@: 4)}, which represents the range of numbers from 2 to 4
11332 @emph{exclusive}, and @dfn{semi-open} intervals in which one end
11333 uses a round parenthesis and the other a square bracket. In mathematical
11335 @samp{[2 ..@: 4]} means @expr{2 <= x <= 4}, whereas
11336 @samp{[2 ..@: 4)} represents @expr{2 <= x < 4},
11337 @samp{(2 ..@: 4]} represents @expr{2 < x <= 4}, and
11338 @samp{(2 ..@: 4)} represents @expr{2 < x < 4}.
11341 Calc supports several varieties of intervals, including \dfn{closed}
11342 intervals of the type shown above, \dfn{open} intervals such as
11343 \samp{(2 ..\: 4)}, which represents the range of numbers from 2 to 4
11344 \emph{exclusive}, and \dfn{semi-open} intervals in which one end
11345 uses a round parenthesis and the other a square bracket. In mathematical
11348 [2 \hbox{\cite{..}} 4] &\quad\hbox{means}\quad 2 \le x \le 4 \cr
11349 [2 \hbox{\cite{..}} 4) &\quad\hbox{means}\quad 2 \le x < 4 \cr
11350 (2 \hbox{\cite{..}} 4] &\quad\hbox{means}\quad 2 < x \le 4 \cr
11351 (2 \hbox{\cite{..}} 4) &\quad\hbox{means}\quad 2 < x < 4 \cr
11355 The lower and upper limits of an interval must be either real numbers
11356 (or HMS or date forms), or symbolic expressions which are assumed to be
11357 real-valued, or @samp{-inf} and @samp{inf}. In general the lower limit
11358 must be less than the upper limit. A closed interval containing only
11359 one value, @samp{[3 ..@: 3]}, is converted to a plain number (3)
11360 automatically. An interval containing no values at all (such as
11361 @samp{[3 ..@: 2]} or @samp{[2 ..@: 2)}) can be represented but is not
11362 guaranteed to behave well when used in arithmetic. Note that the
11363 interval @samp{[3 .. inf)} represents all real numbers greater than
11364 or equal to 3, and @samp{(-inf .. inf)} represents all real numbers.
11365 In fact, @samp{[-inf .. inf]} represents all real numbers including
11366 the real infinities.
11368 Intervals are entered in the notation shown here, either as algebraic
11369 formulas, or using incomplete forms. (@xref{Incomplete Objects}.)
11370 In algebraic formulas, multiple periods in a row are collected from
11371 left to right, so that @samp{1...1e2} is interpreted as @samp{1.0 ..@: 1e2}
11372 rather than @samp{1 ..@: 0.1e2}. Add spaces or zeros if you want to
11373 get the other interpretation. If you omit the lower or upper limit,
11374 a default of @samp{-inf} or @samp{inf} (respectively) is furnished.
11376 Infinite mode also affects operations on intervals
11377 (@pxref{Infinities}). Calc will always introduce an open infinity,
11378 as in @samp{1 / (0 .. 2] = [0.5 .. inf)}. But closed infinities,
11379 @w{@samp{1 / [0 .. 2] = [0.5 .. inf]}}, arise only in Infinite mode;
11380 otherwise they are left unevaluated. Note that the ``direction'' of
11381 a zero is not an issue in this case since the zero is always assumed
11382 to be continuous with the rest of the interval. For intervals that
11383 contain zero inside them Calc is forced to give the result,
11384 @samp{1 / (-2 .. 2) = [-inf .. inf]}.
11386 While it may seem that intervals and error forms are similar, they are
11387 based on entirely different concepts of inexact quantities. An error
11389 @texline `@var{x} @tfn{+/-} @math{\sigma}'
11390 @infoline `@var{x} @tfn{+/-} @var{sigma}'
11391 means a variable is random, and its value could
11392 be anything but is ``probably'' within one
11393 @texline @math{\sigma}
11394 @infoline @var{sigma}
11395 of the mean value @expr{x}. An interval
11396 `@tfn{[}@var{a} @tfn{..@:} @var{b}@tfn{]}' means a
11397 variable's value is unknown, but guaranteed to lie in the specified
11398 range. Error forms are statistical or ``average case'' approximations;
11399 interval arithmetic tends to produce ``worst case'' bounds on an
11402 Intervals may not contain complex numbers, but they may contain
11403 HMS forms or date forms.
11405 @xref{Set Operations}, for commands that interpret interval forms
11406 as subsets of the set of real numbers.
11412 The algebraic function @samp{intv(n, a, b)} builds an interval form
11413 from @samp{a} to @samp{b}; @samp{n} is an integer code which must
11414 be 0 for @samp{(..)}, 1 for @samp{(..]}, 2 for @samp{[..)}, or
11417 Please note that in fully rigorous interval arithmetic, care would be
11418 taken to make sure that the computation of the lower bound rounds toward
11419 minus infinity, while upper bound computations round toward plus
11420 infinity. Calc's arithmetic always uses a round-to-nearest mode,
11421 which means that roundoff errors could creep into an interval
11422 calculation to produce intervals slightly smaller than they ought to
11423 be. For example, entering @samp{[1..2]} and pressing @kbd{Q 2 ^}
11424 should yield the interval @samp{[1..2]} again, but in fact it yields the
11425 (slightly too small) interval @samp{[1..1.9999999]} due to roundoff
11428 @node Incomplete Objects, Variables, Interval Forms, Data Types
11429 @section Incomplete Objects
11449 @cindex Incomplete vectors
11450 @cindex Incomplete complex numbers
11451 @cindex Incomplete interval forms
11452 When @kbd{(} or @kbd{[} is typed to begin entering a complex number or
11453 vector, respectively, the effect is to push an @dfn{incomplete} complex
11454 number or vector onto the stack. The @kbd{,} key adds the value(s) at
11455 the top of the stack onto the current incomplete object. The @kbd{)}
11456 and @kbd{]} keys ``close'' the incomplete object after adding any values
11457 on the top of the stack in front of the incomplete object.
11459 As a result, the sequence of keystrokes @kbd{[ 2 , 3 @key{RET} 2 * , 9 ]}
11460 pushes the vector @samp{[2, 6, 9]} onto the stack. Likewise, @kbd{( 1 , 2 Q )}
11461 pushes the complex number @samp{(1, 1.414)} (approximately).
11463 If several values lie on the stack in front of the incomplete object,
11464 all are collected and appended to the object. Thus the @kbd{,} key
11465 is redundant: @kbd{[ 2 @key{RET} 3 @key{RET} 2 * 9 ]}. Some people
11466 prefer the equivalent @key{SPC} key to @key{RET}.
11468 As a special case, typing @kbd{,} immediately after @kbd{(}, @kbd{[}, or
11469 @kbd{,} adds a zero or duplicates the preceding value in the list being
11470 formed. Typing @key{DEL} during incomplete entry removes the last item
11474 The @kbd{;} key is used in the same way as @kbd{,} to create polar complex
11475 numbers: @kbd{( 1 ; 2 )}. When entering a vector, @kbd{;} is useful for
11476 creating a matrix. In particular, @kbd{[ [ 1 , 2 ; 3 , 4 ; 5 , 6 ] ]} is
11477 equivalent to @kbd{[ [ 1 , 2 ] , [ 3 , 4 ] , [ 5 , 6 ] ]}.
11481 Incomplete entry is also used to enter intervals. For example,
11482 @kbd{[ 2 ..@: 4 )} enters a semi-open interval. Note that when you type
11483 the first period, it will be interpreted as a decimal point, but when
11484 you type a second period immediately afterward, it is re-interpreted as
11485 part of the interval symbol. Typing @kbd{..} corresponds to executing
11486 the @code{calc-dots} command.
11488 If you find incomplete entry distracting, you may wish to enter vectors
11489 and complex numbers as algebraic formulas by pressing the apostrophe key.
11491 @node Variables, Formulas, Incomplete Objects, Data Types
11495 @cindex Variables, in formulas
11496 A @dfn{variable} is somewhere between a storage register on a conventional
11497 calculator, and a variable in a programming language. (In fact, a Calc
11498 variable is really just an Emacs Lisp variable that contains a Calc number
11499 or formula.) A variable's name is normally composed of letters and digits.
11500 Calc also allows apostrophes and @code{#} signs in variable names.
11501 (The Calc variable @code{foo} corresponds to the Emacs Lisp variable
11502 @code{var-foo}, but unless you access the variable from within Emacs
11503 Lisp, you don't need to worry about it. Variable names in algebraic
11504 formulas implicitly have @samp{var-} prefixed to their names. The
11505 @samp{#} character in variable names used in algebraic formulas
11506 corresponds to a dash @samp{-} in the Lisp variable name. If the name
11507 contains any dashes, the prefix @samp{var-} is @emph{not} automatically
11508 added. Thus the two formulas @samp{foo + 1} and @samp{var#foo + 1} both
11509 refer to the same variable.)
11511 In a command that takes a variable name, you can either type the full
11512 name of a variable, or type a single digit to use one of the special
11513 convenience variables @code{q0} through @code{q9}. For example,
11514 @kbd{3 s s 2} stores the number 3 in variable @code{q2}, and
11515 @w{@kbd{3 s s foo @key{RET}}} stores that number in variable
11518 To push a variable itself (as opposed to the variable's value) on the
11519 stack, enter its name as an algebraic expression using the apostrophe
11523 @pindex calc-evaluate
11524 @cindex Evaluation of variables in a formula
11525 @cindex Variables, evaluation
11526 @cindex Formulas, evaluation
11527 The @kbd{=} (@code{calc-evaluate}) key ``evaluates'' a formula by
11528 replacing all variables in the formula which have been given values by a
11529 @code{calc-store} or @code{calc-let} command by their stored values.
11530 Other variables are left alone. Thus a variable that has not been
11531 stored acts like an abstract variable in algebra; a variable that has
11532 been stored acts more like a register in a traditional calculator.
11533 With a positive numeric prefix argument, @kbd{=} evaluates the top
11534 @var{n} stack entries; with a negative argument, @kbd{=} evaluates
11535 the @var{n}th stack entry.
11537 @cindex @code{e} variable
11538 @cindex @code{pi} variable
11539 @cindex @code{i} variable
11540 @cindex @code{phi} variable
11541 @cindex @code{gamma} variable
11547 A few variables are called @dfn{special constants}. Their names are
11548 @samp{e}, @samp{pi}, @samp{i}, @samp{phi}, and @samp{gamma}.
11549 (@xref{Scientific Functions}.) When they are evaluated with @kbd{=},
11550 their values are calculated if necessary according to the current precision
11551 or complex polar mode. If you wish to use these symbols for other purposes,
11552 simply undefine or redefine them using @code{calc-store}.
11554 The variables @samp{inf}, @samp{uinf}, and @samp{nan} stand for
11555 infinite or indeterminate values. It's best not to use them as
11556 regular variables, since Calc uses special algebraic rules when
11557 it manipulates them. Calc displays a warning message if you store
11558 a value into any of these special variables.
11560 @xref{Store and Recall}, for a discussion of commands dealing with variables.
11562 @node Formulas, , Variables, Data Types
11567 @cindex Expressions
11568 @cindex Operators in formulas
11569 @cindex Precedence of operators
11570 When you press the apostrophe key you may enter any expression or formula
11571 in algebraic form. (Calc uses the terms ``expression'' and ``formula''
11572 interchangeably.) An expression is built up of numbers, variable names,
11573 and function calls, combined with various arithmetic operators.
11575 be used to indicate grouping. Spaces are ignored within formulas, except
11576 that spaces are not permitted within variable names or numbers.
11577 Arithmetic operators, in order from highest to lowest precedence, and
11578 with their equivalent function names, are:
11580 @samp{_} [@code{subscr}] (subscripts);
11582 postfix @samp{%} [@code{percent}] (as in @samp{25% = 0.25});
11584 prefix @samp{!} [@code{lnot}] (logical ``not,'' as in @samp{!x});
11586 @samp{+/-} [@code{sdev}] (the standard deviation symbol) and
11587 @samp{mod} [@code{makemod}] (the symbol for modulo forms);
11589 postfix @samp{!} [@code{fact}] (factorial, as in @samp{n!})
11590 and postfix @samp{!!} [@code{dfact}] (double factorial);
11592 @samp{^} [@code{pow}] (raised-to-the-power-of);
11594 prefix @samp{+} and @samp{-} [@code{neg}] (as in @samp{-x});
11596 @samp{*} [@code{mul}];
11598 @samp{/} [@code{div}], @samp{%} [@code{mod}] (modulo), and
11599 @samp{\} [@code{idiv}] (integer division);
11601 infix @samp{+} [@code{add}] and @samp{-} [@code{sub}] (as in @samp{x-y});
11603 @samp{|} [@code{vconcat}] (vector concatenation);
11605 relations @samp{=} [@code{eq}], @samp{!=} [@code{neq}], @samp{<} [@code{lt}],
11606 @samp{>} [@code{gt}], @samp{<=} [@code{leq}], and @samp{>=} [@code{geq}];
11608 @samp{&&} [@code{land}] (logical ``and'');
11610 @samp{||} [@code{lor}] (logical ``or'');
11612 the C-style ``if'' operator @samp{a?b:c} [@code{if}];
11614 @samp{!!!} [@code{pnot}] (rewrite pattern ``not'');
11616 @samp{&&&} [@code{pand}] (rewrite pattern ``and'');
11618 @samp{|||} [@code{por}] (rewrite pattern ``or'');
11620 @samp{:=} [@code{assign}] (for assignments and rewrite rules);
11622 @samp{::} [@code{condition}] (rewrite pattern condition);
11624 @samp{=>} [@code{evalto}].
11626 Note that, unlike in usual computer notation, multiplication binds more
11627 strongly than division: @samp{a*b/c*d} is equivalent to
11628 @texline @math{a b \over c d}.
11629 @infoline @expr{(a*b)/(c*d)}.
11631 @cindex Multiplication, implicit
11632 @cindex Implicit multiplication
11633 The multiplication sign @samp{*} may be omitted in many cases. In particular,
11634 if the righthand side is a number, variable name, or parenthesized
11635 expression, the @samp{*} may be omitted. Implicit multiplication has the
11636 same precedence as the explicit @samp{*} operator. The one exception to
11637 the rule is that a variable name followed by a parenthesized expression,
11639 is interpreted as a function call, not an implicit @samp{*}. In many
11640 cases you must use a space if you omit the @samp{*}: @samp{2a} is the
11641 same as @samp{2*a}, and @samp{a b} is the same as @samp{a*b}, but @samp{ab}
11642 is a variable called @code{ab}, @emph{not} the product of @samp{a} and
11643 @samp{b}! Also note that @samp{f (x)} is still a function call.
11645 @cindex Implicit comma in vectors
11646 The rules are slightly different for vectors written with square brackets.
11647 In vectors, the space character is interpreted (like the comma) as a
11648 separator of elements of the vector. Thus @w{@samp{[ 2a b+c d ]}} is
11649 equivalent to @samp{[2*a, b+c, d]}, whereas @samp{2a b+c d} is equivalent
11650 to @samp{2*a*b + c*d}.
11651 Note that spaces around the brackets, and around explicit commas, are
11652 ignored. To force spaces to be interpreted as multiplication you can
11653 enclose a formula in parentheses as in @samp{[(a b) 2(c d)]}, which is
11654 interpreted as @samp{[a*b, 2*c*d]}. An implicit comma is also inserted
11655 between @samp{][}, as in the matrix @samp{[[1 2][3 4]]}.
11657 Vectors that contain commas (not embedded within nested parentheses or
11658 brackets) do not treat spaces specially: @samp{[a b, 2 c d]} is a vector
11659 of two elements. Also, if it would be an error to treat spaces as
11660 separators, but not otherwise, then Calc will ignore spaces:
11661 @w{@samp{[a - b]}} is a vector of one element, but @w{@samp{[a -b]}} is
11662 a vector of two elements. Finally, vectors entered with curly braces
11663 instead of square brackets do not give spaces any special treatment.
11664 When Calc displays a vector that does not contain any commas, it will
11665 insert parentheses if necessary to make the meaning clear:
11666 @w{@samp{[(a b)]}}.
11668 The expression @samp{5%-2} is ambiguous; is this five-percent minus two,
11669 or five modulo minus-two? Calc always interprets the leftmost symbol as
11670 an infix operator preferentially (modulo, in this case), so you would
11671 need to write @samp{(5%)-2} to get the former interpretation.
11673 @cindex Function call notation
11674 A function call is, e.g., @samp{sin(1+x)}. (The Calc algebraic function
11675 @code{foo} corresponds to the Emacs Lisp function @code{calcFunc-foo},
11676 but unless you access the function from within Emacs Lisp, you don't
11677 need to worry about it.) Most mathematical Calculator commands like
11678 @code{calc-sin} have function equivalents like @code{sin}.
11679 If no Lisp function is defined for a function called by a formula, the
11680 call is left as it is during algebraic manipulation: @samp{f(x+y)} is
11681 left alone. Beware that many innocent-looking short names like @code{in}
11682 and @code{re} have predefined meanings which could surprise you; however,
11683 single letters or single letters followed by digits are always safe to
11684 use for your own function names. @xref{Function Index}.
11686 In the documentation for particular commands, the notation @kbd{H S}
11687 (@code{calc-sinh}) [@code{sinh}] means that the key sequence @kbd{H S}, the
11688 command @kbd{M-x calc-sinh}, and the algebraic function @code{sinh(x)} all
11689 represent the same operation.
11691 Commands that interpret (``parse'') text as algebraic formulas include
11692 algebraic entry (@kbd{'}), editing commands like @kbd{`} which parse
11693 the contents of the editing buffer when you finish, the @kbd{C-x * g}
11694 and @w{@kbd{C-x * r}} commands, the @kbd{C-y} command, the X window system
11695 ``paste'' mouse operation, and Embedded mode. All of these operations
11696 use the same rules for parsing formulas; in particular, language modes
11697 (@pxref{Language Modes}) affect them all in the same way.
11699 When you read a large amount of text into the Calculator (say a vector
11700 which represents a big set of rewrite rules; @pxref{Rewrite Rules}),
11701 you may wish to include comments in the text. Calc's formula parser
11702 ignores the symbol @samp{%%} and anything following it on a line:
11705 [ a + b, %% the sum of "a" and "b"
11707 %% last line is coming up:
11712 This is parsed exactly the same as @samp{[ a + b, c + d, e + f ]}.
11714 @xref{Syntax Tables}, for a way to create your own operators and other
11715 input notations. @xref{Compositions}, for a way to create new display
11718 @xref{Algebra}, for commands for manipulating formulas symbolically.
11720 @node Stack and Trail, Mode Settings, Data Types, Top
11721 @chapter Stack and Trail Commands
11724 This chapter describes the Calc commands for manipulating objects on the
11725 stack and in the trail buffer. (These commands operate on objects of any
11726 type, such as numbers, vectors, formulas, and incomplete objects.)
11729 * Stack Manipulation::
11730 * Editing Stack Entries::
11735 @node Stack Manipulation, Editing Stack Entries, Stack and Trail, Stack and Trail
11736 @section Stack Manipulation Commands
11742 @cindex Duplicating stack entries
11743 To duplicate the top object on the stack, press @key{RET} or @key{SPC}
11744 (two equivalent keys for the @code{calc-enter} command).
11745 Given a positive numeric prefix argument, these commands duplicate
11746 several elements at the top of the stack.
11747 Given a negative argument,
11748 these commands duplicate the specified element of the stack.
11749 Given an argument of zero, they duplicate the entire stack.
11750 For example, with @samp{10 20 30} on the stack,
11751 @key{RET} creates @samp{10 20 30 30},
11752 @kbd{C-u 2 @key{RET}} creates @samp{10 20 30 20 30},
11753 @kbd{C-u - 2 @key{RET}} creates @samp{10 20 30 20}, and
11754 @kbd{C-u 0 @key{RET}} creates @samp{10 20 30 10 20 30}.
11758 The @key{LFD} (@code{calc-over}) command (on a key marked Line-Feed if you
11759 have it, else on @kbd{C-j}) is like @code{calc-enter}
11760 except that the sign of the numeric prefix argument is interpreted
11761 oppositely. Also, with no prefix argument the default argument is 2.
11762 Thus with @samp{10 20 30} on the stack, @key{LFD} and @kbd{C-u 2 @key{LFD}}
11763 are both equivalent to @kbd{C-u - 2 @key{RET}}, producing
11764 @samp{10 20 30 20}.
11769 @cindex Removing stack entries
11770 @cindex Deleting stack entries
11771 To remove the top element from the stack, press @key{DEL} (@code{calc-pop}).
11772 The @kbd{C-d} key is a synonym for @key{DEL}.
11773 (If the top element is an incomplete object with at least one element, the
11774 last element is removed from it.) Given a positive numeric prefix argument,
11775 several elements are removed. Given a negative argument, the specified
11776 element of the stack is deleted. Given an argument of zero, the entire
11778 For example, with @samp{10 20 30} on the stack,
11779 @key{DEL} leaves @samp{10 20},
11780 @kbd{C-u 2 @key{DEL}} leaves @samp{10},
11781 @kbd{C-u - 2 @key{DEL}} leaves @samp{10 30}, and
11782 @kbd{C-u 0 @key{DEL}} leaves an empty stack.
11784 @kindex M-@key{DEL}
11785 @pindex calc-pop-above
11786 The @kbd{M-@key{DEL}} (@code{calc-pop-above}) command is to @key{DEL} what
11787 @key{LFD} is to @key{RET}: It interprets the sign of the numeric
11788 prefix argument in the opposite way, and the default argument is 2.
11789 Thus @kbd{M-@key{DEL}} by itself removes the second-from-top stack element,
11790 leaving the first, third, fourth, and so on; @kbd{M-3 M-@key{DEL}} deletes
11791 the third stack element.
11793 The above commands do not depend on the location of the cursor.
11794 If the customizable variable @code{calc-context-sensitive-enter} is
11795 non-@code{nil} (@pxref{Customizing Calc}), these commands will become
11796 context sensitive. For example, instead of duplicating the top of the stack,
11797 @key{RET} will copy the element at the cursor to the top of the
11798 stack. With a positive numeric prefix, a copy of the element at the
11799 cursor and the appropriate number of preceding elements will be placed
11800 at the top of the stack. A negative prefix will still duplicate the
11801 specified element of the stack regardless of the cursor position.
11802 Similarly, @key{DEL} will remove the corresponding elements from the
11806 @pindex calc-roll-down
11807 To exchange the top two elements of the stack, press @key{TAB}
11808 (@code{calc-roll-down}). Given a positive numeric prefix argument, the
11809 specified number of elements at the top of the stack are rotated downward.
11810 Given a negative argument, the entire stack is rotated downward the specified
11811 number of times. Given an argument of zero, the entire stack is reversed
11813 For example, with @samp{10 20 30 40 50} on the stack,
11814 @key{TAB} creates @samp{10 20 30 50 40},
11815 @kbd{C-u 3 @key{TAB}} creates @samp{10 20 50 30 40},
11816 @kbd{C-u - 2 @key{TAB}} creates @samp{40 50 10 20 30}, and
11817 @kbd{C-u 0 @key{TAB}} creates @samp{50 40 30 20 10}.
11819 @kindex M-@key{TAB}
11820 @pindex calc-roll-up
11821 The command @kbd{M-@key{TAB}} (@code{calc-roll-up}) is analogous to @key{TAB}
11822 except that it rotates upward instead of downward. Also, the default
11823 with no prefix argument is to rotate the top 3 elements.
11824 For example, with @samp{10 20 30 40 50} on the stack,
11825 @kbd{M-@key{TAB}} creates @samp{10 20 40 50 30},
11826 @kbd{C-u 4 M-@key{TAB}} creates @samp{10 30 40 50 20},
11827 @kbd{C-u - 2 M-@key{TAB}} creates @samp{30 40 50 10 20}, and
11828 @kbd{C-u 0 M-@key{TAB}} creates @samp{50 40 30 20 10}.
11830 A good way to view the operation of @key{TAB} and @kbd{M-@key{TAB}} is in
11831 terms of moving a particular element to a new position in the stack.
11832 With a positive argument @var{n}, @key{TAB} moves the top stack
11833 element down to level @var{n}, making room for it by pulling all the
11834 intervening stack elements toward the top. @kbd{M-@key{TAB}} moves the
11835 element at level @var{n} up to the top. (Compare with @key{LFD},
11836 which copies instead of moving the element in level @var{n}.)
11838 With a negative argument @mathit{-@var{n}}, @key{TAB} rotates the stack
11839 to move the object in level @var{n} to the deepest place in the
11840 stack, and the object in level @mathit{@var{n}+1} to the top. @kbd{M-@key{TAB}}
11841 rotates the deepest stack element to be in level @var{n}, also
11842 putting the top stack element in level @mathit{@var{n}+1}.
11844 @xref{Selecting Subformulas}, for a way to apply these commands to
11845 any portion of a vector or formula on the stack.
11848 @pindex calc-transpose-lines
11849 @cindex Moving stack entries
11850 The command @kbd{C-x C-t} (@code{calc-transpose-lines}) will transpose
11851 the stack object determined by the point with the stack object at the
11852 next higher level. For example, with @samp{10 20 30 40 50} on the
11853 stack and the point on the line containing @samp{30}, @kbd{C-x C-t}
11854 creates @samp{10 20 40 30 50}. More generally, @kbd{C-x C-t} acts on
11855 the stack objects determined by the current point (and mark) similar
11856 to how the text-mode command @code{transpose-lines} acts on
11857 lines. With argument @var{n}, @kbd{C-x C-t} will move the stack object
11858 at the level above the current point and move it past N other objects;
11859 for example, with @samp{10 20 30 40 50} on the stack and the point on
11860 the line containing @samp{30}, @kbd{C-u 2 C-x C-t} creates
11861 @samp{10 40 20 30 50}. With an argument of 0, @kbd{C-x C-t} will switch
11862 the stack objects at the levels determined by the point and the mark.
11864 @node Editing Stack Entries, Trail Commands, Stack Manipulation, Stack and Trail
11865 @section Editing Stack Entries
11870 @pindex calc-edit-finish
11871 @cindex Editing the stack with Emacs
11872 The @kbd{`} (@code{calc-edit}) command creates a temporary buffer
11873 (@file{*Calc Edit*}) for editing the top-of-stack value using regular
11874 Emacs commands. Note that @kbd{`} is a backquote, not a quote. With a
11875 numeric prefix argument, it edits the specified number of stack entries
11876 at once. (An argument of zero edits the entire stack; a negative
11877 argument edits one specific stack entry.)
11879 When you are done editing, press @kbd{C-c C-c} to finish and return
11880 to Calc. The @key{RET} and @key{LFD} keys also work to finish most
11881 sorts of editing, though in some cases Calc leaves @key{RET} with its
11882 usual meaning (``insert a newline'') if it's a situation where you
11883 might want to insert new lines into the editing buffer.
11885 When you finish editing, the Calculator parses the lines of text in
11886 the @file{*Calc Edit*} buffer as numbers or formulas, replaces the
11887 original stack elements in the original buffer with these new values,
11888 then kills the @file{*Calc Edit*} buffer. The original Calculator buffer
11889 continues to exist during editing, but for best results you should be
11890 careful not to change it until you have finished the edit. You can
11891 also cancel the edit by killing the buffer with @kbd{C-x k}.
11893 The formula is normally reevaluated as it is put onto the stack.
11894 For example, editing @samp{a + 2} to @samp{3 + 2} and pressing
11895 @kbd{C-c C-c} will push 5 on the stack. If you use @key{LFD} to
11896 finish, Calc will put the result on the stack without evaluating it.
11898 If you give a prefix argument to @kbd{C-c C-c},
11899 Calc will not kill the @file{*Calc Edit*} buffer. You can switch
11900 back to that buffer and continue editing if you wish. However, you
11901 should understand that if you initiated the edit with @kbd{`}, the
11902 @kbd{C-c C-c} operation will be programmed to replace the top of the
11903 stack with the new edited value, and it will do this even if you have
11904 rearranged the stack in the meanwhile. This is not so much of a problem
11905 with other editing commands, though, such as @kbd{s e}
11906 (@code{calc-edit-variable}; @pxref{Operations on Variables}).
11908 If the @code{calc-edit} command involves more than one stack entry,
11909 each line of the @file{*Calc Edit*} buffer is interpreted as a
11910 separate formula. Otherwise, the entire buffer is interpreted as
11911 one formula, with line breaks ignored. (You can use @kbd{C-o} or
11912 @kbd{C-q C-j} to insert a newline in the buffer without pressing @key{RET}.)
11914 The @kbd{`} key also works during numeric or algebraic entry. The
11915 text entered so far is moved to the @file{*Calc Edit*} buffer for
11916 more extensive editing than is convenient in the minibuffer.
11918 @node Trail Commands, Keep Arguments, Editing Stack Entries, Stack and Trail
11919 @section Trail Commands
11922 @cindex Trail buffer
11923 The commands for manipulating the Calc Trail buffer are two-key sequences
11924 beginning with the @kbd{t} prefix.
11927 @pindex calc-trail-display
11928 The @kbd{t d} (@code{calc-trail-display}) command turns display of the
11929 trail on and off. Normally the trail display is toggled on if it was off,
11930 off if it was on. With a numeric prefix of zero, this command always
11931 turns the trail off; with a prefix of one, it always turns the trail on.
11932 The other trail-manipulation commands described here automatically turn
11933 the trail on. Note that when the trail is off values are still recorded
11934 there; they are simply not displayed. To set Emacs to turn the trail
11935 off by default, type @kbd{t d} and then save the mode settings with
11936 @kbd{m m} (@code{calc-save-modes}).
11939 @pindex calc-trail-in
11941 @pindex calc-trail-out
11942 The @kbd{t i} (@code{calc-trail-in}) and @kbd{t o}
11943 (@code{calc-trail-out}) commands switch the cursor into and out of the
11944 Calc Trail window. In practice they are rarely used, since the commands
11945 shown below are a more convenient way to move around in the
11946 trail, and they work ``by remote control'' when the cursor is still
11947 in the Calculator window.
11949 @cindex Trail pointer
11950 There is a @dfn{trail pointer} which selects some entry of the trail at
11951 any given time. The trail pointer looks like a @samp{>} symbol right
11952 before the selected number. The following commands operate on the
11953 trail pointer in various ways.
11956 @pindex calc-trail-yank
11957 @cindex Retrieving previous results
11958 The @kbd{t y} (@code{calc-trail-yank}) command reads the selected value in
11959 the trail and pushes it onto the Calculator stack. It allows you to
11960 re-use any previously computed value without retyping. With a numeric
11961 prefix argument @var{n}, it yanks the value @var{n} lines above the current
11965 @pindex calc-trail-scroll-left
11967 @pindex calc-trail-scroll-right
11968 The @kbd{t <} (@code{calc-trail-scroll-left}) and @kbd{t >}
11969 (@code{calc-trail-scroll-right}) commands horizontally scroll the trail
11970 window left or right by one half of its width.
11973 @pindex calc-trail-next
11975 @pindex calc-trail-previous
11977 @pindex calc-trail-forward
11979 @pindex calc-trail-backward
11980 The @kbd{t n} (@code{calc-trail-next}) and @kbd{t p}
11981 (@code{calc-trail-previous)} commands move the trail pointer down or up
11982 one line. The @kbd{t f} (@code{calc-trail-forward}) and @kbd{t b}
11983 (@code{calc-trail-backward}) commands move the trail pointer down or up
11984 one screenful at a time. All of these commands accept numeric prefix
11985 arguments to move several lines or screenfuls at a time.
11988 @pindex calc-trail-first
11990 @pindex calc-trail-last
11992 @pindex calc-trail-here
11993 The @kbd{t [} (@code{calc-trail-first}) and @kbd{t ]}
11994 (@code{calc-trail-last}) commands move the trail pointer to the first or
11995 last line of the trail. The @kbd{t h} (@code{calc-trail-here}) command
11996 moves the trail pointer to the cursor position; unlike the other trail
11997 commands, @kbd{t h} works only when Calc Trail is the selected window.
12000 @pindex calc-trail-isearch-forward
12002 @pindex calc-trail-isearch-backward
12004 The @kbd{t s} (@code{calc-trail-isearch-forward}) and @kbd{t r}
12005 (@code{calc-trail-isearch-backward}) commands perform an incremental
12006 search forward or backward through the trail. You can press @key{RET}
12007 to terminate the search; the trail pointer moves to the current line.
12008 If you cancel the search with @kbd{C-g}, the trail pointer stays where
12009 it was when the search began.
12012 The @kbd{t s} (@code{calc-trail-isearch-forward}) and @kbd{t r}
12013 (@code{calc-trail-isearch-backward}) com\-mands perform an incremental
12014 search forward or backward through the trail. You can press @key{RET}
12015 to terminate the search; the trail pointer moves to the current line.
12016 If you cancel the search with @kbd{C-g}, the trail pointer stays where
12017 it was when the search began.
12021 @pindex calc-trail-marker
12022 The @kbd{t m} (@code{calc-trail-marker}) command allows you to enter a
12023 line of text of your own choosing into the trail. The text is inserted
12024 after the line containing the trail pointer; this usually means it is
12025 added to the end of the trail. Trail markers are useful mainly as the
12026 targets for later incremental searches in the trail.
12029 @pindex calc-trail-kill
12030 The @kbd{t k} (@code{calc-trail-kill}) command removes the selected line
12031 from the trail. The line is saved in the Emacs kill ring suitable for
12032 yanking into another buffer, but it is not easy to yank the text back
12033 into the trail buffer. With a numeric prefix argument, this command
12034 kills the @var{n} lines below or above the selected one.
12036 The @kbd{t .} (@code{calc-full-trail-vectors}) command is described
12037 elsewhere; @pxref{Vector and Matrix Formats}.
12039 @node Keep Arguments, , Trail Commands, Stack and Trail
12040 @section Keep Arguments
12044 @pindex calc-keep-args
12045 The @kbd{K} (@code{calc-keep-args}) command acts like a prefix for
12046 the following command. It prevents that command from removing its
12047 arguments from the stack. For example, after @kbd{2 @key{RET} 3 +},
12048 the stack contains the sole number 5, but after @kbd{2 @key{RET} 3 K +},
12049 the stack contains the arguments and the result: @samp{2 3 5}.
12051 With the exception of keyboard macros, this works for all commands that
12052 take arguments off the stack. (To avoid potentially unpleasant behavior,
12053 a @kbd{K} prefix before a keyboard macro will be ignored. A @kbd{K}
12054 prefix called @emph{within} the keyboard macro will still take effect.)
12055 As another example, @kbd{K a s} simplifies a formula, pushing the
12056 simplified version of the formula onto the stack after the original
12057 formula (rather than replacing the original formula). Note that you
12058 could get the same effect by typing @kbd{@key{RET} a s}, copying the
12059 formula and then simplifying the copy. One difference is that for a very
12060 large formula the time taken to format the intermediate copy in
12061 @kbd{@key{RET} a s} could be noticeable; @kbd{K a s} would avoid this
12064 Even stack manipulation commands are affected. @key{TAB} works by
12065 popping two values and pushing them back in the opposite order,
12066 so @kbd{2 @key{RET} 3 K @key{TAB}} produces @samp{2 3 3 2}.
12068 A few Calc commands provide other ways of doing the same thing.
12069 For example, @kbd{' sin($)} replaces the number on the stack with
12070 its sine using algebraic entry; to push the sine and keep the
12071 original argument you could use either @kbd{' sin($1)} or
12072 @kbd{K ' sin($)}. @xref{Algebraic Entry}. Also, the @kbd{s s}
12073 command is effectively the same as @kbd{K s t}. @xref{Storing Variables}.
12075 If you execute a command and then decide you really wanted to keep
12076 the argument, you can press @kbd{M-@key{RET}} (@code{calc-last-args}).
12077 This command pushes the last arguments that were popped by any command
12078 onto the stack. Note that the order of things on the stack will be
12079 different than with @kbd{K}: @kbd{2 @key{RET} 3 + M-@key{RET}} leaves
12080 @samp{5 2 3} on the stack instead of @samp{2 3 5}. @xref{Undo}.
12082 @node Mode Settings, Arithmetic, Stack and Trail, Top
12083 @chapter Mode Settings
12086 This chapter describes commands that set modes in the Calculator.
12087 They do not affect the contents of the stack, although they may change
12088 the @emph{appearance} or @emph{interpretation} of the stack's contents.
12091 * General Mode Commands::
12093 * Inverse and Hyperbolic::
12094 * Calculation Modes::
12095 * Simplification Modes::
12103 @node General Mode Commands, Precision, Mode Settings, Mode Settings
12104 @section General Mode Commands
12108 @pindex calc-save-modes
12109 @cindex Continuous memory
12110 @cindex Saving mode settings
12111 @cindex Permanent mode settings
12112 @cindex Calc init file, mode settings
12113 You can save all of the current mode settings in your Calc init file
12114 (the file given by the variable @code{calc-settings-file}, typically
12115 @file{~/.emacs.d/calc.el}) with the @kbd{m m} (@code{calc-save-modes})
12116 command. This will cause Emacs to reestablish these modes each time
12117 it starts up. The modes saved in the file include everything
12118 controlled by the @kbd{m} and @kbd{d} prefix keys, the current
12119 precision and binary word size, whether or not the trail is displayed,
12120 the current height of the Calc window, and more. The current
12121 interface (used when you type @kbd{C-x * *}) is also saved. If there
12122 were already saved mode settings in the file, they are replaced.
12123 Otherwise, the new mode information is appended to the end of the
12127 @pindex calc-mode-record-mode
12128 The @kbd{m R} (@code{calc-mode-record-mode}) command tells Calc to
12129 record all the mode settings (as if by pressing @kbd{m m}) every
12130 time a mode setting changes. If the modes are saved this way, then this
12131 ``automatic mode recording'' mode is also saved.
12132 Type @kbd{m R} again to disable this method of recording the mode
12133 settings. To turn it off permanently, the @kbd{m m} command will also be
12134 necessary. (If Embedded mode is enabled, other options for recording
12135 the modes are available; @pxref{Mode Settings in Embedded Mode}.)
12138 @pindex calc-settings-file-name
12139 The @kbd{m F} (@code{calc-settings-file-name}) command allows you to
12140 choose a different file than the current value of @code{calc-settings-file}
12141 for @kbd{m m}, @kbd{Z P}, and similar commands to save permanent information.
12142 You are prompted for a file name. All Calc modes are then reset to
12143 their default values, then settings from the file you named are loaded
12144 if this file exists, and this file becomes the one that Calc will
12145 use in the future for commands like @kbd{m m}. The default settings
12146 file name is @file{~/.emacs.d/calc.el}. You can see the current file name by
12147 giving a blank response to the @kbd{m F} prompt. See also the
12148 discussion of the @code{calc-settings-file} variable; @pxref{Customizing Calc}.
12150 If the file name you give is your user init file (typically
12151 @file{~/.emacs}), @kbd{m F} will not automatically load the new file. This
12152 is because your user init file may contain other things you don't want
12153 to reread. You can give
12154 a numeric prefix argument of 1 to @kbd{m F} to force it to read the
12155 file no matter what. Conversely, an argument of @mathit{-1} tells
12156 @kbd{m F} @emph{not} to read the new file. An argument of 2 or @mathit{-2}
12157 tells @kbd{m F} not to reset the modes to their defaults beforehand,
12158 which is useful if you intend your new file to have a variant of the
12159 modes present in the file you were using before.
12162 @pindex calc-always-load-extensions
12163 The @kbd{m x} (@code{calc-always-load-extensions}) command enables a mode
12164 in which the first use of Calc loads the entire program, including all
12165 extensions modules. Otherwise, the extensions modules will not be loaded
12166 until the various advanced Calc features are used. Since this mode only
12167 has effect when Calc is first loaded, @kbd{m x} is usually followed by
12168 @kbd{m m} to make the mode-setting permanent. To load all of Calc just
12169 once, rather than always in the future, you can press @kbd{C-x * L}.
12172 @pindex calc-shift-prefix
12173 The @kbd{m S} (@code{calc-shift-prefix}) command enables a mode in which
12174 all of Calc's letter prefix keys may be typed shifted as well as unshifted.
12175 If you are typing, say, @kbd{a S} (@code{calc-solve-for}) quite often
12176 you might find it easier to turn this mode on so that you can type
12177 @kbd{A S} instead. When this mode is enabled, the commands that used to
12178 be on those single shifted letters (e.g., @kbd{A} (@code{calc-abs})) can
12179 now be invoked by pressing the shifted letter twice: @kbd{A A}. Note
12180 that the @kbd{v} prefix key always works both shifted and unshifted, and
12181 the @kbd{z} and @kbd{Z} prefix keys are always distinct. Also, the @kbd{h}
12182 prefix is not affected by this mode. Press @kbd{m S} again to disable
12183 shifted-prefix mode.
12185 @node Precision, Inverse and Hyperbolic, General Mode Commands, Mode Settings
12190 @pindex calc-precision
12191 @cindex Precision of calculations
12192 The @kbd{p} (@code{calc-precision}) command controls the precision to
12193 which floating-point calculations are carried. The precision must be
12194 at least 3 digits and may be arbitrarily high, within the limits of
12195 memory and time. This affects only floats: Integer and rational
12196 calculations are always carried out with as many digits as necessary.
12198 The @kbd{p} key prompts for the current precision. If you wish you
12199 can instead give the precision as a numeric prefix argument.
12201 Many internal calculations are carried to one or two digits higher
12202 precision than normal. Results are rounded down afterward to the
12203 current precision. Unless a special display mode has been selected,
12204 floats are always displayed with their full stored precision, i.e.,
12205 what you see is what you get. Reducing the current precision does not
12206 round values already on the stack, but those values will be rounded
12207 down before being used in any calculation. The @kbd{c 0} through
12208 @kbd{c 9} commands (@pxref{Conversions}) can be used to round an
12209 existing value to a new precision.
12211 @cindex Accuracy of calculations
12212 It is important to distinguish the concepts of @dfn{precision} and
12213 @dfn{accuracy}. In the normal usage of these words, the number
12214 123.4567 has a precision of 7 digits but an accuracy of 4 digits.
12215 The precision is the total number of digits not counting leading
12216 or trailing zeros (regardless of the position of the decimal point).
12217 The accuracy is simply the number of digits after the decimal point
12218 (again not counting trailing zeros). In Calc you control the precision,
12219 not the accuracy of computations. If you were to set the accuracy
12220 instead, then calculations like @samp{exp(100)} would generate many
12221 more digits than you would typically need, while @samp{exp(-100)} would
12222 probably round to zero! In Calc, both these computations give you
12223 exactly 12 (or the requested number of) significant digits.
12225 The only Calc features that deal with accuracy instead of precision
12226 are fixed-point display mode for floats (@kbd{d f}; @pxref{Float Formats}),
12227 and the rounding functions like @code{floor} and @code{round}
12228 (@pxref{Integer Truncation}). Also, @kbd{c 0} through @kbd{c 9}
12229 deal with both precision and accuracy depending on the magnitudes
12230 of the numbers involved.
12232 If you need to work with a particular fixed accuracy (say, dollars and
12233 cents with two digits after the decimal point), one solution is to work
12234 with integers and an ``implied'' decimal point. For example, $8.99
12235 divided by 6 would be entered @kbd{899 @key{RET} 6 /}, yielding 149.833
12236 (actually $1.49833 with our implied decimal point); pressing @kbd{R}
12237 would round this to 150 cents, i.e., $1.50.
12239 @xref{Floats}, for still more on floating-point precision and related
12242 @node Inverse and Hyperbolic, Calculation Modes, Precision, Mode Settings
12243 @section Inverse and Hyperbolic Flags
12247 @pindex calc-inverse
12248 There is no single-key equivalent to the @code{calc-arcsin} function.
12249 Instead, you must first press @kbd{I} (@code{calc-inverse}) to set
12250 the @dfn{Inverse Flag}, then press @kbd{S} (@code{calc-sin}).
12251 The @kbd{I} key actually toggles the Inverse Flag. When this flag
12252 is set, the word @samp{Inv} appears in the mode line.
12255 @pindex calc-hyperbolic
12256 Likewise, the @kbd{H} key (@code{calc-hyperbolic}) sets or clears the
12257 Hyperbolic Flag, which transforms @code{calc-sin} into @code{calc-sinh}.
12258 If both of these flags are set at once, the effect will be
12259 @code{calc-arcsinh}. (The Hyperbolic flag is also used by some
12260 non-trigonometric commands; for example @kbd{H L} computes a base-10,
12261 instead of base-@mathit{e}, logarithm.)
12263 Command names like @code{calc-arcsin} are provided for completeness, and
12264 may be executed with @kbd{x} or @kbd{M-x}. Their effect is simply to
12265 toggle the Inverse and/or Hyperbolic flags and then execute the
12266 corresponding base command (@code{calc-sin} in this case).
12269 @pindex calc-option
12270 The @kbd{O} key (@code{calc-option}) sets another flag, the
12271 @dfn{Option Flag}, which also can alter the subsequent Calc command in
12274 The Inverse, Hyperbolic and Option flags apply only to the next
12275 Calculator command, after which they are automatically cleared. (They
12276 are also cleared if the next keystroke is not a Calc command.) Digits
12277 you type after @kbd{I}, @kbd{H} or @kbd{O} (or @kbd{K}) are treated as
12278 prefix arguments for the next command, not as numeric entries. The
12279 same is true of @kbd{C-u}, but not of the minus sign (@kbd{K -} means
12280 to subtract and keep arguments).
12282 Another Calc prefix flag, @kbd{K} (keep-arguments), is discussed
12283 elsewhere. @xref{Keep Arguments}.
12285 @node Calculation Modes, Simplification Modes, Inverse and Hyperbolic, Mode Settings
12286 @section Calculation Modes
12289 The commands in this section are two-key sequences beginning with
12290 the @kbd{m} prefix. (That's the letter @kbd{m}, not the @key{META} key.)
12291 The @samp{m a} (@code{calc-algebraic-mode}) command is described elsewhere
12292 (@pxref{Algebraic Entry}).
12301 * Automatic Recomputation::
12302 * Working Message::
12305 @node Angular Modes, Polar Mode, Calculation Modes, Calculation Modes
12306 @subsection Angular Modes
12309 @cindex Angular mode
12310 The Calculator supports three notations for angles: radians, degrees,
12311 and degrees-minutes-seconds. When a number is presented to a function
12312 like @code{sin} that requires an angle, the current angular mode is
12313 used to interpret the number as either radians or degrees. If an HMS
12314 form is presented to @code{sin}, it is always interpreted as
12315 degrees-minutes-seconds.
12317 Functions that compute angles produce a number in radians, a number in
12318 degrees, or an HMS form depending on the current angular mode. If the
12319 result is a complex number and the current mode is HMS, the number is
12320 instead expressed in degrees. (Complex-number calculations would
12321 normally be done in Radians mode, though. Complex numbers are converted
12322 to degrees by calculating the complex result in radians and then
12323 multiplying by 180 over @cpi{}.)
12326 @pindex calc-radians-mode
12328 @pindex calc-degrees-mode
12330 @pindex calc-hms-mode
12331 The @kbd{m r} (@code{calc-radians-mode}), @kbd{m d} (@code{calc-degrees-mode}),
12332 and @kbd{m h} (@code{calc-hms-mode}) commands control the angular mode.
12333 The current angular mode is displayed on the Emacs mode line.
12334 The default angular mode is Degrees.
12336 @node Polar Mode, Fraction Mode, Angular Modes, Calculation Modes
12337 @subsection Polar Mode
12341 The Calculator normally ``prefers'' rectangular complex numbers in the
12342 sense that rectangular form is used when the proper form can not be
12343 decided from the input. This might happen by multiplying a rectangular
12344 number by a polar one, by taking the square root of a negative real
12345 number, or by entering @kbd{( 2 @key{SPC} 3 )}.
12348 @pindex calc-polar-mode
12349 The @kbd{m p} (@code{calc-polar-mode}) command toggles complex-number
12350 preference between rectangular and polar forms. In Polar mode, all
12351 of the above example situations would produce polar complex numbers.
12353 @node Fraction Mode, Infinite Mode, Polar Mode, Calculation Modes
12354 @subsection Fraction Mode
12357 @cindex Fraction mode
12358 @cindex Division of integers
12359 Division of two integers normally yields a floating-point number if the
12360 result cannot be expressed as an integer. In some cases you would
12361 rather get an exact fractional answer. One way to accomplish this is
12362 to use the @kbd{:} (@code{calc-fdiv}) [@code{fdiv}] command, which
12363 divides the two integers on the top of the stack to produce a fraction:
12364 @kbd{6 @key{RET} 4 :} produces @expr{3:2} even though
12365 @kbd{6 @key{RET} 4 /} produces @expr{1.5}.
12368 @pindex calc-frac-mode
12369 To set the Calculator to produce fractional results for normal integer
12370 divisions, use the @kbd{m f} (@code{calc-frac-mode}) command.
12371 For example, @expr{8/4} produces @expr{2} in either mode,
12372 but @expr{6/4} produces @expr{3:2} in Fraction mode, @expr{1.5} in
12375 At any time you can use @kbd{c f} (@code{calc-float}) to convert a
12376 fraction to a float, or @kbd{c F} (@code{calc-fraction}) to convert a
12377 float to a fraction. @xref{Conversions}.
12379 @node Infinite Mode, Symbolic Mode, Fraction Mode, Calculation Modes
12380 @subsection Infinite Mode
12383 @cindex Infinite mode
12384 The Calculator normally treats results like @expr{1 / 0} as errors;
12385 formulas like this are left in unsimplified form. But Calc can be
12386 put into a mode where such calculations instead produce ``infinite''
12390 @pindex calc-infinite-mode
12391 The @kbd{m i} (@code{calc-infinite-mode}) command turns this mode
12392 on and off. When the mode is off, infinities do not arise except
12393 in calculations that already had infinities as inputs. (One exception
12394 is that infinite open intervals like @samp{[0 .. inf)} can be
12395 generated; however, intervals closed at infinity (@samp{[0 .. inf]})
12396 will not be generated when Infinite mode is off.)
12398 With Infinite mode turned on, @samp{1 / 0} will generate @code{uinf},
12399 an undirected infinity. @xref{Infinities}, for a discussion of the
12400 difference between @code{inf} and @code{uinf}. Also, @expr{0 / 0}
12401 evaluates to @code{nan}, the ``indeterminate'' symbol. Various other
12402 functions can also return infinities in this mode; for example,
12403 @samp{ln(0) = -inf}, and @samp{gamma(-7) = uinf}. Once again,
12404 note that @samp{exp(inf) = inf} regardless of Infinite mode because
12405 this calculation has infinity as an input.
12407 @cindex Positive Infinite mode
12408 The @kbd{m i} command with a numeric prefix argument of zero,
12409 i.e., @kbd{C-u 0 m i}, turns on a Positive Infinite mode in
12410 which zero is treated as positive instead of being directionless.
12411 Thus, @samp{1 / 0 = inf} and @samp{-1 / 0 = -inf} in this mode.
12412 Note that zero never actually has a sign in Calc; there are no
12413 separate representations for @mathit{+0} and @mathit{-0}. Positive
12414 Infinite mode merely changes the interpretation given to the
12415 single symbol, @samp{0}. One consequence of this is that, while
12416 you might expect @samp{1 / -0 = -inf}, actually @samp{1 / -0}
12417 is equivalent to @samp{1 / 0}, which is equal to positive @code{inf}.
12419 @node Symbolic Mode, Matrix Mode, Infinite Mode, Calculation Modes
12420 @subsection Symbolic Mode
12423 @cindex Symbolic mode
12424 @cindex Inexact results
12425 Calculations are normally performed numerically wherever possible.
12426 For example, the @code{calc-sqrt} command, or @code{sqrt} function in an
12427 algebraic expression, produces a numeric answer if the argument is a
12428 number or a symbolic expression if the argument is an expression:
12429 @kbd{2 Q} pushes 1.4142 but @kbd{@key{'} x+1 @key{RET} Q} pushes @samp{sqrt(x+1)}.
12432 @pindex calc-symbolic-mode
12433 In @dfn{Symbolic mode}, controlled by the @kbd{m s} (@code{calc-symbolic-mode})
12434 command, functions which would produce inexact, irrational results are
12435 left in symbolic form. Thus @kbd{16 Q} pushes 4, but @kbd{2 Q} pushes
12439 @pindex calc-eval-num
12440 The shift-@kbd{N} (@code{calc-eval-num}) command evaluates numerically
12441 the expression at the top of the stack, by temporarily disabling
12442 @code{calc-symbolic-mode} and executing @kbd{=} (@code{calc-evaluate}).
12443 Given a numeric prefix argument, it also
12444 sets the floating-point precision to the specified value for the duration
12447 To evaluate a formula numerically without expanding the variables it
12448 contains, you can use the key sequence @kbd{m s a v m s} (this uses
12449 @code{calc-alg-evaluate}, which resimplifies but doesn't evaluate
12452 @node Matrix Mode, Automatic Recomputation, Symbolic Mode, Calculation Modes
12453 @subsection Matrix and Scalar Modes
12456 @cindex Matrix mode
12457 @cindex Scalar mode
12458 Calc sometimes makes assumptions during algebraic manipulation that
12459 are awkward or incorrect when vectors and matrices are involved.
12460 Calc has two modes, @dfn{Matrix mode} and @dfn{Scalar mode}, which
12461 modify its behavior around vectors in useful ways.
12464 @pindex calc-matrix-mode
12465 Press @kbd{m v} (@code{calc-matrix-mode}) once to enter Matrix mode.
12466 In this mode, all objects are assumed to be matrices unless provably
12467 otherwise. One major effect is that Calc will no longer consider
12468 multiplication to be commutative. (Recall that in matrix arithmetic,
12469 @samp{A*B} is not the same as @samp{B*A}.) This assumption affects
12470 rewrite rules and algebraic simplification. Another effect of this
12471 mode is that calculations that would normally produce constants like
12472 0 and 1 (e.g., @expr{a - a} and @expr{a / a}, respectively) will now
12473 produce function calls that represent ``generic'' zero or identity
12474 matrices: @samp{idn(0)}, @samp{idn(1)}. The @code{idn} function
12475 @samp{idn(@var{a},@var{n})} returns @var{a} times an @var{n}x@var{n}
12476 identity matrix; if @var{n} is omitted, it doesn't know what
12477 dimension to use and so the @code{idn} call remains in symbolic
12478 form. However, if this generic identity matrix is later combined
12479 with a matrix whose size is known, it will be converted into
12480 a true identity matrix of the appropriate size. On the other hand,
12481 if it is combined with a scalar (as in @samp{idn(1) + 2}), Calc
12482 will assume it really was a scalar after all and produce, e.g., 3.
12484 Press @kbd{m v} a second time to get Scalar mode. Here, objects are
12485 assumed @emph{not} to be vectors or matrices unless provably so.
12486 For example, normally adding a variable to a vector, as in
12487 @samp{[x, y, z] + a}, will leave the sum in symbolic form because
12488 as far as Calc knows, @samp{a} could represent either a number or
12489 another 3-vector. In Scalar mode, @samp{a} is assumed to be a
12490 non-vector, and the addition is evaluated to @samp{[x+a, y+a, z+a]}.
12492 Press @kbd{m v} a third time to return to the normal mode of operation.
12494 If you press @kbd{m v} with a numeric prefix argument @var{n}, you
12495 get a special ``dimensioned'' Matrix mode in which matrices of
12496 unknown size are assumed to be @var{n}x@var{n} square matrices.
12497 Then, the function call @samp{idn(1)} will expand into an actual
12498 matrix rather than representing a ``generic'' matrix. Simply typing
12499 @kbd{C-u m v} will get you a square Matrix mode, in which matrices of
12500 unknown size are assumed to be square matrices of unspecified size.
12502 @cindex Declaring scalar variables
12503 Of course these modes are approximations to the true state of
12504 affairs, which is probably that some quantities will be matrices
12505 and others will be scalars. One solution is to ``declare''
12506 certain variables or functions to be scalar-valued.
12507 @xref{Declarations}, to see how to make declarations in Calc.
12509 There is nothing stopping you from declaring a variable to be
12510 scalar and then storing a matrix in it; however, if you do, the
12511 results you get from Calc may not be valid. Suppose you let Calc
12512 get the result @samp{[x+a, y+a, z+a]} shown above, and then stored
12513 @samp{[1, 2, 3]} in @samp{a}. The result would not be the same as
12514 for @samp{[x, y, z] + [1, 2, 3]}, but that's because you have broken
12515 your earlier promise to Calc that @samp{a} would be scalar.
12517 Another way to mix scalars and matrices is to use selections
12518 (@pxref{Selecting Subformulas}). Use Matrix mode when operating on
12519 your formula normally; then, to apply Scalar mode to a certain part
12520 of the formula without affecting the rest just select that part,
12521 change into Scalar mode and press @kbd{=} to resimplify the part
12522 under this mode, then change back to Matrix mode before deselecting.
12524 @node Automatic Recomputation, Working Message, Matrix Mode, Calculation Modes
12525 @subsection Automatic Recomputation
12528 The @dfn{evaluates-to} operator, @samp{=>}, has the special
12529 property that any @samp{=>} formulas on the stack are recomputed
12530 whenever variable values or mode settings that might affect them
12531 are changed. @xref{Evaluates-To Operator}.
12534 @pindex calc-auto-recompute
12535 The @kbd{m C} (@code{calc-auto-recompute}) command turns this
12536 automatic recomputation on and off. If you turn it off, Calc will
12537 not update @samp{=>} operators on the stack (nor those in the
12538 attached Embedded mode buffer, if there is one). They will not
12539 be updated unless you explicitly do so by pressing @kbd{=} or until
12540 you press @kbd{m C} to turn recomputation back on. (While automatic
12541 recomputation is off, you can think of @kbd{m C m C} as a command
12542 to update all @samp{=>} operators while leaving recomputation off.)
12544 To update @samp{=>} operators in an Embedded buffer while
12545 automatic recomputation is off, use @w{@kbd{C-x * u}}.
12546 @xref{Embedded Mode}.
12548 @node Working Message, , Automatic Recomputation, Calculation Modes
12549 @subsection Working Messages
12552 @cindex Performance
12553 @cindex Working messages
12554 Since the Calculator is written entirely in Emacs Lisp, which is not
12555 designed for heavy numerical work, many operations are quite slow.
12556 The Calculator normally displays the message @samp{Working...} in the
12557 echo area during any command that may be slow. In addition, iterative
12558 operations such as square roots and trigonometric functions display the
12559 intermediate result at each step. Both of these types of messages can
12560 be disabled if you find them distracting.
12563 @pindex calc-working
12564 Type @kbd{m w} (@code{calc-working}) with a numeric prefix of 0 to
12565 disable all ``working'' messages. Use a numeric prefix of 1 to enable
12566 only the plain @samp{Working...} message. Use a numeric prefix of 2 to
12567 see intermediate results as well. With no numeric prefix this displays
12570 While it may seem that the ``working'' messages will slow Calc down
12571 considerably, experiments have shown that their impact is actually
12572 quite small. But if your terminal is slow you may find that it helps
12573 to turn the messages off.
12575 @node Simplification Modes, Declarations, Calculation Modes, Mode Settings
12576 @section Simplification Modes
12579 The current @dfn{simplification mode} controls how numbers and formulas
12580 are ``normalized'' when being taken from or pushed onto the stack.
12581 Some normalizations are unavoidable, such as rounding floating-point
12582 results to the current precision, and reducing fractions to simplest
12583 form. Others, such as simplifying a formula like @expr{a+a} (or @expr{2+3}),
12584 are done automatically but can be turned off when necessary.
12586 When you press a key like @kbd{+} when @expr{2} and @expr{3} are on the
12587 stack, Calc pops these numbers, normalizes them, creates the formula
12588 @expr{2+3}, normalizes it, and pushes the result. Of course the standard
12589 rules for normalizing @expr{2+3} will produce the result @expr{5}.
12591 Simplification mode commands consist of the lower-case @kbd{m} prefix key
12592 followed by a shifted letter.
12595 @pindex calc-no-simplify-mode
12596 The @kbd{m O} (@code{calc-no-simplify-mode}) command turns off all optional
12597 simplifications. These would leave a formula like @expr{2+3} alone. In
12598 fact, nothing except simple numbers are ever affected by normalization
12599 in this mode. Explicit simplification commands, such as @kbd{=} or
12600 @kbd{a s}, can still be given to simplify any formulas.
12601 @xref{Algebraic Definitions}, for a sample use of
12602 No-Simplification mode.
12606 @pindex calc-num-simplify-mode
12607 The @kbd{m N} (@code{calc-num-simplify-mode}) command turns off simplification
12608 of any formulas except those for which all arguments are constants. For
12609 example, @expr{1+2} is simplified to @expr{3}, and @expr{a+(2-2)} is
12610 simplified to @expr{a+0} but no further, since one argument of the sum
12611 is not a constant. Unfortunately, @expr{(a+2)-2} is @emph{not} simplified
12612 because the top-level @samp{-} operator's arguments are not both
12613 constant numbers (one of them is the formula @expr{a+2}).
12614 A constant is a number or other numeric object (such as a constant
12615 error form or modulo form), or a vector all of whose
12616 elements are constant.
12619 @pindex calc-basic-simplify-mode
12620 The @kbd{m I} (@code{calc-basic-simplify-mode}) command does some basic
12621 simplifications for all formulas. This includes many easy and
12622 fast algebraic simplifications such as @expr{a+0} to @expr{a}, and
12623 @expr{a + 2 a} to @expr{3 a}, as well as evaluating functions like
12624 @expr{@tfn{deriv}(x^2, x)} to @expr{2 x}.
12627 @pindex calc-bin-simplify-mode
12628 The @kbd{m B} (@code{calc-bin-simplify-mode}) mode applies the basic
12629 simplifications to a result and then, if the result is an integer,
12630 uses the @kbd{b c} (@code{calc-clip}) command to clip the integer according
12631 to the current binary word size. @xref{Binary Functions}. Real numbers
12632 are rounded to the nearest integer and then clipped; other kinds of
12633 results (after the basic simplifications) are left alone.
12636 @pindex calc-alg-simplify-mode
12637 The @kbd{m A} (@code{calc-alg-simplify-mode}) mode does standard
12638 algebraic simplifications. @xref{Algebraic Simplifications}.
12641 @pindex calc-ext-simplify-mode
12642 The @kbd{m E} (@code{calc-ext-simplify-mode}) mode does ``extended'', or
12643 ``unsafe'', algebraic simplification. @xref{Unsafe Simplifications}.
12646 @pindex calc-units-simplify-mode
12647 The @kbd{m U} (@code{calc-units-simplify-mode}) mode does units
12648 simplification. @xref{Simplification of Units}. These include the
12649 algebraic simplifications, plus variable names which
12650 are identifiable as unit names (like @samp{mm} for ``millimeters'')
12651 are simplified with their unit definitions in mind.
12653 A common technique is to set the simplification mode down to the lowest
12654 amount of simplification you will allow to be applied automatically, then
12655 use manual commands like @kbd{a s} and @kbd{c c} (@code{calc-clean}) to
12656 perform higher types of simplifications on demand.
12657 @node Declarations, Display Modes, Simplification Modes, Mode Settings
12658 @section Declarations
12661 A @dfn{declaration} is a statement you make that promises you will
12662 use a certain variable or function in a restricted way. This may
12663 give Calc the freedom to do things that it couldn't do if it had to
12664 take the fully general situation into account.
12667 * Declaration Basics::
12668 * Kinds of Declarations::
12669 * Functions for Declarations::
12672 @node Declaration Basics, Kinds of Declarations, Declarations, Declarations
12673 @subsection Declaration Basics
12677 @pindex calc-declare-variable
12678 The @kbd{s d} (@code{calc-declare-variable}) command is the easiest
12679 way to make a declaration for a variable. This command prompts for
12680 the variable name, then prompts for the declaration. The default
12681 at the declaration prompt is the previous declaration, if any.
12682 You can edit this declaration, or press @kbd{C-k} to erase it and
12683 type a new declaration. (Or, erase it and press @key{RET} to clear
12684 the declaration, effectively ``undeclaring'' the variable.)
12686 A declaration is in general a vector of @dfn{type symbols} and
12687 @dfn{range} values. If there is only one type symbol or range value,
12688 you can write it directly rather than enclosing it in a vector.
12689 For example, @kbd{s d foo @key{RET} real @key{RET}} declares @code{foo} to
12690 be a real number, and @kbd{s d bar @key{RET} [int, const, [1..6]] @key{RET}}
12691 declares @code{bar} to be a constant integer between 1 and 6.
12692 (Actually, you can omit the outermost brackets and Calc will
12693 provide them for you: @kbd{s d bar @key{RET} int, const, [1..6] @key{RET}}.)
12695 @cindex @code{Decls} variable
12697 Declarations in Calc are kept in a special variable called @code{Decls}.
12698 This variable encodes the set of all outstanding declarations in
12699 the form of a matrix. Each row has two elements: A variable or
12700 vector of variables declared by that row, and the declaration
12701 specifier as described above. You can use the @kbd{s D} command to
12702 edit this variable if you wish to see all the declarations at once.
12703 @xref{Operations on Variables}, for a description of this command
12704 and the @kbd{s p} command that allows you to save your declarations
12705 permanently if you wish.
12707 Items being declared can also be function calls. The arguments in
12708 the call are ignored; the effect is to say that this function returns
12709 values of the declared type for any valid arguments. The @kbd{s d}
12710 command declares only variables, so if you wish to make a function
12711 declaration you will have to edit the @code{Decls} matrix yourself.
12713 For example, the declaration matrix
12719 [ f(1,2,3), [0 .. inf) ] ]
12724 declares that @code{foo} represents a real number, @code{j}, @code{k}
12725 and @code{n} represent integers, and the function @code{f} always
12726 returns a real number in the interval shown.
12729 If there is a declaration for the variable @code{All}, then that
12730 declaration applies to all variables that are not otherwise declared.
12731 It does not apply to function names. For example, using the row
12732 @samp{[All, real]} says that all your variables are real unless they
12733 are explicitly declared without @code{real} in some other row.
12734 The @kbd{s d} command declares @code{All} if you give a blank
12735 response to the variable-name prompt.
12737 @node Kinds of Declarations, Functions for Declarations, Declaration Basics, Declarations
12738 @subsection Kinds of Declarations
12741 The type-specifier part of a declaration (that is, the second prompt
12742 in the @kbd{s d} command) can be a type symbol, an interval, or a
12743 vector consisting of zero or more type symbols followed by zero or
12744 more intervals or numbers that represent the set of possible values
12749 [ [ a, [1, 2, 3, 4, 5] ]
12751 [ c, [int, 1 .. 5] ] ]
12755 Here @code{a} is declared to contain one of the five integers shown;
12756 @code{b} is any number in the interval from 1 to 5 (any real number
12757 since we haven't specified), and @code{c} is any integer in that
12758 interval. Thus the declarations for @code{a} and @code{c} are
12759 nearly equivalent (see below).
12761 The type-specifier can be the empty vector @samp{[]} to say that
12762 nothing is known about a given variable's value. This is the same
12763 as not declaring the variable at all except that it overrides any
12764 @code{All} declaration which would otherwise apply.
12766 The initial value of @code{Decls} is the empty vector @samp{[]}.
12767 If @code{Decls} has no stored value or if the value stored in it
12768 is not valid, it is ignored and there are no declarations as far
12769 as Calc is concerned. (The @kbd{s d} command will replace such a
12770 malformed value with a fresh empty matrix, @samp{[]}, before recording
12771 the new declaration.) Unrecognized type symbols are ignored.
12773 The following type symbols describe what sorts of numbers will be
12774 stored in a variable:
12780 Numerical integers. (Integers or integer-valued floats.)
12782 Fractions. (Rational numbers which are not integers.)
12784 Rational numbers. (Either integers or fractions.)
12786 Floating-point numbers.
12788 Real numbers. (Integers, fractions, or floats. Actually,
12789 intervals and error forms with real components also count as
12792 Positive real numbers. (Strictly greater than zero.)
12794 Nonnegative real numbers. (Greater than or equal to zero.)
12796 Numbers. (Real or complex.)
12799 Calc uses this information to determine when certain simplifications
12800 of formulas are safe. For example, @samp{(x^y)^z} cannot be
12801 simplified to @samp{x^(y z)} in general; for example,
12802 @samp{((-3)^2)^1:2} is 3, but @samp{(-3)^(2*1:2) = (-3)^1} is @mathit{-3}.
12803 However, this simplification @emph{is} safe if @code{z} is known
12804 to be an integer, or if @code{x} is known to be a nonnegative
12805 real number. If you have given declarations that allow Calc to
12806 deduce either of these facts, Calc will perform this simplification
12809 Calc can apply a certain amount of logic when using declarations.
12810 For example, @samp{(x^y)^(2n+1)} will be simplified if @code{n}
12811 has been declared @code{int}; Calc knows that an integer times an
12812 integer, plus an integer, must always be an integer. (In fact,
12813 Calc would simplify @samp{(-x)^(2n+1)} to @samp{-(x^(2n+1))} since
12814 it is able to determine that @samp{2n+1} must be an odd integer.)
12816 Similarly, @samp{(abs(x)^y)^z} will be simplified to @samp{abs(x)^(y z)}
12817 because Calc knows that the @code{abs} function always returns a
12818 nonnegative real. If you had a @code{myabs} function that also had
12819 this property, you could get Calc to recognize it by adding the row
12820 @samp{[myabs(), nonneg]} to the @code{Decls} matrix.
12822 One instance of this simplification is @samp{sqrt(x^2)} (since the
12823 @code{sqrt} function is effectively a one-half power). Normally
12824 Calc leaves this formula alone. After the command
12825 @kbd{s d x @key{RET} real @key{RET}}, however, it can simplify the formula to
12826 @samp{abs(x)}. And after @kbd{s d x @key{RET} nonneg @key{RET}}, Calc can
12827 simplify this formula all the way to @samp{x}.
12829 If there are any intervals or real numbers in the type specifier,
12830 they comprise the set of possible values that the variable or
12831 function being declared can have. In particular, the type symbol
12832 @code{real} is effectively the same as the range @samp{[-inf .. inf]}
12833 (note that infinity is included in the range of possible values);
12834 @code{pos} is the same as @samp{(0 .. inf]}, and @code{nonneg} is
12835 the same as @samp{[0 .. inf]}. Saying @samp{[real, [-5 .. 5]]} is
12836 redundant because the fact that the variable is real can be
12837 deduced just from the interval, but @samp{[int, [-5 .. 5]]} and
12838 @samp{[rat, [-5 .. 5]]} are useful combinations.
12840 Note that the vector of intervals or numbers is in the same format
12841 used by Calc's set-manipulation commands. @xref{Set Operations}.
12843 The type specifier @samp{[1, 2, 3]} is equivalent to
12844 @samp{[numint, 1, 2, 3]}, @emph{not} to @samp{[int, 1, 2, 3]}.
12845 In other words, the range of possible values means only that
12846 the variable's value must be numerically equal to a number in
12847 that range, but not that it must be equal in type as well.
12848 Calc's set operations act the same way; @samp{in(2, [1., 2., 3.])}
12849 and @samp{in(1.5, [1:2, 3:2, 5:2])} both report ``true.''
12851 If you use a conflicting combination of type specifiers, the
12852 results are unpredictable. An example is @samp{[pos, [0 .. 5]]},
12853 where the interval does not lie in the range described by the
12856 ``Real'' declarations mostly affect simplifications involving powers
12857 like the one described above. Another case where they are used
12858 is in the @kbd{a P} command which returns a list of all roots of a
12859 polynomial; if the variable has been declared real, only the real
12860 roots (if any) will be included in the list.
12862 ``Integer'' declarations are used for simplifications which are valid
12863 only when certain values are integers (such as @samp{(x^y)^z}
12866 Calc's algebraic simplifications also make use of declarations when
12867 simplifying equations and inequalities. They will cancel @code{x}
12868 from both sides of @samp{a x = b x} only if it is sure @code{x}
12869 is non-zero, say, because it has a @code{pos} declaration.
12870 To declare specifically that @code{x} is real and non-zero,
12871 use @samp{[[-inf .. 0), (0 .. inf]]}. (There is no way in the
12872 current notation to say that @code{x} is nonzero but not necessarily
12873 real.) The @kbd{a e} command does ``unsafe'' simplifications,
12874 including canceling @samp{x} from the equation when @samp{x} is
12875 not known to be nonzero.
12877 Another set of type symbols distinguish between scalars and vectors.
12881 The value is not a vector.
12883 The value is a vector.
12885 The value is a matrix (a rectangular vector of vectors).
12887 The value is a square matrix.
12890 These type symbols can be combined with the other type symbols
12891 described above; @samp{[int, matrix]} describes an object which
12892 is a matrix of integers.
12894 Scalar/vector declarations are used to determine whether certain
12895 algebraic operations are safe. For example, @samp{[a, b, c] + x}
12896 is normally not simplified to @samp{[a + x, b + x, c + x]}, but
12897 it will be if @code{x} has been declared @code{scalar}. On the
12898 other hand, multiplication is usually assumed to be commutative,
12899 but the terms in @samp{x y} will never be exchanged if both @code{x}
12900 and @code{y} are known to be vectors or matrices. (Calc currently
12901 never distinguishes between @code{vector} and @code{matrix}
12904 @xref{Matrix Mode}, for a discussion of Matrix mode and
12905 Scalar mode, which are similar to declaring @samp{[All, matrix]}
12906 or @samp{[All, scalar]} but much more convenient.
12908 One more type symbol that is recognized is used with the @kbd{H a d}
12909 command for taking total derivatives of a formula. @xref{Calculus}.
12913 The value is a constant with respect to other variables.
12916 Calc does not check the declarations for a variable when you store
12917 a value in it. However, storing @mathit{-3.5} in a variable that has
12918 been declared @code{pos}, @code{int}, or @code{matrix} may have
12919 unexpected effects; Calc may evaluate @samp{sqrt(x^2)} to @expr{3.5}
12920 if it substitutes the value first, or to @expr{-3.5} if @code{x}
12921 was declared @code{pos} and the formula @samp{sqrt(x^2)} is
12922 simplified to @samp{x} before the value is substituted. Before
12923 using a variable for a new purpose, it is best to use @kbd{s d}
12924 or @kbd{s D} to check to make sure you don't still have an old
12925 declaration for the variable that will conflict with its new meaning.
12927 @node Functions for Declarations, , Kinds of Declarations, Declarations
12928 @subsection Functions for Declarations
12931 Calc has a set of functions for accessing the current declarations
12932 in a convenient manner. These functions return 1 if the argument
12933 can be shown to have the specified property, or 0 if the argument
12934 can be shown @emph{not} to have that property; otherwise they are
12935 left unevaluated. These functions are suitable for use with rewrite
12936 rules (@pxref{Conditional Rewrite Rules}) or programming constructs
12937 (@pxref{Conditionals in Macros}). They can be entered only using
12938 algebraic notation. @xref{Logical Operations}, for functions
12939 that perform other tests not related to declarations.
12941 For example, @samp{dint(17)} returns 1 because 17 is an integer, as
12942 do @samp{dint(n)} and @samp{dint(2 n - 3)} if @code{n} has been declared
12943 @code{int}, but @samp{dint(2.5)} and @samp{dint(n + 0.5)} return 0.
12944 Calc consults knowledge of its own built-in functions as well as your
12945 own declarations: @samp{dint(floor(x))} returns 1.
12959 The @code{dint} function checks if its argument is an integer.
12960 The @code{dnatnum} function checks if its argument is a natural
12961 number, i.e., a nonnegative integer. The @code{dnumint} function
12962 checks if its argument is numerically an integer, i.e., either an
12963 integer or an integer-valued float. Note that these and the other
12964 data type functions also accept vectors or matrices composed of
12965 suitable elements, and that real infinities @samp{inf} and @samp{-inf}
12966 are considered to be integers for the purposes of these functions.
12972 The @code{drat} function checks if its argument is rational, i.e.,
12973 an integer or fraction. Infinities count as rational, but intervals
12974 and error forms do not.
12980 The @code{dreal} function checks if its argument is real. This
12981 includes integers, fractions, floats, real error forms, and intervals.
12987 The @code{dimag} function checks if its argument is imaginary,
12988 i.e., is mathematically equal to a real number times @expr{i}.
13002 The @code{dpos} function checks for positive (but nonzero) reals.
13003 The @code{dneg} function checks for negative reals. The @code{dnonneg}
13004 function checks for nonnegative reals, i.e., reals greater than or
13005 equal to zero. Note that Calc's algebraic simplifications, which are
13006 effectively applied to all conditions in rewrite rules, can simplify
13007 an expression like @expr{x > 0} to 1 or 0 using @code{dpos}.
13008 So the actual functions @code{dpos}, @code{dneg}, and @code{dnonneg}
13009 are rarely necessary.
13015 The @code{dnonzero} function checks that its argument is nonzero.
13016 This includes all nonzero real or complex numbers, all intervals that
13017 do not include zero, all nonzero modulo forms, vectors all of whose
13018 elements are nonzero, and variables or formulas whose values can be
13019 deduced to be nonzero. It does not include error forms, since they
13020 represent values which could be anything including zero. (This is
13021 also the set of objects considered ``true'' in conditional contexts.)
13031 The @code{deven} function returns 1 if its argument is known to be
13032 an even integer (or integer-valued float); it returns 0 if its argument
13033 is known not to be even (because it is known to be odd or a non-integer).
13034 Calc's algebraic simplifications use this to simplify a test of the form
13035 @samp{x % 2 = 0}. There is also an analogous @code{dodd} function.
13041 The @code{drange} function returns a set (an interval or a vector
13042 of intervals and/or numbers; @pxref{Set Operations}) that describes
13043 the set of possible values of its argument. If the argument is
13044 a variable or a function with a declaration, the range is copied
13045 from the declaration. Otherwise, the possible signs of the
13046 expression are determined using a method similar to @code{dpos},
13047 etc., and a suitable set like @samp{[0 .. inf]} is returned. If
13048 the expression is not provably real, the @code{drange} function
13049 remains unevaluated.
13055 The @code{dscalar} function returns 1 if its argument is provably
13056 scalar, or 0 if its argument is provably non-scalar. It is left
13057 unevaluated if this cannot be determined. (If Matrix mode or Scalar
13058 mode is in effect, this function returns 1 or 0, respectively,
13059 if it has no other information.) When Calc interprets a condition
13060 (say, in a rewrite rule) it considers an unevaluated formula to be
13061 ``false.'' Thus, @samp{dscalar(a)} is ``true'' only if @code{a} is
13062 provably scalar, and @samp{!dscalar(a)} is ``true'' only if @code{a}
13063 is provably non-scalar; both are ``false'' if there is insufficient
13064 information to tell.
13066 @node Display Modes, Language Modes, Declarations, Mode Settings
13067 @section Display Modes
13070 The commands in this section are two-key sequences beginning with the
13071 @kbd{d} prefix. The @kbd{d l} (@code{calc-line-numbering}) and @kbd{d b}
13072 (@code{calc-line-breaking}) commands are described elsewhere;
13073 @pxref{Stack Basics} and @pxref{Normal Language Modes}, respectively.
13074 Display formats for vectors and matrices are also covered elsewhere;
13075 @pxref{Vector and Matrix Formats}.
13077 One thing all display modes have in common is their treatment of the
13078 @kbd{H} prefix. This prefix causes any mode command that would normally
13079 refresh the stack to leave the stack display alone. The word ``Dirty''
13080 will appear in the mode line when Calc thinks the stack display may not
13081 reflect the latest mode settings.
13083 @kindex d @key{RET}
13084 @pindex calc-refresh-top
13085 The @kbd{d @key{RET}} (@code{calc-refresh-top}) command reformats the
13086 top stack entry according to all the current modes. Positive prefix
13087 arguments reformat the top @var{n} entries; negative prefix arguments
13088 reformat the specified entry, and a prefix of zero is equivalent to
13089 @kbd{d @key{SPC}} (@code{calc-refresh}), which reformats the entire stack.
13090 For example, @kbd{H d s M-2 d @key{RET}} changes to scientific notation
13091 but reformats only the top two stack entries in the new mode.
13093 The @kbd{I} prefix has another effect on the display modes. The mode
13094 is set only temporarily; the top stack entry is reformatted according
13095 to that mode, then the original mode setting is restored. In other
13096 words, @kbd{I d s} is equivalent to @kbd{H d s d @key{RET} H d (@var{old mode})}.
13100 * Grouping Digits::
13102 * Complex Formats::
13103 * Fraction Formats::
13106 * Truncating the Stack::
13111 @node Radix Modes, Grouping Digits, Display Modes, Display Modes
13112 @subsection Radix Modes
13115 @cindex Radix display
13116 @cindex Non-decimal numbers
13117 @cindex Decimal and non-decimal numbers
13118 Calc normally displays numbers in decimal (@dfn{base-10} or @dfn{radix-10})
13119 notation. Calc can actually display in any radix from two (binary) to 36.
13120 When the radix is above 10, the letters @code{A} to @code{Z} are used as
13121 digits. When entering such a number, letter keys are interpreted as
13122 potential digits rather than terminating numeric entry mode.
13128 @cindex Hexadecimal integers
13129 @cindex Octal integers
13130 The key sequences @kbd{d 2}, @kbd{d 8}, @kbd{d 6}, and @kbd{d 0} select
13131 binary, octal, hexadecimal, and decimal as the current display radix,
13132 respectively. Numbers can always be entered in any radix, though the
13133 current radix is used as a default if you press @kbd{#} without any initial
13134 digits. A number entered without a @kbd{#} is @emph{always} interpreted
13139 To set the radix generally, use @kbd{d r} (@code{calc-radix}) and enter
13140 an integer from 2 to 36. You can specify the radix as a numeric prefix
13141 argument; otherwise you will be prompted for it.
13144 @pindex calc-leading-zeros
13145 @cindex Leading zeros
13146 Integers normally are displayed with however many digits are necessary to
13147 represent the integer and no more. The @kbd{d z} (@code{calc-leading-zeros})
13148 command causes integers to be padded out with leading zeros according to the
13149 current binary word size. (@xref{Binary Functions}, for a discussion of
13150 word size.) If the absolute value of the word size is @expr{w}, all integers
13151 are displayed with at least enough digits to represent
13152 @texline @math{2^w-1}
13153 @infoline @expr{(2^w)-1}
13154 in the current radix. (Larger integers will still be displayed in their
13157 @cindex Two's complements
13158 Calc can display @expr{w}-bit integers using two's complement
13159 notation, although this is most useful with the binary, octal and
13160 hexadecimal display modes. This option is selected by using the
13161 @kbd{O} option prefix before setting the display radix, and a negative word
13162 size might be appropriate (@pxref{Binary Functions}). In two's
13163 complement notation, the integers in the (nearly) symmetric interval
13165 @texline @math{-2^{w-1}}
13166 @infoline @expr{-2^(w-1)}
13168 @texline @math{2^{w-1}-1}
13169 @infoline @expr{2^(w-1)-1}
13170 are represented by the integers from @expr{0} to @expr{2^w-1}:
13171 the integers from @expr{0} to
13172 @texline @math{2^{w-1}-1}
13173 @infoline @expr{2^(w-1)-1}
13174 are represented by themselves and the integers from
13175 @texline @math{-2^{w-1}}
13176 @infoline @expr{-2^(w-1)}
13177 to @expr{-1} are represented by the integers from
13178 @texline @math{2^{w-1}}
13179 @infoline @expr{2^(w-1)}
13180 to @expr{2^w-1} (the integer @expr{k} is represented by @expr{k+2^w}).
13181 Calc will display a two's complement integer by the radix (either
13182 @expr{2}, @expr{8} or @expr{16}), two @kbd{#} symbols, and then its
13183 representation (including any leading zeros necessary to include all
13184 @expr{w} bits). In a two's complement display mode, numbers that
13185 are not displayed in two's complement notation (i.e., that aren't
13187 @texline @math{-2^{w-1}}
13188 @infoline @expr{-2^(w-1)}
13191 @texline @math{2^{w-1}-1})
13192 @infoline @expr{2^(w-1)-1})
13193 will be represented using Calc's usual notation (in the appropriate
13196 @node Grouping Digits, Float Formats, Radix Modes, Display Modes
13197 @subsection Grouping Digits
13201 @pindex calc-group-digits
13202 @cindex Grouping digits
13203 @cindex Digit grouping
13204 Long numbers can be hard to read if they have too many digits. For
13205 example, the factorial of 30 is 33 digits long! Press @kbd{d g}
13206 (@code{calc-group-digits}) to enable @dfn{Grouping} mode, in which digits
13207 are displayed in clumps of 3 or 4 (depending on the current radix)
13208 separated by commas.
13210 The @kbd{d g} command toggles grouping on and off.
13211 With a numeric prefix of 0, this command displays the current state of
13212 the grouping flag; with an argument of minus one it disables grouping;
13213 with a positive argument @expr{N} it enables grouping on every @expr{N}
13214 digits. For floating-point numbers, grouping normally occurs only
13215 before the decimal point. A negative prefix argument @expr{-N} enables
13216 grouping every @expr{N} digits both before and after the decimal point.
13219 @pindex calc-group-char
13220 The @kbd{d ,} (@code{calc-group-char}) command allows you to choose any
13221 character as the grouping separator. The default is the comma character.
13222 If you find it difficult to read vectors of large integers grouped with
13223 commas, you may wish to use spaces or some other character instead.
13224 This command takes the next character you type, whatever it is, and
13225 uses it as the digit separator. As a special case, @kbd{d , \} selects
13226 @samp{\,} (@TeX{}'s thin-space symbol) as the digit separator.
13228 Please note that grouped numbers will not generally be parsed correctly
13229 if re-read in textual form, say by the use of @kbd{C-x * y} and @kbd{C-x * g}.
13230 (@xref{Kill and Yank}, for details on these commands.) One exception is
13231 the @samp{\,} separator, which doesn't interfere with parsing because it
13232 is ignored by @TeX{} language mode.
13234 @node Float Formats, Complex Formats, Grouping Digits, Display Modes
13235 @subsection Float Formats
13238 Floating-point quantities are normally displayed in standard decimal
13239 form, with scientific notation used if the exponent is especially high
13240 or low. All significant digits are normally displayed. The commands
13241 in this section allow you to choose among several alternative display
13242 formats for floats.
13245 @pindex calc-normal-notation
13246 The @kbd{d n} (@code{calc-normal-notation}) command selects the normal
13247 display format. All significant figures in a number are displayed.
13248 With a positive numeric prefix, numbers are rounded if necessary to
13249 that number of significant digits. With a negative numerix prefix,
13250 the specified number of significant digits less than the current
13251 precision is used. (Thus @kbd{C-u -2 d n} displays 10 digits if the
13252 current precision is 12.)
13255 @pindex calc-fix-notation
13256 The @kbd{d f} (@code{calc-fix-notation}) command selects fixed-point
13257 notation. The numeric argument is the number of digits after the
13258 decimal point, zero or more. This format will relax into scientific
13259 notation if a nonzero number would otherwise have been rounded all the
13260 way to zero. Specifying a negative number of digits is the same as
13261 for a positive number, except that small nonzero numbers will be rounded
13262 to zero rather than switching to scientific notation.
13265 @pindex calc-sci-notation
13266 @cindex Scientific notation, display of
13267 The @kbd{d s} (@code{calc-sci-notation}) command selects scientific
13268 notation. A positive argument sets the number of significant figures
13269 displayed, of which one will be before and the rest after the decimal
13270 point. A negative argument works the same as for @kbd{d n} format.
13271 The default is to display all significant digits.
13274 @pindex calc-eng-notation
13275 @cindex Engineering notation, display of
13276 The @kbd{d e} (@code{calc-eng-notation}) command selects engineering
13277 notation. This is similar to scientific notation except that the
13278 exponent is rounded down to a multiple of three, with from one to three
13279 digits before the decimal point. An optional numeric prefix sets the
13280 number of significant digits to display, as for @kbd{d s}.
13282 It is important to distinguish between the current @emph{precision} and
13283 the current @emph{display format}. After the commands @kbd{C-u 10 p}
13284 and @kbd{C-u 6 d n} the Calculator computes all results to ten
13285 significant figures but displays only six. (In fact, intermediate
13286 calculations are often carried to one or two more significant figures,
13287 but values placed on the stack will be rounded down to ten figures.)
13288 Numbers are never actually rounded to the display precision for storage,
13289 except by commands like @kbd{C-k} and @kbd{C-x * y} which operate on the
13290 actual displayed text in the Calculator buffer.
13293 @pindex calc-point-char
13294 The @kbd{d .} (@code{calc-point-char}) command selects the character used
13295 as a decimal point. Normally this is a period; users in some countries
13296 may wish to change this to a comma. Note that this is only a display
13297 style; on entry, periods must always be used to denote floating-point
13298 numbers, and commas to separate elements in a list.
13300 @node Complex Formats, Fraction Formats, Float Formats, Display Modes
13301 @subsection Complex Formats
13305 @pindex calc-complex-notation
13306 There are three supported notations for complex numbers in rectangular
13307 form. The default is as a pair of real numbers enclosed in parentheses
13308 and separated by a comma: @samp{(a,b)}. The @kbd{d c}
13309 (@code{calc-complex-notation}) command selects this style.
13312 @pindex calc-i-notation
13314 @pindex calc-j-notation
13315 The other notations are @kbd{d i} (@code{calc-i-notation}), in which
13316 numbers are displayed in @samp{a+bi} form, and @kbd{d j}
13317 (@code{calc-j-notation}) which displays the form @samp{a+bj} preferred
13318 in some disciplines.
13320 @cindex @code{i} variable
13322 Complex numbers are normally entered in @samp{(a,b)} format.
13323 If you enter @samp{2+3i} as an algebraic formula, it will be stored as
13324 the formula @samp{2 + 3 * i}. However, if you use @kbd{=} to evaluate
13325 this formula and you have not changed the variable @samp{i}, the @samp{i}
13326 will be interpreted as @samp{(0,1)} and the formula will be simplified
13327 to @samp{(2,3)}. Other commands (like @code{calc-sin}) will @emph{not}
13328 interpret the formula @samp{2 + 3 * i} as a complex number.
13329 @xref{Variables}, under ``special constants.''
13331 @node Fraction Formats, HMS Formats, Complex Formats, Display Modes
13332 @subsection Fraction Formats
13336 @pindex calc-over-notation
13337 Display of fractional numbers is controlled by the @kbd{d o}
13338 (@code{calc-over-notation}) command. By default, a number like
13339 eight thirds is displayed in the form @samp{8:3}. The @kbd{d o} command
13340 prompts for a one- or two-character format. If you give one character,
13341 that character is used as the fraction separator. Common separators are
13342 @samp{:} and @samp{/}. (During input of numbers, the @kbd{:} key must be
13343 used regardless of the display format; in particular, the @kbd{/} is used
13344 for RPN-style division, @emph{not} for entering fractions.)
13346 If you give two characters, fractions use ``integer-plus-fractional-part''
13347 notation. For example, the format @samp{+/} would display eight thirds
13348 as @samp{2+2/3}. If two colons are present in a number being entered,
13349 the number is interpreted in this form (so that the entries @kbd{2:2:3}
13350 and @kbd{8:3} are equivalent).
13352 It is also possible to follow the one- or two-character format with
13353 a number. For example: @samp{:10} or @samp{+/3}. In this case,
13354 Calc adjusts all fractions that are displayed to have the specified
13355 denominator, if possible. Otherwise it adjusts the denominator to
13356 be a multiple of the specified value. For example, in @samp{:6} mode
13357 the fraction @expr{1:6} will be unaffected, but @expr{2:3} will be
13358 displayed as @expr{4:6}, @expr{1:2} will be displayed as @expr{3:6},
13359 and @expr{1:8} will be displayed as @expr{3:24}. Integers are also
13360 affected by this mode: 3 is displayed as @expr{18:6}. Note that the
13361 format @samp{:1} writes fractions the same as @samp{:}, but it writes
13362 integers as @expr{n:1}.
13364 The fraction format does not affect the way fractions or integers are
13365 stored, only the way they appear on the screen. The fraction format
13366 never affects floats.
13368 @node HMS Formats, Date Formats, Fraction Formats, Display Modes
13369 @subsection HMS Formats
13373 @pindex calc-hms-notation
13374 The @kbd{d h} (@code{calc-hms-notation}) command controls the display of
13375 HMS (hours-minutes-seconds) forms. It prompts for a string which
13376 consists basically of an ``hours'' marker, optional punctuation, a
13377 ``minutes'' marker, more optional punctuation, and a ``seconds'' marker.
13378 Punctuation is zero or more spaces, commas, or semicolons. The hours
13379 marker is one or more non-punctuation characters. The minutes and
13380 seconds markers must be single non-punctuation characters.
13382 The default HMS format is @samp{@@ ' "}, producing HMS values of the form
13383 @samp{23@@ 30' 15.75"}. The format @samp{deg, ms} would display this same
13384 value as @samp{23deg, 30m15.75s}. During numeric entry, the @kbd{h} or @kbd{o}
13385 keys are recognized as synonyms for @kbd{@@} regardless of display format.
13386 The @kbd{m} and @kbd{s} keys are recognized as synonyms for @kbd{'} and
13387 @kbd{"}, respectively, but only if an @kbd{@@} (or @kbd{h} or @kbd{o}) has
13388 already been typed; otherwise, they have their usual meanings
13389 (@kbd{m-} prefix and @kbd{s-} prefix). Thus, @kbd{5 "}, @kbd{0 @@ 5 "}, and
13390 @kbd{0 h 5 s} are some of the ways to enter the quantity ``five seconds.''
13391 The @kbd{'} key is recognized as ``minutes'' only if @kbd{@@} (or @kbd{h} or
13392 @kbd{o}) has already been pressed; otherwise it means to switch to algebraic
13395 @node Date Formats, Truncating the Stack, HMS Formats, Display Modes
13396 @subsection Date Formats
13400 @pindex calc-date-notation
13401 The @kbd{d d} (@code{calc-date-notation}) command controls the display
13402 of date forms (@pxref{Date Forms}). It prompts for a string which
13403 contains letters that represent the various parts of a date and time.
13404 To show which parts should be omitted when the form represents a pure
13405 date with no time, parts of the string can be enclosed in @samp{< >}
13406 marks. If you don't include @samp{< >} markers in the format, Calc
13407 guesses at which parts, if any, should be omitted when formatting
13410 The default format is: @samp{<H:mm:SSpp >Www Mmm D, YYYY}.
13411 An example string in this format is @samp{3:32pm Wed Jan 9, 1991}.
13412 If you enter a blank format string, this default format is
13415 Calc uses @samp{< >} notation for nameless functions as well as for
13416 dates. @xref{Specifying Operators}. To avoid confusion with nameless
13417 functions, your date formats should avoid using the @samp{#} character.
13421 * Date Formatting Codes::
13422 * Free-Form Dates::
13423 * Standard Date Formats::
13426 @node ISO 8601, Date Formatting Codes, Date Formats, Date Formats
13427 @subsubsection ISO 8601
13431 The same date can be written down in different formats and Calc tries
13432 to allow you to choose your preferred format. Some common formats are
13433 ambiguous, however; for example, 10/11/2012 means October 11,
13434 2012 in the United States but it means November 10, 2012 in
13435 Europe. To help avoid such ambiguities, the International Organization
13436 for Standardization (ISO) provides the ISO 8601 standard, which
13437 provides three different but easily distinguishable and unambiguous
13438 ways to represent a date.
13440 The ISO 8601 calendar date representation is
13443 @var{YYYY}-@var{MM}-@var{DD}
13447 where @var{YYYY} is the four digit year, @var{MM} is the two-digit month
13448 number (01 for January to 12 for December), and @var{DD} is the
13449 two-digit day of the month (01 to 31). (Note that @var{YYYY} does not
13450 correspond to Calc's date formatting code, which will be introduced
13451 later.) The year, which should be padded with zeros to ensure it has at
13452 least four digits, is the Gregorian year, except that the year before
13453 0001 (1 AD) is the year 0000 (1 BC). The date October 11, 2012 is
13454 written 2012-10-11 in this representation and November 10, 2012 is
13455 written 2012-11-10.
13457 The ISO 8601 ordinal date representation is
13460 @var{YYYY}-@var{DDD}
13464 where @var{YYYY} is the year, as above, and @var{DDD} is the day of the year.
13465 The date December 31, 2011 is written 2011-365 in this representation
13466 and January 1, 2012 is written 2012-001.
13468 The ISO 8601 week date representation is
13471 @var{YYYY}-W@var{ww}-@var{D}
13475 where @var{YYYY} is the ISO week-numbering year, @var{ww} is the two
13476 digit week number (preceded by a literal ``W''), and @var{D} is the day
13477 of the week (1 for Monday through 7 for Sunday). The ISO week-numbering
13478 year is based on the Gregorian year but can differ slightly. The first
13479 week of an ISO week-numbering year is the week with the Gregorian year's
13480 first Thursday in it (equivalently, the week containing January 4);
13481 any day of that week (Monday through Sunday) is part of the same ISO
13482 week-numbering year, any day from the previous week is part of the
13483 previous year. For example, January 4, 2013 is on a Friday, and so
13484 the first week for the ISO week-numbering year 2013 starts on
13485 Monday, December 31, 2012. The day December 31, 2012 is then part of the
13486 Gregorian year 2012 but ISO week-numbering year 2013. In the week
13487 date representation, this week goes from 2013-W01-1 (December 31,
13488 2012) to 2013-W01-7 (January 6, 2013).
13490 All three ISO 8601 representations arrange the numbers from most
13491 significant to least significant; as well as being unambiguous
13492 representations, they are easy to sort since chronological order in
13493 this formats corresponds to lexicographical order. The hyphens are
13496 The ISO 8601 standard uses a 24 hour clock; a particular time is
13497 represented by @var{hh}:@var{mm}:@var{ss} where @var{hh} is the
13498 two-digit hour (from 00 to 24), @var{mm} is the two-digit minute (from
13499 00 to 59) and @var{ss} is the two-digit second. The seconds or minutes
13500 and seconds can be omitted, and decimals can be added. If a date with a
13501 time is represented, they should be separated by a literal ``T'', so noon
13502 on December 13, 2012 can be represented as 2012-12-13T12:00.
13504 @node Date Formatting Codes, Free-Form Dates, ISO 8601, Date Formats
13505 @subsubsection Date Formatting Codes
13508 When displaying a date, the current date format is used. All
13509 characters except for letters and @samp{<} and @samp{>} are
13510 copied literally when dates are formatted. The portion between
13511 @samp{< >} markers is omitted for pure dates, or included for
13512 date/time forms. Letters are interpreted according to the table
13515 When dates are read in during algebraic entry, Calc first tries to
13516 match the input string to the current format either with or without
13517 the time part. The punctuation characters (including spaces) must
13518 match exactly; letter fields must correspond to suitable text in
13519 the input. If this doesn't work, Calc checks if the input is a
13520 simple number; if so, the number is interpreted as a number of days
13521 since Dec 31, 1 BC@. Otherwise, Calc tries a much more relaxed and
13522 flexible algorithm which is described in the next section.
13524 Weekday names are ignored during reading.
13526 Two-digit year numbers are interpreted as lying in the range
13527 from 1941 to 2039. Years outside that range are always
13528 entered and displayed in full. Year numbers with a leading
13529 @samp{+} sign are always interpreted exactly, allowing the
13530 entry and display of the years 1 through 99 AD.
13532 Here is a complete list of the formatting codes for dates:
13536 Year: ``91'' for 1991, ``7'' for 2007, ``+23'' for 23 AD.
13538 Year: ``91'' for 1991, ``07'' for 2007, ``+23'' for 23 AD.
13540 Year: ``91'' for 1991, `` 7'' for 2007, ``+23'' for 23 AD.
13542 Year: ``1991'' for 1991, ``23'' for 23 AD.
13544 Year: ``1991'' for 1991, ``+23'' for 23 AD.
13546 Year: ``1991'' for 1991, ``0023'' for 23 AD, ``0000'' for 1 BC.
13548 Year: ISO 8601 week-numbering year.
13550 Year: ``ad'' or blank.
13552 Year: ``AD'' or blank.
13554 Year: ``ad '' or blank. (Note trailing space.)
13556 Year: ``AD '' or blank.
13558 Year: ``a.d.@:'' or blank.
13560 Year: ``A.D.'' or blank.
13562 Year: ``bc'' or blank.
13564 Year: ``BC'' or blank.
13566 Year: `` bc'' or blank. (Note leading space.)
13568 Year: `` BC'' or blank.
13570 Year: ``b.c.@:'' or blank.
13572 Year: ``B.C.'' or blank.
13574 Month: ``8'' for August.
13576 Month: ``08'' for August.
13578 Month: `` 8'' for August.
13580 Month: ``AUG'' for August.
13582 Month: ``Aug'' for August.
13584 Month: ``aug'' for August.
13586 Month: ``AUGUST'' for August.
13588 Month: ``August'' for August.
13590 Day: ``7'' for 7th day of month.
13592 Day: ``07'' for 7th day of month.
13594 Day: `` 7'' for 7th day of month.
13596 Weekday: ``0'' for Sunday, ``6'' for Saturday.
13598 Weekday: ``1'' for Monday, ``7'' for Sunday.
13600 Weekday: ``SUN'' for Sunday.
13602 Weekday: ``Sun'' for Sunday.
13604 Weekday: ``sun'' for Sunday.
13606 Weekday: ``SUNDAY'' for Sunday.
13608 Weekday: ``Sunday'' for Sunday.
13610 Week number: ISO 8601 week number, ``W01'' for week 1.
13612 Day of year: ``34'' for Feb. 3.
13614 Day of year: ``034'' for Feb. 3.
13616 Day of year: `` 34'' for Feb. 3.
13618 Letter: Literal ``T''.
13620 Hour: ``5'' for 5 AM; ``17'' for 5 PM.
13622 Hour: ``05'' for 5 AM; ``17'' for 5 PM.
13624 Hour: `` 5'' for 5 AM; ``17'' for 5 PM.
13626 Hour: ``5'' for 5 AM and 5 PM.
13628 Hour: ``05'' for 5 AM and 5 PM.
13630 Hour: `` 5'' for 5 AM and 5 PM.
13632 AM/PM: ``a'' or ``p''.
13634 AM/PM: ``A'' or ``P''.
13636 AM/PM: ``am'' or ``pm''.
13638 AM/PM: ``AM'' or ``PM''.
13640 AM/PM: ``a.m.@:'' or ``p.m.''.
13642 AM/PM: ``A.M.'' or ``P.M.''.
13644 Minutes: ``7'' for 7.
13646 Minutes: ``07'' for 7.
13648 Minutes: `` 7'' for 7.
13650 Seconds: ``7'' for 7; ``7.23'' for 7.23.
13652 Seconds: ``07'' for 7; ``07.23'' for 7.23.
13654 Seconds: `` 7'' for 7; `` 7.23'' for 7.23.
13656 Optional seconds: ``07'' for 7; blank for 0.
13658 Optional seconds: `` 7'' for 7; blank for 0.
13660 Numeric date/time: ``726842.25'' for 6:00am Wed Jan 9, 1991.
13662 Numeric date: ``726842'' for any time on Wed Jan 9, 1991.
13664 Julian date/time: ``2448265.75'' for 6:00am Wed Jan 9, 1991.
13666 Julian date: ``2448266'' for any time on Wed Jan 9, 1991.
13668 Unix time: ``663400800'' for 6:00am Wed Jan 9, 1991.
13670 Brackets suppression. An ``X'' at the front of the format
13671 causes the surrounding @w{@samp{< >}} delimiters to be omitted
13672 when formatting dates. Note that the brackets are still
13673 required for algebraic entry.
13676 If ``SS'' or ``BS'' (optional seconds) is preceded by a colon, the
13677 colon is also omitted if the seconds part is zero.
13679 If ``bb,'' ``bbb'' or ``bbbb'' or their upper-case equivalents
13680 appear in the format, then negative year numbers are displayed
13681 without a minus sign. Note that ``aa'' and ``bb'' are mutually
13682 exclusive. Some typical usages would be @samp{YYYY AABB};
13683 @samp{AAAYYYYBBB}; @samp{YYYYBBB}.
13685 The formats ``YY,'' ``YYYY,'' ``MM,'' ``DD,'' ``ddd,'' ``hh,'' ``HH,''
13686 ``mm,'' ``ss,'' and ``SS'' actually match any number of digits during
13687 reading unless several of these codes are strung together with no
13688 punctuation in between, in which case the input must have exactly as
13689 many digits as there are letters in the format.
13691 The ``j,'' ``J,'' and ``U'' formats do not make any time zone
13692 adjustment. They effectively use @samp{julian(x,0)} and
13693 @samp{unixtime(x,0)} to make the conversion; @pxref{Date Arithmetic}.
13695 @node Free-Form Dates, Standard Date Formats, Date Formatting Codes, Date Formats
13696 @subsubsection Free-Form Dates
13699 When reading a date form during algebraic entry, Calc falls back
13700 on the algorithm described here if the input does not exactly
13701 match the current date format. This algorithm generally
13702 ``does the right thing'' and you don't have to worry about it,
13703 but it is described here in full detail for the curious.
13705 Calc does not distinguish between upper- and lower-case letters
13706 while interpreting dates.
13708 First, the time portion, if present, is located somewhere in the
13709 text and then removed. The remaining text is then interpreted as
13712 A time is of the form @samp{hh:mm:ss}, possibly with the seconds
13713 part omitted and possibly with an AM/PM indicator added to indicate
13714 12-hour time. If the AM/PM is present, the minutes may also be
13715 omitted. The AM/PM part may be any of the words @samp{am},
13716 @samp{pm}, @samp{noon}, or @samp{midnight}; each of these may be
13717 abbreviated to one letter, and the alternate forms @samp{a.m.},
13718 @samp{p.m.}, and @samp{mid} are also understood. Obviously
13719 @samp{noon} and @samp{midnight} are allowed only on 12:00:00.
13720 The words @samp{noon}, @samp{mid}, and @samp{midnight} are also
13721 recognized with no number attached. Midnight will represent the
13722 beginning of a day.
13724 If there is no AM/PM indicator, the time is interpreted in 24-hour
13727 When reading the date portion, Calc first checks to see if it is an
13728 ISO 8601 week-numbering date; if the string contains an integer
13729 representing the year, a ``W'' followed by two digits for the week
13730 number, and an integer from 1 to 7 representing the weekday (in that
13731 order), then all other characters are ignored and this information
13732 determines the date. Otherwise, all words and numbers are isolated
13733 from the string; other characters are ignored. All words must be
13734 either month names or day-of-week names (the latter of which are
13735 ignored). Names can be written in full or as three-letter
13738 Large numbers, or numbers with @samp{+} or @samp{-} signs,
13739 are interpreted as years. If one of the other numbers is
13740 greater than 12, then that must be the day and the remaining
13741 number in the input is therefore the month. Otherwise, Calc
13742 assumes the month, day and year are in the same order that they
13743 appear in the current date format. If the year is omitted, the
13744 current year is taken from the system clock.
13746 If there are too many or too few numbers, or any unrecognizable
13747 words, then the input is rejected.
13749 If there are any large numbers (of five digits or more) other than
13750 the year, they are ignored on the assumption that they are something
13751 like Julian dates that were included along with the traditional
13752 date components when the date was formatted.
13754 One of the words @samp{ad}, @samp{a.d.}, @samp{bc}, or @samp{b.c.}
13755 may optionally be used; the latter two are equivalent to a
13756 minus sign on the year value.
13758 If you always enter a four-digit year, and use a name instead
13759 of a number for the month, there is no danger of ambiguity.
13761 @node Standard Date Formats, , Free-Form Dates, Date Formats
13762 @subsubsection Standard Date Formats
13765 There are actually ten standard date formats, numbered 0 through 9.
13766 Entering a blank line at the @kbd{d d} command's prompt gives
13767 you format number 1, Calc's usual format. You can enter any digit
13768 to select the other formats.
13770 To create your own standard date formats, give a numeric prefix
13771 argument from 0 to 9 to the @w{@kbd{d d}} command. The format you
13772 enter will be recorded as the new standard format of that
13773 number, as well as becoming the new current date format.
13774 You can save your formats permanently with the @w{@kbd{m m}}
13775 command (@pxref{Mode Settings}).
13779 @samp{N} (Numerical format)
13781 @samp{<H:mm:SSpp >Www Mmm D, YYYY} (American format)
13783 @samp{D Mmm YYYY<, h:mm:SS>} (European format)
13785 @samp{Www Mmm BD< hh:mm:ss> YYYY} (Unix written date format)
13787 @samp{M/D/Y< H:mm:SSpp>} (American slashed format)
13789 @samp{D.M.Y< h:mm:SS>} (European dotted format)
13791 @samp{M-D-Y< H:mm:SSpp>} (American dashed format)
13793 @samp{D-M-Y< h:mm:SS>} (European dashed format)
13795 @samp{j<, h:mm:ss>} (Julian day plus time)
13797 @samp{YYddd< hh:mm:ss>} (Year-day format)
13799 @samp{ZYYY-MM-DD Www< hh:mm>} (Org mode format)
13801 @samp{IYYY-Iww-w<Thh:mm:ss>} (ISO 8601 week numbering format)
13804 @node Truncating the Stack, Justification, Date Formats, Display Modes
13805 @subsection Truncating the Stack
13809 @pindex calc-truncate-stack
13810 @cindex Truncating the stack
13811 @cindex Narrowing the stack
13812 The @kbd{d t} (@code{calc-truncate-stack}) command moves the @samp{.}@:
13813 line that marks the top-of-stack up or down in the Calculator buffer.
13814 The number right above that line is considered to the be at the top of
13815 the stack. Any numbers below that line are ``hidden'' from all stack
13816 operations (although still visible to the user). This is similar to the
13817 Emacs ``narrowing'' feature, except that the values below the @samp{.}
13818 are @emph{visible}, just temporarily frozen. This feature allows you to
13819 keep several independent calculations running at once in different parts
13820 of the stack, or to apply a certain command to an element buried deep in
13823 Pressing @kbd{d t} by itself moves the @samp{.} to the line the cursor
13824 is on. Thus, this line and all those below it become hidden. To un-hide
13825 these lines, move down to the end of the buffer and press @w{@kbd{d t}}.
13826 With a positive numeric prefix argument @expr{n}, @kbd{d t} hides the
13827 bottom @expr{n} values in the buffer. With a negative argument, it hides
13828 all but the top @expr{n} values. With an argument of zero, it hides zero
13829 values, i.e., moves the @samp{.} all the way down to the bottom.
13832 @pindex calc-truncate-up
13834 @pindex calc-truncate-down
13835 The @kbd{d [} (@code{calc-truncate-up}) and @kbd{d ]}
13836 (@code{calc-truncate-down}) commands move the @samp{.} up or down one
13837 line at a time (or several lines with a prefix argument).
13839 @node Justification, Labels, Truncating the Stack, Display Modes
13840 @subsection Justification
13844 @pindex calc-left-justify
13846 @pindex calc-center-justify
13848 @pindex calc-right-justify
13849 Values on the stack are normally left-justified in the window. You can
13850 control this arrangement by typing @kbd{d <} (@code{calc-left-justify}),
13851 @kbd{d >} (@code{calc-right-justify}), or @kbd{d =}
13852 (@code{calc-center-justify}). For example, in Right-Justification mode,
13853 stack entries are displayed flush-right against the right edge of the
13856 If you change the width of the Calculator window you may have to type
13857 @kbd{d @key{SPC}} (@code{calc-refresh}) to re-align right-justified or centered
13860 Right-justification is especially useful together with fixed-point
13861 notation (see @code{d f}; @code{calc-fix-notation}). With these modes
13862 together, the decimal points on numbers will always line up.
13864 With a numeric prefix argument, the justification commands give you
13865 a little extra control over the display. The argument specifies the
13866 horizontal ``origin'' of a display line. It is also possible to
13867 specify a maximum line width using the @kbd{d b} command (@pxref{Normal
13868 Language Modes}). For reference, the precise rules for formatting and
13869 breaking lines are given below. Notice that the interaction between
13870 origin and line width is slightly different in each justification
13873 In Left-Justified mode, the line is indented by a number of spaces
13874 given by the origin (default zero). If the result is longer than the
13875 maximum line width, if given, or too wide to fit in the Calc window
13876 otherwise, then it is broken into lines which will fit; each broken
13877 line is indented to the origin.
13879 In Right-Justified mode, lines are shifted right so that the rightmost
13880 character is just before the origin, or just before the current
13881 window width if no origin was specified. If the line is too long
13882 for this, then it is broken; the current line width is used, if
13883 specified, or else the origin is used as a width if that is
13884 specified, or else the line is broken to fit in the window.
13886 In Centering mode, the origin is the column number of the center of
13887 each stack entry. If a line width is specified, lines will not be
13888 allowed to go past that width; Calc will either indent less or
13889 break the lines if necessary. If no origin is specified, half the
13890 line width or Calc window width is used.
13892 Note that, in each case, if line numbering is enabled the display
13893 is indented an additional four spaces to make room for the line
13894 number. The width of the line number is taken into account when
13895 positioning according to the current Calc window width, but not
13896 when positioning by explicit origins and widths. In the latter
13897 case, the display is formatted as specified, and then uniformly
13898 shifted over four spaces to fit the line numbers.
13900 @node Labels, , Justification, Display Modes
13905 @pindex calc-left-label
13906 The @kbd{d @{} (@code{calc-left-label}) command prompts for a string,
13907 then displays that string to the left of every stack entry. If the
13908 entries are left-justified (@pxref{Justification}), then they will
13909 appear immediately after the label (unless you specified an origin
13910 greater than the length of the label). If the entries are centered
13911 or right-justified, the label appears on the far left and does not
13912 affect the horizontal position of the stack entry.
13914 Give a blank string (with @kbd{d @{ @key{RET}}) to turn the label off.
13917 @pindex calc-right-label
13918 The @kbd{d @}} (@code{calc-right-label}) command similarly adds a
13919 label on the righthand side. It does not affect positioning of
13920 the stack entries unless they are right-justified. Also, if both
13921 a line width and an origin are given in Right-Justified mode, the
13922 stack entry is justified to the origin and the righthand label is
13923 justified to the line width.
13925 One application of labels would be to add equation numbers to
13926 formulas you are manipulating in Calc and then copying into a
13927 document (possibly using Embedded mode). The equations would
13928 typically be centered, and the equation numbers would be on the
13929 left or right as you prefer.
13931 @node Language Modes, Modes Variable, Display Modes, Mode Settings
13932 @section Language Modes
13935 The commands in this section change Calc to use a different notation for
13936 entry and display of formulas, corresponding to the conventions of some
13937 other common language such as Pascal or @LaTeX{}. Objects displayed on the
13938 stack or yanked from the Calculator to an editing buffer will be formatted
13939 in the current language; objects entered in algebraic entry or yanked from
13940 another buffer will be interpreted according to the current language.
13942 The current language has no effect on things written to or read from the
13943 trail buffer, nor does it affect numeric entry. Only algebraic entry is
13944 affected. You can make even algebraic entry ignore the current language
13945 and use the standard notation by giving a numeric prefix, e.g., @kbd{C-u '}.
13947 For example, suppose the formula @samp{2*a[1] + atan(a[2])} occurs in a C
13948 program; elsewhere in the program you need the derivatives of this formula
13949 with respect to @samp{a[1]} and @samp{a[2]}. First, type @kbd{d C}
13950 to switch to C notation. Now use @code{C-u C-x * g} to grab the formula
13951 into the Calculator, @kbd{a d a[1] @key{RET}} to differentiate with respect
13952 to the first variable, and @kbd{C-x * y} to yank the formula for the derivative
13953 back into your C program. Press @kbd{U} to undo the differentiation and
13954 repeat with @kbd{a d a[2] @key{RET}} for the other derivative.
13956 Without being switched into C mode first, Calc would have misinterpreted
13957 the brackets in @samp{a[1]} and @samp{a[2]}, would not have known that
13958 @code{atan} was equivalent to Calc's built-in @code{arctan} function,
13959 and would have written the formula back with notations (like implicit
13960 multiplication) which would not have been valid for a C program.
13962 As another example, suppose you are maintaining a C program and a @LaTeX{}
13963 document, each of which needs a copy of the same formula. You can grab the
13964 formula from the program in C mode, switch to @LaTeX{} mode, and yank the
13965 formula into the document in @LaTeX{} math-mode format.
13967 Language modes are selected by typing the letter @kbd{d} followed by a
13968 shifted letter key.
13971 * Normal Language Modes::
13972 * C FORTRAN Pascal::
13973 * TeX and LaTeX Language Modes::
13974 * Eqn Language Mode::
13975 * Yacas Language Mode::
13976 * Maxima Language Mode::
13977 * Giac Language Mode::
13978 * Mathematica Language Mode::
13979 * Maple Language Mode::
13984 @node Normal Language Modes, C FORTRAN Pascal, Language Modes, Language Modes
13985 @subsection Normal Language Modes
13989 @pindex calc-normal-language
13990 The @kbd{d N} (@code{calc-normal-language}) command selects the usual
13991 notation for Calc formulas, as described in the rest of this manual.
13992 Matrices are displayed in a multi-line tabular format, but all other
13993 objects are written in linear form, as they would be typed from the
13997 @pindex calc-flat-language
13998 @cindex Matrix display
13999 The @kbd{d O} (@code{calc-flat-language}) command selects a language
14000 identical with the normal one, except that matrices are written in
14001 one-line form along with everything else. In some applications this
14002 form may be more suitable for yanking data into other buffers.
14005 @pindex calc-line-breaking
14006 @cindex Line breaking
14007 @cindex Breaking up long lines
14008 Even in one-line mode, long formulas or vectors will still be split
14009 across multiple lines if they exceed the width of the Calculator window.
14010 The @kbd{d b} (@code{calc-line-breaking}) command turns this line-breaking
14011 feature on and off. (It works independently of the current language.)
14012 If you give a numeric prefix argument of five or greater to the @kbd{d b}
14013 command, that argument will specify the line width used when breaking
14017 @pindex calc-big-language
14018 The @kbd{d B} (@code{calc-big-language}) command selects a language
14019 which uses textual approximations to various mathematical notations,
14020 such as powers, quotients, and square roots:
14030 in place of @samp{sqrt((a+1)/b + c^2)}.
14032 Subscripts like @samp{a_i} are displayed as actual subscripts in Big
14033 mode. Double subscripts, @samp{a_i_j} (@samp{subscr(subscr(a, i), j)})
14034 are displayed as @samp{a} with subscripts separated by commas:
14035 @samp{i, j}. They must still be entered in the usual underscore
14038 One slight ambiguity of Big notation is that
14047 can represent either the negative rational number @expr{-3:4}, or the
14048 actual expression @samp{-(3/4)}; but the latter formula would normally
14049 never be displayed because it would immediately be evaluated to
14050 @expr{-3:4} or @expr{-0.75}, so this ambiguity is not a problem in
14053 Non-decimal numbers are displayed with subscripts. Thus there is no
14054 way to tell the difference between @samp{16#C2} and @samp{C2_16},
14055 though generally you will know which interpretation is correct.
14056 Logarithms @samp{log(x,b)} and @samp{log10(x)} also use subscripts
14059 In Big mode, stack entries often take up several lines. To aid
14060 readability, stack entries are separated by a blank line in this mode.
14061 You may find it useful to expand the Calc window's height using
14062 @kbd{C-x ^} (@code{enlarge-window}) or to make the Calc window the only
14063 one on the screen with @kbd{C-x 1} (@code{delete-other-windows}).
14065 Long lines are currently not rearranged to fit the window width in
14066 Big mode, so you may need to use the @kbd{<} and @kbd{>} keys
14067 to scroll across a wide formula. For really big formulas, you may
14068 even need to use @kbd{@{} and @kbd{@}} to scroll up and down.
14071 @pindex calc-unformatted-language
14072 The @kbd{d U} (@code{calc-unformatted-language}) command altogether disables
14073 the use of operator notation in formulas. In this mode, the formula
14074 shown above would be displayed:
14077 sqrt(add(div(add(a, 1), b), pow(c, 2)))
14080 These four modes differ only in display format, not in the format
14081 expected for algebraic entry. The standard Calc operators work in
14082 all four modes, and unformatted notation works in any language mode
14083 (except that Mathematica mode expects square brackets instead of
14086 @node C FORTRAN Pascal, TeX and LaTeX Language Modes, Normal Language Modes, Language Modes
14087 @subsection C, FORTRAN, and Pascal Modes
14091 @pindex calc-c-language
14093 The @kbd{d C} (@code{calc-c-language}) command selects the conventions
14094 of the C language for display and entry of formulas. This differs from
14095 the normal language mode in a variety of (mostly minor) ways. In
14096 particular, C language operators and operator precedences are used in
14097 place of Calc's usual ones. For example, @samp{a^b} means @samp{xor(a,b)}
14098 in C mode; a value raised to a power is written as a function call,
14101 In C mode, vectors and matrices use curly braces instead of brackets.
14102 Octal and hexadecimal values are written with leading @samp{0} or @samp{0x}
14103 rather than using the @samp{#} symbol. Array subscripting is
14104 translated into @code{subscr} calls, so that @samp{a[i]} in C
14105 mode is the same as @samp{a_i} in Normal mode. Assignments
14106 turn into the @code{assign} function, which Calc normally displays
14107 using the @samp{:=} symbol.
14109 The variables @code{pi} and @code{e} would be displayed @samp{pi}
14110 and @samp{e} in Normal mode, but in C mode they are displayed as
14111 @samp{M_PI} and @samp{M_E}, corresponding to the names of constants
14112 typically provided in the @file{<math.h>} header. Functions whose
14113 names are different in C are translated automatically for entry and
14114 display purposes. For example, entering @samp{asin(x)} will push the
14115 formula @samp{arcsin(x)} onto the stack; this formula will be displayed
14116 as @samp{asin(x)} as long as C mode is in effect.
14119 @pindex calc-pascal-language
14120 @cindex Pascal language
14121 The @kbd{d P} (@code{calc-pascal-language}) command selects Pascal
14122 conventions. Like C mode, Pascal mode interprets array brackets and uses
14123 a different table of operators. Hexadecimal numbers are entered and
14124 displayed with a preceding dollar sign. (Thus the regular meaning of
14125 @kbd{$2} during algebraic entry does not work in Pascal mode, though
14126 @kbd{$} (and @kbd{$$}, etc.)@: not followed by digits works the same as
14127 always.) No special provisions are made for other non-decimal numbers,
14128 vectors, and so on, since there is no universally accepted standard way
14129 of handling these in Pascal.
14132 @pindex calc-fortran-language
14133 @cindex FORTRAN language
14134 The @kbd{d F} (@code{calc-fortran-language}) command selects FORTRAN
14135 conventions. Various function names are transformed into FORTRAN
14136 equivalents. Vectors are written as @samp{/1, 2, 3/}, and may be
14137 entered this way or using square brackets. Since FORTRAN uses round
14138 parentheses for both function calls and array subscripts, Calc displays
14139 both in the same way; @samp{a(i)} is interpreted as a function call
14140 upon reading, and subscripts must be entered as @samp{subscr(a, i)}.
14141 If the variable @code{a} has been declared to have type
14142 @code{vector} or @code{matrix}, however, then @samp{a(i)} will be
14143 parsed as a subscript. (@xref{Declarations}.) Usually it doesn't
14144 matter, though; if you enter the subscript expression @samp{a(i)} and
14145 Calc interprets it as a function call, you'll never know the difference
14146 unless you switch to another language mode or replace @code{a} with an
14147 actual vector (or unless @code{a} happens to be the name of a built-in
14150 Underscores are allowed in variable and function names in all of these
14151 language modes. The underscore here is equivalent to the @samp{#} in
14152 Normal mode, or to hyphens in the underlying Emacs Lisp variable names.
14154 FORTRAN and Pascal modes normally do not adjust the case of letters in
14155 formulas. Most built-in Calc names use lower-case letters. If you use a
14156 positive numeric prefix argument with @kbd{d P} or @kbd{d F}, these
14157 modes will use upper-case letters exclusively for display, and will
14158 convert to lower-case on input. With a negative prefix, these modes
14159 convert to lower-case for display and input.
14161 @node TeX and LaTeX Language Modes, Eqn Language Mode, C FORTRAN Pascal, Language Modes
14162 @subsection @TeX{} and @LaTeX{} Language Modes
14166 @pindex calc-tex-language
14167 @cindex TeX language
14169 @pindex calc-latex-language
14170 @cindex LaTeX language
14171 The @kbd{d T} (@code{calc-tex-language}) command selects the conventions
14172 of ``math mode'' in Donald Knuth's @TeX{} typesetting language,
14173 and the @kbd{d L} (@code{calc-latex-language}) command selects the
14174 conventions of ``math mode'' in @LaTeX{}, a typesetting language that
14175 uses @TeX{} as its formatting engine. Calc's @LaTeX{} language mode can
14176 read any formula that the @TeX{} language mode can, although @LaTeX{}
14177 mode may display it differently.
14179 Formulas are entered and displayed in the appropriate notation;
14180 @texline @math{\sin(a/b)}
14181 @infoline @expr{sin(a/b)}
14182 will appear as @samp{\sin\left( @{a \over b@} \right)} in @TeX{} mode and
14183 @samp{\sin\left(\frac@{a@}@{b@}\right)} in @LaTeX{} mode.
14184 Math formulas are often enclosed by @samp{$ $} signs in @TeX{} and
14185 @LaTeX{}; these should be omitted when interfacing with Calc. To Calc,
14186 the @samp{$} sign has the same meaning it always does in algebraic
14187 formulas (a reference to an existing entry on the stack).
14189 Complex numbers are displayed as in @samp{3 + 4i}. Fractions and
14190 quotients are written using @code{\over} in @TeX{} mode (as in
14191 @code{@{a \over b@}}) and @code{\frac} in @LaTeX{} mode (as in
14192 @code{\frac@{a@}@{b@}}); binomial coefficients are written with
14193 @code{\choose} in @TeX{} mode (as in @code{@{a \choose b@}}) and
14194 @code{\binom} in @LaTeX{} mode (as in @code{\binom@{a@}@{b@}}).
14195 Interval forms are written with @code{\ldots}, and error forms are
14196 written with @code{\pm}. Absolute values are written as in
14197 @samp{|x + 1|}, and the floor and ceiling functions are written with
14198 @code{\lfloor}, @code{\rfloor}, etc. The words @code{\left} and
14199 @code{\right} are ignored when reading formulas in @TeX{} and @LaTeX{}
14200 modes. Both @code{inf} and @code{uinf} are written as @code{\infty};
14201 when read, @code{\infty} always translates to @code{inf}.
14203 Function calls are written the usual way, with the function name followed
14204 by the arguments in parentheses. However, functions for which @TeX{}
14205 and @LaTeX{} have special names (like @code{\sin}) will use curly braces
14206 instead of parentheses for very simple arguments. During input, curly
14207 braces and parentheses work equally well for grouping, but when the
14208 document is formatted the curly braces will be invisible. Thus the
14210 @texline @math{\sin{2 x}}
14211 @infoline @expr{sin 2x}
14213 @texline @math{\sin(2 + x)}.
14214 @infoline @expr{sin(2 + x)}.
14216 The @TeX{} specific unit names (@pxref{Predefined Units}) will not use
14217 the @samp{tex} prefix; the unit name for a @TeX{} point will be
14218 @samp{pt} instead of @samp{texpt}, for example.
14220 Function and variable names not treated specially by @TeX{} and @LaTeX{}
14221 are simply written out as-is, which will cause them to come out in
14222 italic letters in the printed document. If you invoke @kbd{d T} or
14223 @kbd{d L} with a positive numeric prefix argument, names of more than
14224 one character will instead be enclosed in a protective commands that
14225 will prevent them from being typeset in the math italics; they will be
14226 written @samp{\hbox@{@var{name}@}} in @TeX{} mode and
14227 @samp{\text@{@var{name}@}} in @LaTeX{} mode. The
14228 @samp{\hbox@{ @}} and @samp{\text@{ @}} notations are ignored during
14229 reading. If you use a negative prefix argument, such function names are
14230 written @samp{\@var{name}}, and function names that begin with @code{\} during
14231 reading have the @code{\} removed. (Note that in this mode, long
14232 variable names are still written with @code{\hbox} or @code{\text}.
14233 However, you can always make an actual variable name like @code{\bar} in
14236 During reading, text of the form @samp{\matrix@{ ...@: @}} is replaced
14237 by @samp{[ ...@: ]}. The same also applies to @code{\pmatrix} and
14238 @code{\bmatrix}. In @LaTeX{} mode this also applies to
14239 @samp{\begin@{matrix@} ... \end@{matrix@}},
14240 @samp{\begin@{bmatrix@} ... \end@{bmatrix@}},
14241 @samp{\begin@{pmatrix@} ... \end@{pmatrix@}}, as well as
14242 @samp{\begin@{smallmatrix@} ... \end@{smallmatrix@}}.
14243 The symbol @samp{&} is interpreted as a comma,
14244 and the symbols @samp{\cr} and @samp{\\} are interpreted as semicolons.
14245 During output, matrices are displayed in @samp{\matrix@{ a & b \\ c & d@}}
14246 format in @TeX{} mode and in
14247 @samp{\begin@{pmatrix@} a & b \\ c & d \end@{pmatrix@}} format in
14248 @LaTeX{} mode; you may need to edit this afterwards to change to your
14249 preferred matrix form. If you invoke @kbd{d T} or @kbd{d L} with an
14250 argument of 2 or -2, then matrices will be displayed in two-dimensional
14261 This may be convenient for isolated matrices, but could lead to
14262 expressions being displayed like
14265 \begin@{pmatrix@} \times x
14272 While this wouldn't bother Calc, it is incorrect @LaTeX{}.
14273 (Similarly for @TeX{}.)
14275 Accents like @code{\tilde} and @code{\bar} translate into function
14276 calls internally (@samp{tilde(x)}, @samp{bar(x)}). The @code{\underline}
14277 sequence is treated as an accent. The @code{\vec} accent corresponds
14278 to the function name @code{Vec}, because @code{vec} is the name of
14279 a built-in Calc function. The following table shows the accents
14280 in Calc, @TeX{}, @LaTeX{} and @dfn{eqn} (described in the next section):
14285 @let@calcindexershow=@calcindexernoshow @c Suppress marginal notes
14286 @let@calcindexersh=@calcindexernoshow
14395 acute \acute \acute
14399 breve \breve \breve
14401 check \check \check
14407 dotdot \ddot \ddot dotdot
14410 grave \grave \grave
14415 tilde \tilde \tilde tilde
14417 under \underline \underline under
14422 The @samp{=>} (evaluates-to) operator appears as a @code{\to} symbol:
14423 @samp{@{@var{a} \to @var{b}@}}. @TeX{} defines @code{\to} as an
14424 alias for @code{\rightarrow}. However, if the @samp{=>} is the
14425 top-level expression being formatted, a slightly different notation
14426 is used: @samp{\evalto @var{a} \to @var{b}}. The @code{\evalto}
14427 word is ignored by Calc's input routines, and is undefined in @TeX{}.
14428 You will typically want to include one of the following definitions
14429 at the top of a @TeX{} file that uses @code{\evalto}:
14433 \def\evalto#1\to@{@}
14436 The first definition formats evaluates-to operators in the usual
14437 way. The second causes only the @var{b} part to appear in the
14438 printed document; the @var{a} part and the arrow are hidden.
14439 Another definition you may wish to use is @samp{\let\to=\Rightarrow}
14440 which causes @code{\to} to appear more like Calc's @samp{=>} symbol.
14441 @xref{Evaluates-To Operator}, for a discussion of @code{evalto}.
14443 The complete set of @TeX{} control sequences that are ignored during
14447 \hbox \mbox \text \left \right
14448 \, \> \: \; \! \quad \qquad \hfil \hfill
14449 \displaystyle \textstyle \dsize \tsize
14450 \scriptstyle \scriptscriptstyle \ssize \ssize
14451 \rm \bf \it \sl \roman \bold \italic \slanted
14452 \cal \mit \Cal \Bbb \frak \goth
14456 Note that, because these symbols are ignored, reading a @TeX{} or
14457 @LaTeX{} formula into Calc and writing it back out may lose spacing and
14460 Also, the ``discretionary multiplication sign'' @samp{\*} is read
14461 the same as @samp{*}.
14464 The @TeX{} version of this manual includes some printed examples at the
14465 end of this section.
14468 Here are some examples of how various Calc formulas are formatted in @TeX{}:
14473 \sin\left( {a^2 \over b_i} \right)
14477 $$ \sin\left( a^2 \over b_i \right) $$
14483 [(3, 4), 3:4, 3 +/- 4, [3 .. inf)]
14484 [3 + 4i, @{3 \over 4@}, 3 \pm 4, [3 \ldots \infty)]
14488 $$ [3 + 4i, {3 \over 4}, 3 \pm 4, [ 3 \ldots \infty)] $$
14494 [abs(a), abs(a / b), floor(a), ceil(a / b)]
14495 [|a|, \left| a \over b \right|,
14496 \lfloor a \rfloor, \left\lceil a \over b \right\rceil]
14500 $$ [|a|, \left| a \over b \right|,
14501 \lfloor a \rfloor, \left\lceil a \over b \right\rceil] $$
14507 [sin(a), sin(2 a), sin(2 + a), sin(a / b)]
14508 [\sin@{a@}, \sin@{2 a@}, \sin(2 + a),
14509 \sin\left( @{a \over b@} \right)]
14513 $$ [\sin{a}, \sin{2 a}, \sin(2 + a), \sin\left( {a \over b} \right)] $$
14517 First with plain @kbd{d T}, then with @kbd{C-u d T}, then finally with
14518 @kbd{C-u - d T} (using the example definition
14519 @samp{\def\foo#1@{\tilde F(#1)@}}:
14523 [f(a), foo(bar), sin(pi)]
14524 [f(a), foo(bar), \sin{\pi}]
14525 [f(a), \hbox@{foo@}(\hbox@{bar@}), \sin@{\pi@}]
14526 [f(a), \foo@{\hbox@{bar@}@}, \sin@{\pi@}]
14530 $$ [f(a), foo(bar), \sin{\pi}] $$
14531 $$ [f(a), \hbox{foo}(\hbox{bar}), \sin{\pi}] $$
14532 $$ [f(a), \tilde F(\hbox{bar}), \sin{\pi}] $$
14536 First with @samp{\def\evalto@{@}}, then with @samp{\def\evalto#1\to@{@}}:
14541 \evalto 2 + 3 \to 5
14550 First with standard @code{\to}, then with @samp{\let\to\Rightarrow}:
14554 [2 + 3 => 5, a / 2 => (b + c) / 2]
14555 [@{2 + 3 \to 5@}, @{@{a \over 2@} \to @{b + c \over 2@}@}]
14559 $$ [{2 + 3 \to 5}, {{a \over 2} \to {b + c \over 2}}] $$
14560 {\let\to\Rightarrow
14561 $$ [{2 + 3 \to 5}, {{a \over 2} \to {b + c \over 2}}] $$}
14565 Matrices normally, then changing @code{\matrix} to @code{\pmatrix}:
14569 [ [ a / b, 0 ], [ 0, 2^(x + 1) ] ]
14570 \matrix@{ @{a \over b@} & 0 \\ 0 & 2^@{(x + 1)@} @}
14571 \pmatrix@{ @{a \over b@} & 0 \\ 0 & 2^@{(x + 1)@} @}
14575 $$ \matrix{ {a \over b} & 0 \cr 0 & 2^{(x + 1)} } $$
14576 $$ \pmatrix{ {a \over b} & 0 \cr 0 & 2^{(x + 1)} } $$
14581 @node Eqn Language Mode, Yacas Language Mode, TeX and LaTeX Language Modes, Language Modes
14582 @subsection Eqn Language Mode
14586 @pindex calc-eqn-language
14587 @dfn{Eqn} is another popular formatter for math formulas. It is
14588 designed for use with the TROFF text formatter, and comes standard
14589 with many versions of Unix. The @kbd{d E} (@code{calc-eqn-language})
14590 command selects @dfn{eqn} notation.
14592 The @dfn{eqn} language's main idiosyncrasy is that whitespace plays
14593 a significant part in the parsing of the language. For example,
14594 @samp{sqrt x+1 + y} treats @samp{x+1} as the argument of the
14595 @code{sqrt} operator. @dfn{Eqn} also understands more conventional
14596 grouping using curly braces: @samp{sqrt@{x+1@} + y}. Braces are
14597 required only when the argument contains spaces.
14599 In Calc's @dfn{eqn} mode, however, curly braces are required to
14600 delimit arguments of operators like @code{sqrt}. The first of the
14601 above examples would treat only the @samp{x} as the argument of
14602 @code{sqrt}, and in fact @samp{sin x+1} would be interpreted as
14603 @samp{sin * x + 1}, because @code{sin} is not a special operator
14604 in the @dfn{eqn} language. If you always surround the argument
14605 with curly braces, Calc will never misunderstand.
14607 Calc also understands parentheses as grouping characters. Another
14608 peculiarity of @dfn{eqn}'s syntax makes it advisable to separate
14609 words with spaces from any surrounding characters that aren't curly
14610 braces, so Calc writes @samp{sin ( x + y )} in @dfn{eqn} mode.
14611 (The spaces around @code{sin} are important to make @dfn{eqn}
14612 recognize that @code{sin} should be typeset in a roman font, and
14613 the spaces around @code{x} and @code{y} are a good idea just in
14614 case the @dfn{eqn} document has defined special meanings for these
14617 Powers and subscripts are written with the @code{sub} and @code{sup}
14618 operators, respectively. Note that the caret symbol @samp{^} is
14619 treated the same as a space in @dfn{eqn} mode, as is the @samp{~}
14620 symbol (these are used to introduce spaces of various widths into
14621 the typeset output of @dfn{eqn}).
14623 As in @LaTeX{} mode, Calc's formatter omits parentheses around the
14624 arguments of functions like @code{ln} and @code{sin} if they are
14625 ``simple-looking''; in this case Calc surrounds the argument with
14626 braces, separated by a @samp{~} from the function name: @samp{sin~@{x@}}.
14628 Font change codes (like @samp{roman @var{x}}) and positioning codes
14629 (like @samp{~} and @samp{down @var{n} @var{x}}) are ignored by the
14630 @dfn{eqn} reader. Also ignored are the words @code{left}, @code{right},
14631 @code{mark}, and @code{lineup}. Quotation marks in @dfn{eqn} mode input
14632 are treated the same as curly braces: @samp{sqrt "1+x"} is equivalent to
14633 @samp{sqrt @{1+x@}}; this is only an approximation to the true meaning
14634 of quotes in @dfn{eqn}, but it is good enough for most uses.
14636 Accent codes (@samp{@var{x} dot}) are handled by treating them as
14637 function calls (@samp{dot(@var{x})}) internally.
14638 @xref{TeX and LaTeX Language Modes}, for a table of these accent
14639 functions. The @code{prime} accent is treated specially if it occurs on
14640 a variable or function name: @samp{f prime prime @w{( x prime )}} is
14641 stored internally as @samp{f'@w{'}(x')}. For example, taking the
14642 derivative of @samp{f(2 x)} with @kbd{a d x} will produce @samp{2 f'(2
14643 x)}, which @dfn{eqn} mode will display as @samp{2 f prime ( 2 x )}.
14645 Assignments are written with the @samp{<-} (left-arrow) symbol,
14646 and @code{evalto} operators are written with @samp{->} or
14647 @samp{evalto ... ->} (@pxref{TeX and LaTeX Language Modes}, for a discussion
14648 of this). The regular Calc symbols @samp{:=} and @samp{=>} are also
14649 recognized for these operators during reading.
14651 Vectors in @dfn{eqn} mode use regular Calc square brackets, but
14652 matrices are formatted as @samp{matrix @{ ccol @{ a above b @} ... @}}.
14653 The words @code{lcol} and @code{rcol} are recognized as synonyms
14654 for @code{ccol} during input, and are generated instead of @code{ccol}
14655 if the matrix justification mode so specifies.
14657 @node Yacas Language Mode, Maxima Language Mode, Eqn Language Mode, Language Modes
14658 @subsection Yacas Language Mode
14662 @pindex calc-yacas-language
14663 @cindex Yacas language
14664 The @kbd{d Y} (@code{calc-yacas-language}) command selects the
14665 conventions of Yacas, a free computer algebra system. While the
14666 operators and functions in Yacas are similar to those of Calc, the names
14667 of built-in functions in Yacas are capitalized. The Calc formula
14668 @samp{sin(2 x)}, for example, is entered and displayed @samp{Sin(2 x)}
14669 in Yacas mode, and `@samp{arcsin(x^2)} is @samp{ArcSin(x^2)} in Yacas
14670 mode. Complex numbers are written are written @samp{3 + 4 I}.
14671 The standard special constants are written @code{Pi}, @code{E},
14672 @code{I}, @code{GoldenRatio} and @code{Gamma}. @code{Infinity}
14673 represents both @code{inf} and @code{uinf}, and @code{Undefined}
14674 represents @code{nan}.
14676 Certain operators on functions, such as @code{D} for differentiation
14677 and @code{Integrate} for integration, take a prefix form in Yacas. For
14678 example, the derivative of @w{@samp{e^x sin(x)}} can be computed with
14679 @w{@samp{D(x) Exp(x)*Sin(x)}}.
14681 Other notable differences between Yacas and standard Calc expressions
14682 are that vectors and matrices use curly braces in Yacas, and subscripts
14683 use square brackets. If, for example, @samp{A} represents the list
14684 @samp{@{a,2,c,4@}}, then @samp{A[3]} would equal @samp{c}.
14687 @node Maxima Language Mode, Giac Language Mode, Yacas Language Mode, Language Modes
14688 @subsection Maxima Language Mode
14692 @pindex calc-maxima-language
14693 @cindex Maxima language
14694 The @kbd{d X} (@code{calc-maxima-language}) command selects the
14695 conventions of Maxima, another free computer algebra system. The
14696 function names in Maxima are similar, but not always identical, to Calc.
14697 For example, instead of @samp{arcsin(x)}, Maxima will use
14698 @samp{asin(x)}. Complex numbers are written @samp{3 + 4 %i}. The
14699 standard special constants are written @code{%pi}, @code{%e},
14700 @code{%i}, @code{%phi} and @code{%gamma}. In Maxima, @code{inf} means
14701 the same as in Calc, but @code{infinity} represents Calc's @code{uinf}.
14703 Underscores as well as percent signs are allowed in function and
14704 variable names in Maxima mode. The underscore again is equivalent to
14705 the @samp{#} in Normal mode, and the percent sign is equivalent to
14708 Maxima uses square brackets for lists and vectors, and matrices are
14709 written as calls to the function @code{matrix}, given the row vectors of
14710 the matrix as arguments. Square brackets are also used as subscripts.
14712 @node Giac Language Mode, Mathematica Language Mode, Maxima Language Mode, Language Modes
14713 @subsection Giac Language Mode
14717 @pindex calc-giac-language
14718 @cindex Giac language
14719 The @kbd{d A} (@code{calc-giac-language}) command selects the
14720 conventions of Giac, another free computer algebra system. The function
14721 names in Giac are similar to Maxima. Complex numbers are written
14722 @samp{3 + 4 i}. The standard special constants in Giac are the same as
14723 in Calc, except that @code{infinity} represents both Calc's @code{inf}
14726 Underscores are allowed in function and variable names in Giac mode.
14727 Brackets are used for subscripts. In Giac, indexing of lists begins at
14728 0, instead of 1 as in Calc. So if @samp{A} represents the list
14729 @samp{[a,2,c,4]}, then @samp{A[2]} would equal @samp{c}. In general,
14730 @samp{A[n]} in Giac mode corresponds to @samp{A_(n+1)} in Normal mode.
14732 The Giac interval notation @samp{2 .. 3} has no surrounding brackets;
14733 Calc reads @samp{2 .. 3} as the closed interval @samp{[2 .. 3]} and
14734 writes any kind of interval as @samp{2 .. 3}. This means you cannot see
14735 the difference between an open and a closed interval while in Giac mode.
14737 @node Mathematica Language Mode, Maple Language Mode, Giac Language Mode, Language Modes
14738 @subsection Mathematica Language Mode
14742 @pindex calc-mathematica-language
14743 @cindex Mathematica language
14744 The @kbd{d M} (@code{calc-mathematica-language}) command selects the
14745 conventions of Mathematica. Notable differences in Mathematica mode
14746 are that the names of built-in functions are capitalized, and function
14747 calls use square brackets instead of parentheses. Thus the Calc
14748 formula @samp{sin(2 x)} is entered and displayed @w{@samp{Sin[2 x]}} in
14751 Vectors and matrices use curly braces in Mathematica. Complex numbers
14752 are written @samp{3 + 4 I}. The standard special constants in Calc are
14753 written @code{Pi}, @code{E}, @code{I}, @code{GoldenRatio}, @code{EulerGamma},
14754 @code{Infinity}, @code{ComplexInfinity}, and @code{Indeterminate} in
14756 Non-decimal numbers are written, e.g., @samp{16^^7fff}. Floating-point
14757 numbers in scientific notation are written @samp{1.23*10.^3}.
14758 Subscripts use double square brackets: @samp{a[[i]]}.
14760 @node Maple Language Mode, Compositions, Mathematica Language Mode, Language Modes
14761 @subsection Maple Language Mode
14765 @pindex calc-maple-language
14766 @cindex Maple language
14767 The @kbd{d W} (@code{calc-maple-language}) command selects the
14768 conventions of Maple.
14770 Maple's language is much like C@. Underscores are allowed in symbol
14771 names; square brackets are used for subscripts; explicit @samp{*}s for
14772 multiplications are required. Use either @samp{^} or @samp{**} to
14775 Maple uses square brackets for lists and curly braces for sets. Calc
14776 interprets both notations as vectors, and displays vectors with square
14777 brackets. This means Maple sets will be converted to lists when they
14778 pass through Calc. As a special case, matrices are written as calls
14779 to the function @code{matrix}, given a list of lists as the argument,
14780 and can be read in this form or with all-capitals @code{MATRIX}.
14782 The Maple interval notation @samp{2 .. 3} is like Giac's interval
14783 notation, and is handled the same by Calc.
14785 Maple writes complex numbers as @samp{3 + 4*I}. Its special constants
14786 are @code{Pi}, @code{E}, @code{I}, and @code{infinity} (all three of
14787 @code{inf}, @code{uinf}, and @code{nan} display as @code{infinity}).
14788 Floating-point numbers are written @samp{1.23*10.^3}.
14790 Among things not currently handled by Calc's Maple mode are the
14791 various quote symbols, procedures and functional operators, and
14792 inert (@samp{&}) operators.
14794 @node Compositions, Syntax Tables, Maple Language Mode, Language Modes
14795 @subsection Compositions
14798 @cindex Compositions
14799 There are several @dfn{composition functions} which allow you to get
14800 displays in a variety of formats similar to those in Big language
14801 mode. Most of these functions do not evaluate to anything; they are
14802 placeholders which are left in symbolic form by Calc's evaluator but
14803 are recognized by Calc's display formatting routines.
14805 Two of these, @code{string} and @code{bstring}, are described elsewhere.
14806 @xref{Strings}. For example, @samp{string("ABC")} is displayed as
14807 @samp{ABC}. When viewed on the stack it will be indistinguishable from
14808 the variable @code{ABC}, but internally it will be stored as
14809 @samp{string([65, 66, 67])} and can still be manipulated this way; for
14810 example, the selection and vector commands @kbd{j 1 v v j u} would
14811 select the vector portion of this object and reverse the elements, then
14812 deselect to reveal a string whose characters had been reversed.
14814 The composition functions do the same thing in all language modes
14815 (although their components will of course be formatted in the current
14816 language mode). The one exception is Unformatted mode (@kbd{d U}),
14817 which does not give the composition functions any special treatment.
14818 The functions are discussed here because of their relationship to
14819 the language modes.
14822 * Composition Basics::
14823 * Horizontal Compositions::
14824 * Vertical Compositions::
14825 * Other Compositions::
14826 * Information about Compositions::
14827 * User-Defined Compositions::
14830 @node Composition Basics, Horizontal Compositions, Compositions, Compositions
14831 @subsubsection Composition Basics
14834 Compositions are generally formed by stacking formulas together
14835 horizontally or vertically in various ways. Those formulas are
14836 themselves compositions. @TeX{} users will find this analogous
14837 to @TeX{}'s ``boxes.'' Each multi-line composition has a
14838 @dfn{baseline}; horizontal compositions use the baselines to
14839 decide how formulas should be positioned relative to one another.
14840 For example, in the Big mode formula
14852 the second term of the sum is four lines tall and has line three as
14853 its baseline. Thus when the term is combined with 17, line three
14854 is placed on the same level as the baseline of 17.
14860 Another important composition concept is @dfn{precedence}. This is
14861 an integer that represents the binding strength of various operators.
14862 For example, @samp{*} has higher precedence (195) than @samp{+} (180),
14863 which means that @samp{(a * b) + c} will be formatted without the
14864 parentheses, but @samp{a * (b + c)} will keep the parentheses.
14866 The operator table used by normal and Big language modes has the
14867 following precedences:
14870 _ 1200 @r{(subscripts)}
14871 % 1100 @r{(as in n}%@r{)}
14872 ! 1000 @r{(as in }!@r{n)}
14875 !! 210 @r{(as in n}!!@r{)}
14876 ! 210 @r{(as in n}!@r{)}
14878 - 197 @r{(as in }-@r{n)}
14879 * 195 @r{(or implicit multiplication)}
14881 + - 180 @r{(as in a}+@r{b)}
14883 < = 160 @r{(and other relations)}
14895 The general rule is that if an operator with precedence @expr{n}
14896 occurs as an argument to an operator with precedence @expr{m}, then
14897 the argument is enclosed in parentheses if @expr{n < m}. Top-level
14898 expressions and expressions which are function arguments, vector
14899 components, etc., are formatted with precedence zero (so that they
14900 normally never get additional parentheses).
14902 For binary left-associative operators like @samp{+}, the righthand
14903 argument is actually formatted with one-higher precedence than shown
14904 in the table. This makes sure @samp{(a + b) + c} omits the parentheses,
14905 but the unnatural form @samp{a + (b + c)} keeps its parentheses.
14906 Right-associative operators like @samp{^} format the lefthand argument
14907 with one-higher precedence.
14913 The @code{cprec} function formats an expression with an arbitrary
14914 precedence. For example, @samp{cprec(abc, 185)} will combine into
14915 sums and products as follows: @samp{7 + abc}, @samp{7 (abc)} (because
14916 this @code{cprec} form has higher precedence than addition, but lower
14917 precedence than multiplication).
14923 A final composition issue is @dfn{line breaking}. Calc uses two
14924 different strategies for ``flat'' and ``non-flat'' compositions.
14925 A non-flat composition is anything that appears on multiple lines
14926 (not counting line breaking). Examples would be matrices and Big
14927 mode powers and quotients. Non-flat compositions are displayed
14928 exactly as specified. If they come out wider than the current
14929 window, you must use horizontal scrolling (@kbd{<} and @kbd{>}) to
14932 Flat compositions, on the other hand, will be broken across several
14933 lines if they are too wide to fit the window. Certain points in a
14934 composition are noted internally as @dfn{break points}. Calc's
14935 general strategy is to fill each line as much as possible, then to
14936 move down to the next line starting at the first break point that
14937 didn't fit. However, the line breaker understands the hierarchical
14938 structure of formulas. It will not break an ``inner'' formula if
14939 it can use an earlier break point from an ``outer'' formula instead.
14940 For example, a vector of sums might be formatted as:
14944 [ a + b + c, d + e + f,
14945 g + h + i, j + k + l, m ]
14950 If the @samp{m} can fit, then so, it seems, could the @samp{g}.
14951 But Calc prefers to break at the comma since the comma is part
14952 of a ``more outer'' formula. Calc would break at a plus sign
14953 only if it had to, say, if the very first sum in the vector had
14954 itself been too large to fit.
14956 Of the composition functions described below, only @code{choriz}
14957 generates break points. The @code{bstring} function (@pxref{Strings})
14958 also generates breakable items: A break point is added after every
14959 space (or group of spaces) except for spaces at the very beginning or
14962 Composition functions themselves count as levels in the formula
14963 hierarchy, so a @code{choriz} that is a component of a larger
14964 @code{choriz} will be less likely to be broken. As a special case,
14965 if a @code{bstring} occurs as a component of a @code{choriz} or
14966 @code{choriz}-like object (such as a vector or a list of arguments
14967 in a function call), then the break points in that @code{bstring}
14968 will be on the same level as the break points of the surrounding
14971 @node Horizontal Compositions, Vertical Compositions, Composition Basics, Compositions
14972 @subsubsection Horizontal Compositions
14979 The @code{choriz} function takes a vector of objects and composes
14980 them horizontally. For example, @samp{choriz([17, a b/c, d])} formats
14981 as @w{@samp{17a b / cd}} in Normal language mode, or as
14992 in Big language mode. This is actually one case of the general
14993 function @samp{choriz(@var{vec}, @var{sep}, @var{prec})}, where
14994 either or both of @var{sep} and @var{prec} may be omitted.
14995 @var{Prec} gives the @dfn{precedence} to use when formatting
14996 each of the components of @var{vec}. The default precedence is
14997 the precedence from the surrounding environment.
14999 @var{Sep} is a string (i.e., a vector of character codes as might
15000 be entered with @code{" "} notation) which should separate components
15001 of the composition. Also, if @var{sep} is given, the line breaker
15002 will allow lines to be broken after each occurrence of @var{sep}.
15003 If @var{sep} is omitted, the composition will not be breakable
15004 (unless any of its component compositions are breakable).
15006 For example, @samp{2 choriz([a, b c, d = e], " + ", 180)} is
15007 formatted as @samp{2 a + b c + (d = e)}. To get the @code{choriz}
15008 to have precedence 180 ``outwards'' as well as ``inwards,''
15009 enclose it in a @code{cprec} form: @samp{2 cprec(choriz(...), 180)}
15010 formats as @samp{2 (a + b c + (d = e))}.
15012 The baseline of a horizontal composition is the same as the
15013 baselines of the component compositions, which are all aligned.
15015 @node Vertical Compositions, Other Compositions, Horizontal Compositions, Compositions
15016 @subsubsection Vertical Compositions
15023 The @code{cvert} function makes a vertical composition. Each
15024 component of the vector is centered in a column. The baseline of
15025 the result is by default the top line of the resulting composition.
15026 For example, @samp{f(cvert([a, bb, ccc]), cvert([a^2 + 1, b^2]))}
15027 formats in Big mode as
15042 There are several special composition functions that work only as
15043 components of a vertical composition. The @code{cbase} function
15044 controls the baseline of the vertical composition; the baseline
15045 will be the same as the baseline of whatever component is enclosed
15046 in @code{cbase}. Thus @samp{f(cvert([a, cbase(bb), ccc]),
15047 cvert([a^2 + 1, cbase(b^2)]))} displays as
15067 There are also @code{ctbase} and @code{cbbase} functions which
15068 make the baseline of the vertical composition equal to the top
15069 or bottom line (rather than the baseline) of that component.
15070 Thus @samp{cvert([cbase(a / b)]) + cvert([ctbase(a / b)]) +
15071 cvert([cbbase(a / b)])} gives
15083 There should be only one @code{cbase}, @code{ctbase}, or @code{cbbase}
15084 function in a given vertical composition. These functions can also
15085 be written with no arguments: @samp{ctbase()} is a zero-height object
15086 which means the baseline is the top line of the following item, and
15087 @samp{cbbase()} means the baseline is the bottom line of the preceding
15094 The @code{crule} function builds a ``rule,'' or horizontal line,
15095 across a vertical composition. By itself @samp{crule()} uses @samp{-}
15096 characters to build the rule. You can specify any other character,
15097 e.g., @samp{crule("=")}. The argument must be a character code or
15098 vector of exactly one character code. It is repeated to match the
15099 width of the widest item in the stack. For example, a quotient
15100 with a thick line is @samp{cvert([a + 1, cbase(crule("=")), b^2])}:
15119 Finally, the functions @code{clvert} and @code{crvert} act exactly
15120 like @code{cvert} except that the items are left- or right-justified
15121 in the stack. Thus @samp{clvert([a, bb, ccc]) + crvert([a, bb, ccc])}
15132 Like @code{choriz}, the vertical compositions accept a second argument
15133 which gives the precedence to use when formatting the components.
15134 Vertical compositions do not support separator strings.
15136 @node Other Compositions, Information about Compositions, Vertical Compositions, Compositions
15137 @subsubsection Other Compositions
15144 The @code{csup} function builds a superscripted expression. For
15145 example, @samp{csup(a, b)} looks the same as @samp{a^b} does in Big
15146 language mode. This is essentially a horizontal composition of
15147 @samp{a} and @samp{b}, where @samp{b} is shifted up so that its
15148 bottom line is one above the baseline.
15154 Likewise, the @code{csub} function builds a subscripted expression.
15155 This shifts @samp{b} down so that its top line is one below the
15156 bottom line of @samp{a} (note that this is not quite analogous to
15157 @code{csup}). Other arrangements can be obtained by using
15158 @code{choriz} and @code{cvert} directly.
15164 The @code{cflat} function formats its argument in ``flat'' mode,
15165 as obtained by @samp{d O}, if the current language mode is normal
15166 or Big. It has no effect in other language modes. For example,
15167 @samp{a^(b/c)} is formatted by Big mode like @samp{csup(a, cflat(b/c))}
15168 to improve its readability.
15174 The @code{cspace} function creates horizontal space. For example,
15175 @samp{cspace(4)} is effectively the same as @samp{string(" ")}.
15176 A second string (i.e., vector of characters) argument is repeated
15177 instead of the space character. For example, @samp{cspace(4, "ab")}
15178 looks like @samp{abababab}. If the second argument is not a string,
15179 it is formatted in the normal way and then several copies of that
15180 are composed together: @samp{cspace(4, a^2)} yields
15190 If the number argument is zero, this is a zero-width object.
15196 The @code{cvspace} function creates vertical space, or a vertical
15197 stack of copies of a certain string or formatted object. The
15198 baseline is the center line of the resulting stack. A numerical
15199 argument of zero will produce an object which contributes zero
15200 height if used in a vertical composition.
15210 There are also @code{ctspace} and @code{cbspace} functions which
15211 create vertical space with the baseline the same as the baseline
15212 of the top or bottom copy, respectively, of the second argument.
15213 Thus @samp{cvspace(2, a/b) + ctspace(2, a/b) + cbspace(2, a/b)}
15230 @node Information about Compositions, User-Defined Compositions, Other Compositions, Compositions
15231 @subsubsection Information about Compositions
15234 The functions in this section are actual functions; they compose their
15235 arguments according to the current language and other display modes,
15236 then return a certain measurement of the composition as an integer.
15242 The @code{cwidth} function measures the width, in characters, of a
15243 composition. For example, @samp{cwidth(a + b)} is 5, and
15244 @samp{cwidth(a / b)} is 5 in Normal mode, 1 in Big mode, and 11 in
15245 @TeX{} mode (for @samp{@{a \over b@}}). The argument may involve
15246 the composition functions described in this section.
15252 The @code{cheight} function measures the height of a composition.
15253 This is the total number of lines in the argument's printed form.
15263 The functions @code{cascent} and @code{cdescent} measure the amount
15264 of the height that is above (and including) the baseline, or below
15265 the baseline, respectively. Thus @samp{cascent(@var{x}) + cdescent(@var{x})}
15266 always equals @samp{cheight(@var{x})}. For a one-line formula like
15267 @samp{a + b}, @code{cascent} returns 1 and @code{cdescent} returns 0.
15268 For @samp{a / b} in Big mode, @code{cascent} returns 2 and @code{cdescent}
15269 returns 1. The only formula for which @code{cascent} will return zero
15270 is @samp{cvspace(0)} or equivalents.
15272 @node User-Defined Compositions, , Information about Compositions, Compositions
15273 @subsubsection User-Defined Compositions
15277 @pindex calc-user-define-composition
15278 The @kbd{Z C} (@code{calc-user-define-composition}) command lets you
15279 define the display format for any algebraic function. You provide a
15280 formula containing a certain number of argument variables on the stack.
15281 Any time Calc formats a call to the specified function in the current
15282 language mode and with that number of arguments, Calc effectively
15283 replaces the function call with that formula with the arguments
15286 Calc builds the default argument list by sorting all the variable names
15287 that appear in the formula into alphabetical order. You can edit this
15288 argument list before pressing @key{RET} if you wish. Any variables in
15289 the formula that do not appear in the argument list will be displayed
15290 literally; any arguments that do not appear in the formula will not
15291 affect the display at all.
15293 You can define formats for built-in functions, for functions you have
15294 defined with @kbd{Z F} (@pxref{Algebraic Definitions}), or for functions
15295 which have no definitions but are being used as purely syntactic objects.
15296 You can define different formats for each language mode, and for each
15297 number of arguments, using a succession of @kbd{Z C} commands. When
15298 Calc formats a function call, it first searches for a format defined
15299 for the current language mode (and number of arguments); if there is
15300 none, it uses the format defined for the Normal language mode. If
15301 neither format exists, Calc uses its built-in standard format for that
15302 function (usually just @samp{@var{func}(@var{args})}).
15304 If you execute @kbd{Z C} with the number 0 on the stack instead of a
15305 formula, any defined formats for the function in the current language
15306 mode will be removed. The function will revert to its standard format.
15308 For example, the default format for the binomial coefficient function
15309 @samp{choose(n, m)} in the Big language mode is
15320 You might prefer the notation,
15330 To define this notation, first make sure you are in Big mode,
15331 then put the formula
15334 choriz([cvert([cvspace(1), n]), C, cvert([cvspace(1), m])])
15338 on the stack and type @kbd{Z C}. Answer the first prompt with
15339 @code{choose}. The second prompt will be the default argument list
15340 of @samp{(C m n)}. Edit this list to be @samp{(n m)} and press
15341 @key{RET}. Now, try it out: For example, turn simplification
15342 off with @kbd{m O} and enter @samp{choose(a,b) + choose(7,3)}
15343 as an algebraic entry.
15352 As another example, let's define the usual notation for Stirling
15353 numbers of the first kind, @samp{stir1(n, m)}. This is just like
15354 the regular format for binomial coefficients but with square brackets
15355 instead of parentheses.
15358 choriz([string("["), cvert([n, cbase(cvspace(1)), m]), string("]")])
15361 Now type @kbd{Z C stir1 @key{RET}}, edit the argument list to
15362 @samp{(n m)}, and type @key{RET}.
15364 The formula provided to @kbd{Z C} usually will involve composition
15365 functions, but it doesn't have to. Putting the formula @samp{a + b + c}
15366 onto the stack and typing @kbd{Z C foo @key{RET} @key{RET}} would define
15367 the function @samp{foo(x,y,z)} to display like @samp{x + y + z}.
15368 This ``sum'' will act exactly like a real sum for all formatting
15369 purposes (it will be parenthesized the same, and so on). However
15370 it will be computationally unrelated to a sum. For example, the
15371 formula @samp{2 * foo(1, 2, 3)} will display as @samp{2 (1 + 2 + 3)}.
15372 Operator precedences have caused the ``sum'' to be written in
15373 parentheses, but the arguments have not actually been summed.
15374 (Generally a display format like this would be undesirable, since
15375 it can easily be confused with a real sum.)
15377 The special function @code{eval} can be used inside a @kbd{Z C}
15378 composition formula to cause all or part of the formula to be
15379 evaluated at display time. For example, if the formula is
15380 @samp{a + eval(b + c)}, then @samp{foo(1, 2, 3)} will be displayed
15381 as @samp{1 + 5}. Evaluation will use the default simplifications,
15382 regardless of the current simplification mode. There are also
15383 @code{evalsimp} and @code{evalextsimp} which simplify as if by
15384 @kbd{a s} and @kbd{a e} (respectively). Note that these ``functions''
15385 operate only in the context of composition formulas (and also in
15386 rewrite rules, where they serve a similar purpose; @pxref{Rewrite
15387 Rules}). On the stack, a call to @code{eval} will be left in
15390 It is not a good idea to use @code{eval} except as a last resort.
15391 It can cause the display of formulas to be extremely slow. For
15392 example, while @samp{eval(a + b)} might seem quite fast and simple,
15393 there are several situations where it could be slow. For example,
15394 @samp{a} and/or @samp{b} could be polar complex numbers, in which
15395 case doing the sum requires trigonometry. Or, @samp{a} could be
15396 the factorial @samp{fact(100)} which is unevaluated because you
15397 have typed @kbd{m O}; @code{eval} will evaluate it anyway to
15398 produce a large, unwieldy integer.
15400 You can save your display formats permanently using the @kbd{Z P}
15401 command (@pxref{Creating User Keys}).
15403 @node Syntax Tables, , Compositions, Language Modes
15404 @subsection Syntax Tables
15407 @cindex Syntax tables
15408 @cindex Parsing formulas, customized
15409 Syntax tables do for input what compositions do for output: They
15410 allow you to teach custom notations to Calc's formula parser.
15411 Calc keeps a separate syntax table for each language mode.
15413 (Note that the Calc ``syntax tables'' discussed here are completely
15414 unrelated to the syntax tables described in the Emacs manual.)
15417 @pindex calc-edit-user-syntax
15418 The @kbd{Z S} (@code{calc-edit-user-syntax}) command edits the
15419 syntax table for the current language mode. If you want your
15420 syntax to work in any language, define it in the Normal language
15421 mode. Type @kbd{C-c C-c} to finish editing the syntax table, or
15422 @kbd{C-x k} to cancel the edit. The @kbd{m m} command saves all
15423 the syntax tables along with the other mode settings;
15424 @pxref{General Mode Commands}.
15427 * Syntax Table Basics::
15428 * Precedence in Syntax Tables::
15429 * Advanced Syntax Patterns::
15430 * Conditional Syntax Rules::
15433 @node Syntax Table Basics, Precedence in Syntax Tables, Syntax Tables, Syntax Tables
15434 @subsubsection Syntax Table Basics
15437 @dfn{Parsing} is the process of converting a raw string of characters,
15438 such as you would type in during algebraic entry, into a Calc formula.
15439 Calc's parser works in two stages. First, the input is broken down
15440 into @dfn{tokens}, such as words, numbers, and punctuation symbols
15441 like @samp{+}, @samp{:=}, and @samp{+/-}. Space between tokens is
15442 ignored (except when it serves to separate adjacent words). Next,
15443 the parser matches this string of tokens against various built-in
15444 syntactic patterns, such as ``an expression followed by @samp{+}
15445 followed by another expression'' or ``a name followed by @samp{(},
15446 zero or more expressions separated by commas, and @samp{)}.''
15448 A @dfn{syntax table} is a list of user-defined @dfn{syntax rules},
15449 which allow you to specify new patterns to define your own
15450 favorite input notations. Calc's parser always checks the syntax
15451 table for the current language mode, then the table for the Normal
15452 language mode, before it uses its built-in rules to parse an
15453 algebraic formula you have entered. Each syntax rule should go on
15454 its own line; it consists of a @dfn{pattern}, a @samp{:=} symbol,
15455 and a Calc formula with an optional @dfn{condition}. (Syntax rules
15456 resemble algebraic rewrite rules, but the notation for patterns is
15457 completely different.)
15459 A syntax pattern is a list of tokens, separated by spaces.
15460 Except for a few special symbols, tokens in syntax patterns are
15461 matched literally, from left to right. For example, the rule,
15468 would cause Calc to parse the formula @samp{4+foo()*5} as if it
15469 were @samp{4+(2+3)*5}. Notice that the parentheses were written
15470 as two separate tokens in the rule. As a result, the rule works
15471 for both @samp{foo()} and @w{@samp{foo ( )}}. If we had written
15472 the rule as @samp{foo () := 2+3}, then Calc would treat @samp{()}
15473 as a single, indivisible token, so that @w{@samp{foo( )}} would
15474 not be recognized by the rule. (It would be parsed as a regular
15475 zero-argument function call instead.) In fact, this rule would
15476 also make trouble for the rest of Calc's parser: An unrelated
15477 formula like @samp{bar()} would now be tokenized into @samp{bar ()}
15478 instead of @samp{bar ( )}, so that the standard parser for function
15479 calls would no longer recognize it!
15481 While it is possible to make a token with a mixture of letters
15482 and punctuation symbols, this is not recommended. It is better to
15483 break it into several tokens, as we did with @samp{foo()} above.
15485 The symbol @samp{#} in a syntax pattern matches any Calc expression.
15486 On the righthand side, the things that matched the @samp{#}s can
15487 be referred to as @samp{#1}, @samp{#2}, and so on (where @samp{#1}
15488 matches the leftmost @samp{#} in the pattern). For example, these
15489 rules match a user-defined function, prefix operator, infix operator,
15490 and postfix operator, respectively:
15493 foo ( # ) := myfunc(#1)
15494 foo # := myprefix(#1)
15495 # foo # := myinfix(#1,#2)
15496 # foo := mypostfix(#1)
15499 Thus @samp{foo(3)} will parse as @samp{myfunc(3)}, and @samp{2+3 foo}
15500 will parse as @samp{mypostfix(2+3)}.
15502 It is important to write the first two rules in the order shown,
15503 because Calc tries rules in order from first to last. If the
15504 pattern @samp{foo #} came first, it would match anything that could
15505 match the @samp{foo ( # )} rule, since an expression in parentheses
15506 is itself a valid expression. Thus the @w{@samp{foo ( # )}} rule would
15507 never get to match anything. Likewise, the last two rules must be
15508 written in the order shown or else @samp{3 foo 4} will be parsed as
15509 @samp{mypostfix(3) * 4}. (Of course, the best way to avoid these
15510 ambiguities is not to use the same symbol in more than one way at
15511 the same time! In case you're not convinced, try the following
15512 exercise: How will the above rules parse the input @samp{foo(3,4)},
15513 if at all? Work it out for yourself, then try it in Calc and see.)
15515 Calc is quite flexible about what sorts of patterns are allowed.
15516 The only rule is that every pattern must begin with a literal
15517 token (like @samp{foo} in the first two patterns above), or with
15518 a @samp{#} followed by a literal token (as in the last two
15519 patterns). After that, any mixture is allowed, although putting
15520 two @samp{#}s in a row will not be very useful since two
15521 expressions with nothing between them will be parsed as one
15522 expression that uses implicit multiplication.
15524 As a more practical example, Maple uses the notation
15525 @samp{sum(a(i), i=1..10)} for sums, which Calc's Maple mode doesn't
15526 recognize at present. To handle this syntax, we simply add the
15530 sum ( # , # = # .. # ) := sum(#1,#2,#3,#4)
15534 to the Maple mode syntax table. As another example, C mode can't
15535 read assignment operators like @samp{++} and @samp{*=}. We can
15536 define these operators quite easily:
15539 # *= # := muleq(#1,#2)
15540 # ++ := postinc(#1)
15545 To complete the job, we would use corresponding composition functions
15546 and @kbd{Z C} to cause these functions to display in their respective
15547 Maple and C notations. (Note that the C example ignores issues of
15548 operator precedence, which are discussed in the next section.)
15550 You can enclose any token in quotes to prevent its usual
15551 interpretation in syntax patterns:
15554 # ":=" # := becomes(#1,#2)
15557 Quotes also allow you to include spaces in a token, although once
15558 again it is generally better to use two tokens than one token with
15559 an embedded space. To include an actual quotation mark in a quoted
15560 token, precede it with a backslash. (This also works to include
15561 backslashes in tokens.)
15564 # "bad token" # "/\"\\" # := silly(#1,#2,#3)
15568 This will parse @samp{3 bad token 4 /"\ 5} to @samp{silly(3,4,5)}.
15570 The token @kbd{#} has a predefined meaning in Calc's formula parser;
15571 it is not valid to use @samp{"#"} in a syntax rule. However, longer
15572 tokens that include the @samp{#} character are allowed. Also, while
15573 @samp{"$"} and @samp{"\""} are allowed as tokens, their presence in
15574 the syntax table will prevent those characters from working in their
15575 usual ways (referring to stack entries and quoting strings,
15578 Finally, the notation @samp{%%} anywhere in a syntax table causes
15579 the rest of the line to be ignored as a comment.
15581 @node Precedence in Syntax Tables, Advanced Syntax Patterns, Syntax Table Basics, Syntax Tables
15582 @subsubsection Precedence
15585 Different operators are generally assigned different @dfn{precedences}.
15586 By default, an operator defined by a rule like
15589 # foo # := foo(#1,#2)
15593 will have an extremely low precedence, so that @samp{2*3+4 foo 5 == 6}
15594 will be parsed as @samp{(2*3+4) foo (5 == 6)}. To change the
15595 precedence of an operator, use the notation @samp{#/@var{p}} in
15596 place of @samp{#}, where @var{p} is an integer precedence level.
15597 For example, 185 lies between the precedences for @samp{+} and
15598 @samp{*}, so if we change this rule to
15601 #/185 foo #/186 := foo(#1,#2)
15605 then @samp{2+3 foo 4*5} will be parsed as @samp{2+(3 foo (4*5))}.
15606 Also, because we've given the righthand expression slightly higher
15607 precedence, our new operator will be left-associative:
15608 @samp{1 foo 2 foo 3} will be parsed as @samp{(1 foo 2) foo 3}.
15609 By raising the precedence of the lefthand expression instead, we
15610 can create a right-associative operator.
15612 @xref{Composition Basics}, for a table of precedences of the
15613 standard Calc operators. For the precedences of operators in other
15614 language modes, look in the Calc source file @file{calc-lang.el}.
15616 @node Advanced Syntax Patterns, Conditional Syntax Rules, Precedence in Syntax Tables, Syntax Tables
15617 @subsubsection Advanced Syntax Patterns
15620 To match a function with a variable number of arguments, you could
15624 foo ( # ) := myfunc(#1)
15625 foo ( # , # ) := myfunc(#1,#2)
15626 foo ( # , # , # ) := myfunc(#1,#2,#3)
15630 but this isn't very elegant. To match variable numbers of items,
15631 Calc uses some notations inspired regular expressions and the
15632 ``extended BNF'' style used by some language designers.
15635 foo ( @{ # @}*, ) := apply(myfunc,#1)
15638 The token @samp{@{} introduces a repeated or optional portion.
15639 One of the three tokens @samp{@}*}, @samp{@}+}, or @samp{@}?}
15640 ends the portion. These will match zero or more, one or more,
15641 or zero or one copies of the enclosed pattern, respectively.
15642 In addition, @samp{@}*} and @samp{@}+} can be followed by a
15643 separator token (with no space in between, as shown above).
15644 Thus @samp{@{ # @}*,} matches nothing, or one expression, or
15645 several expressions separated by commas.
15647 A complete @samp{@{ ... @}} item matches as a vector of the
15648 items that matched inside it. For example, the above rule will
15649 match @samp{foo(1,2,3)} to get @samp{apply(myfunc,[1,2,3])}.
15650 The Calc @code{apply} function takes a function name and a vector
15651 of arguments and builds a call to the function with those
15652 arguments, so the net result is the formula @samp{myfunc(1,2,3)}.
15654 If the body of a @samp{@{ ... @}} contains several @samp{#}s
15655 (or nested @samp{@{ ... @}} constructs), then the items will be
15656 strung together into the resulting vector. If the body
15657 does not contain anything but literal tokens, the result will
15658 always be an empty vector.
15661 foo ( @{ # , # @}+, ) := bar(#1)
15662 foo ( @{ @{ # @}*, @}*; ) := matrix(#1)
15666 will parse @samp{foo(1, 2, 3, 4)} as @samp{bar([1, 2, 3, 4])}, and
15667 @samp{foo(1, 2; 3, 4)} as @samp{matrix([[1, 2], [3, 4]])}. Also, after
15668 some thought it's easy to see how this pair of rules will parse
15669 @samp{foo(1, 2, 3)} as @samp{matrix([[1, 2, 3]])}, since the first
15670 rule will only match an even number of arguments. The rule
15673 foo ( # @{ , # , # @}? ) := bar(#1,#2)
15677 will parse @samp{foo(2,3,4)} as @samp{bar(2,[3,4])}, and
15678 @samp{foo(2)} as @samp{bar(2,[])}.
15680 The notation @samp{@{ ... @}?.} (note the trailing period) works
15681 just the same as regular @samp{@{ ... @}?}, except that it does not
15682 count as an argument; the following two rules are equivalent:
15685 foo ( # , @{ also @}? # ) := bar(#1,#3)
15686 foo ( # , @{ also @}?. # ) := bar(#1,#2)
15690 Note that in the first case the optional text counts as @samp{#2},
15691 which will always be an empty vector, but in the second case no
15692 empty vector is produced.
15694 Another variant is @samp{@{ ... @}?$}, which means the body is
15695 optional only at the end of the input formula. All built-in syntax
15696 rules in Calc use this for closing delimiters, so that during
15697 algebraic entry you can type @kbd{[sqrt(2), sqrt(3 @key{RET}}, omitting
15698 the closing parenthesis and bracket. Calc does this automatically
15699 for trailing @samp{)}, @samp{]}, and @samp{>} tokens in syntax
15700 rules, but you can use @samp{@{ ... @}?$} explicitly to get
15701 this effect with any token (such as @samp{"@}"} or @samp{end}).
15702 Like @samp{@{ ... @}?.}, this notation does not count as an
15703 argument. Conversely, you can use quotes, as in @samp{")"}, to
15704 prevent a closing-delimiter token from being automatically treated
15707 Calc's parser does not have full backtracking, which means some
15708 patterns will not work as you might expect:
15711 foo ( @{ # , @}? # , # ) := bar(#1,#2,#3)
15715 Here we are trying to make the first argument optional, so that
15716 @samp{foo(2,3)} parses as @samp{bar([],2,3)}. Unfortunately, Calc
15717 first tries to match @samp{2,} against the optional part of the
15718 pattern, finds a match, and so goes ahead to match the rest of the
15719 pattern. Later on it will fail to match the second comma, but it
15720 doesn't know how to go back and try the other alternative at that
15721 point. One way to get around this would be to use two rules:
15724 foo ( # , # , # ) := bar([#1],#2,#3)
15725 foo ( # , # ) := bar([],#1,#2)
15728 More precisely, when Calc wants to match an optional or repeated
15729 part of a pattern, it scans forward attempting to match that part.
15730 If it reaches the end of the optional part without failing, it
15731 ``finalizes'' its choice and proceeds. If it fails, though, it
15732 backs up and tries the other alternative. Thus Calc has ``partial''
15733 backtracking. A fully backtracking parser would go on to make sure
15734 the rest of the pattern matched before finalizing the choice.
15736 @node Conditional Syntax Rules, , Advanced Syntax Patterns, Syntax Tables
15737 @subsubsection Conditional Syntax Rules
15740 It is possible to attach a @dfn{condition} to a syntax rule. For
15744 foo ( # ) := ifoo(#1) :: integer(#1)
15745 foo ( # ) := gfoo(#1)
15749 will parse @samp{foo(3)} as @samp{ifoo(3)}, but will parse
15750 @samp{foo(3.5)} and @samp{foo(x)} as calls to @code{gfoo}. Any
15751 number of conditions may be attached; all must be true for the
15752 rule to succeed. A condition is ``true'' if it evaluates to a
15753 nonzero number. @xref{Logical Operations}, for a list of Calc
15754 functions like @code{integer} that perform logical tests.
15756 The exact sequence of events is as follows: When Calc tries a
15757 rule, it first matches the pattern as usual. It then substitutes
15758 @samp{#1}, @samp{#2}, etc., in the conditions, if any. Next, the
15759 conditions are simplified and evaluated in order from left to right,
15760 using the algebraic simplifications (@pxref{Simplifying Formulas}).
15761 Each result is true if it is a nonzero number, or an expression
15762 that can be proven to be nonzero (@pxref{Declarations}). If the
15763 results of all conditions are true, the expression (such as
15764 @samp{ifoo(#1)}) has its @samp{#}s substituted, and that is the
15765 result of the parse. If the result of any condition is false, Calc
15766 goes on to try the next rule in the syntax table.
15768 Syntax rules also support @code{let} conditions, which operate in
15769 exactly the same way as they do in algebraic rewrite rules.
15770 @xref{Other Features of Rewrite Rules}, for details. A @code{let}
15771 condition is always true, but as a side effect it defines a
15772 variable which can be used in later conditions, and also in the
15773 expression after the @samp{:=} sign:
15776 foo ( # ) := hifoo(x) :: let(x := #1 + 0.5) :: dnumint(x)
15780 The @code{dnumint} function tests if a value is numerically an
15781 integer, i.e., either a true integer or an integer-valued float.
15782 This rule will parse @code{foo} with a half-integer argument,
15783 like @samp{foo(3.5)}, to a call like @samp{hifoo(4.)}.
15785 The lefthand side of a syntax rule @code{let} must be a simple
15786 variable, not the arbitrary pattern that is allowed in rewrite
15789 The @code{matches} function is also treated specially in syntax
15790 rule conditions (again, in the same way as in rewrite rules).
15791 @xref{Matching Commands}. If the matching pattern contains
15792 meta-variables, then those meta-variables may be used in later
15793 conditions and in the result expression. The arguments to
15794 @code{matches} are not evaluated in this situation.
15797 sum ( # , # ) := sum(#1,a,b,c) :: matches(#2, a=[b..c])
15801 This is another way to implement the Maple mode @code{sum} notation.
15802 In this approach, we allow @samp{#2} to equal the whole expression
15803 @samp{i=1..10}. Then, we use @code{matches} to break it apart into
15804 its components. If the expression turns out not to match the pattern,
15805 the syntax rule will fail. Note that @kbd{Z S} always uses Calc's
15806 Normal language mode for editing expressions in syntax rules, so we
15807 must use regular Calc notation for the interval @samp{[b..c]} that
15808 will correspond to the Maple mode interval @samp{1..10}.
15810 @node Modes Variable, Calc Mode Line, Language Modes, Mode Settings
15811 @section The @code{Modes} Variable
15815 @pindex calc-get-modes
15816 The @kbd{m g} (@code{calc-get-modes}) command pushes onto the stack
15817 a vector of numbers that describes the various mode settings that
15818 are in effect. With a numeric prefix argument, it pushes only the
15819 @var{n}th mode, i.e., the @var{n}th element of this vector. Keyboard
15820 macros can use the @kbd{m g} command to modify their behavior based
15821 on the current mode settings.
15823 @cindex @code{Modes} variable
15825 The modes vector is also available in the special variable
15826 @code{Modes}. In other words, @kbd{m g} is like @kbd{s r Modes @key{RET}}.
15827 It will not work to store into this variable; in fact, if you do,
15828 @code{Modes} will cease to track the current modes. (The @kbd{m g}
15829 command will continue to work, however.)
15831 In general, each number in this vector is suitable as a numeric
15832 prefix argument to the associated mode-setting command. (Recall
15833 that the @kbd{~} key takes a number from the stack and gives it as
15834 a numeric prefix to the next command.)
15836 The elements of the modes vector are as follows:
15840 Current precision. Default is 12; associated command is @kbd{p}.
15843 Binary word size. Default is 32; associated command is @kbd{b w}.
15846 Stack size (not counting the value about to be pushed by @kbd{m g}).
15847 This is zero if @kbd{m g} is executed with an empty stack.
15850 Number radix. Default is 10; command is @kbd{d r}.
15853 Floating-point format. This is the number of digits, plus the
15854 constant 0 for normal notation, 10000 for scientific notation,
15855 20000 for engineering notation, or 30000 for fixed-point notation.
15856 These codes are acceptable as prefix arguments to the @kbd{d n}
15857 command, but note that this may lose information: For example,
15858 @kbd{d s} and @kbd{C-u 12 d s} have similar (but not quite
15859 identical) effects if the current precision is 12, but they both
15860 produce a code of 10012, which will be treated by @kbd{d n} as
15861 @kbd{C-u 12 d s}. If the precision then changes, the float format
15862 will still be frozen at 12 significant figures.
15865 Angular mode. Default is 1 (degrees). Other values are 2 (radians)
15866 and 3 (HMS). The @kbd{m d} command accepts these prefixes.
15869 Symbolic mode. Value is 0 or 1; default is 0. Command is @kbd{m s}.
15872 Fraction mode. Value is 0 or 1; default is 0. Command is @kbd{m f}.
15875 Polar mode. Value is 0 (rectangular) or 1 (polar); default is 0.
15876 Command is @kbd{m p}.
15879 Matrix/Scalar mode. Default value is @mathit{-1}. Value is 0 for Scalar
15880 mode, @mathit{-2} for Matrix mode, @mathit{-3} for square Matrix mode,
15882 @texline @math{N\times N}
15883 @infoline @var{N}x@var{N}
15884 Matrix mode. Command is @kbd{m v}.
15887 Simplification mode. Default is 1. Value is @mathit{-1} for off (@kbd{m O}),
15888 0 for @kbd{m N}, 2 for @kbd{m B}, 3 for @kbd{m A}, 4 for @kbd{m E},
15889 or 5 for @w{@kbd{m U}}. The @kbd{m D} command accepts these prefixes.
15892 Infinite mode. Default is @mathit{-1} (off). Value is 1 if the mode is on,
15893 or 0 if the mode is on with positive zeros. Command is @kbd{m i}.
15896 For example, the sequence @kbd{M-1 m g @key{RET} 2 + ~ p} increases the
15897 precision by two, leaving a copy of the old precision on the stack.
15898 Later, @kbd{~ p} will restore the original precision using that
15899 stack value. (This sequence might be especially useful inside a
15902 As another example, @kbd{M-3 m g 1 - ~ @key{DEL}} deletes all but the
15903 oldest (bottommost) stack entry.
15905 Yet another example: The HP-48 ``round'' command rounds a number
15906 to the current displayed precision. You could roughly emulate this
15907 in Calc with the sequence @kbd{M-5 m g 10000 % ~ c c}. (This
15908 would not work for fixed-point mode, but it wouldn't be hard to
15909 do a full emulation with the help of the @kbd{Z [} and @kbd{Z ]}
15910 programming commands. @xref{Conditionals in Macros}.)
15912 @node Calc Mode Line, , Modes Variable, Mode Settings
15913 @section The Calc Mode Line
15916 @cindex Mode line indicators
15917 This section is a summary of all symbols that can appear on the
15918 Calc mode line, the highlighted bar that appears under the Calc
15919 stack window (or under an editing window in Embedded mode).
15921 The basic mode line format is:
15924 --%*-Calc: 12 Deg @var{other modes} (Calculator)
15927 The @samp{%*} indicates that the buffer is ``read-only''; it shows that
15928 regular Emacs commands are not allowed to edit the stack buffer
15929 as if it were text.
15931 The word @samp{Calc:} changes to @samp{CalcEmbed:} if Embedded mode
15932 is enabled. The words after this describe the various Calc modes
15933 that are in effect.
15935 The first mode is always the current precision, an integer.
15936 The second mode is always the angular mode, either @code{Deg},
15937 @code{Rad}, or @code{Hms}.
15939 Here is a complete list of the remaining symbols that can appear
15944 Algebraic mode (@kbd{m a}; @pxref{Algebraic Entry}).
15947 Incomplete algebraic mode (@kbd{C-u m a}).
15950 Total algebraic mode (@kbd{m t}).
15953 Symbolic mode (@kbd{m s}; @pxref{Symbolic Mode}).
15956 Matrix mode (@kbd{m v}; @pxref{Matrix Mode}).
15958 @item Matrix@var{n}
15959 Dimensioned Matrix mode (@kbd{C-u @var{n} m v}; @pxref{Matrix Mode}).
15962 Square Matrix mode (@kbd{C-u m v}; @pxref{Matrix Mode}).
15965 Scalar mode (@kbd{m v}; @pxref{Matrix Mode}).
15968 Polar complex mode (@kbd{m p}; @pxref{Polar Mode}).
15971 Fraction mode (@kbd{m f}; @pxref{Fraction Mode}).
15974 Infinite mode (@kbd{m i}; @pxref{Infinite Mode}).
15977 Positive Infinite mode (@kbd{C-u 0 m i}).
15980 Default simplifications off (@kbd{m O}; @pxref{Simplification Modes}).
15983 Default simplifications for numeric arguments only (@kbd{m N}).
15985 @item BinSimp@var{w}
15986 Binary-integer simplification mode; word size @var{w} (@kbd{m B}, @kbd{b w}).
15989 Basic simplification mode (@kbd{m I}).
15992 Extended algebraic simplification mode (@kbd{m E}).
15995 Units simplification mode (@kbd{m U}).
15998 Current radix is 2 (@kbd{d 2}; @pxref{Radix Modes}).
16001 Current radix is 8 (@kbd{d 8}).
16004 Current radix is 16 (@kbd{d 6}).
16007 Current radix is @var{n} (@kbd{d r}).
16010 Leading zeros (@kbd{d z}; @pxref{Radix Modes}).
16013 Big language mode (@kbd{d B}; @pxref{Normal Language Modes}).
16016 One-line normal language mode (@kbd{d O}).
16019 Unformatted language mode (@kbd{d U}).
16022 C language mode (@kbd{d C}; @pxref{C FORTRAN Pascal}).
16025 Pascal language mode (@kbd{d P}).
16028 FORTRAN language mode (@kbd{d F}).
16031 @TeX{} language mode (@kbd{d T}; @pxref{TeX and LaTeX Language Modes}).
16034 @LaTeX{} language mode (@kbd{d L}; @pxref{TeX and LaTeX Language Modes}).
16037 @dfn{Eqn} language mode (@kbd{d E}; @pxref{Eqn Language Mode}).
16040 Mathematica language mode (@kbd{d M}; @pxref{Mathematica Language Mode}).
16043 Maple language mode (@kbd{d W}; @pxref{Maple Language Mode}).
16046 Normal float mode with @var{n} digits (@kbd{d n}; @pxref{Float Formats}).
16049 Fixed point mode with @var{n} digits after the point (@kbd{d f}).
16052 Scientific notation mode (@kbd{d s}).
16055 Scientific notation with @var{n} digits (@kbd{d s}).
16058 Engineering notation mode (@kbd{d e}).
16061 Engineering notation with @var{n} digits (@kbd{d e}).
16064 Left-justified display indented by @var{n} (@kbd{d <}; @pxref{Justification}).
16067 Right-justified display (@kbd{d >}).
16070 Right-justified display with width @var{n} (@kbd{d >}).
16073 Centered display (@kbd{d =}).
16075 @item Center@var{n}
16076 Centered display with center column @var{n} (@kbd{d =}).
16079 Line breaking with width @var{n} (@kbd{d b}; @pxref{Normal Language Modes}).
16082 No line breaking (@kbd{d b}).
16085 Selections show deep structure (@kbd{j b}; @pxref{Making Selections}).
16088 Record modes in @file{~/.emacs.d/calc.el} (@kbd{m R}; @pxref{General Mode Commands}).
16091 Record modes in Embedded buffer (@kbd{m R}).
16094 Record modes as editing-only in Embedded buffer (@kbd{m R}).
16097 Record modes as permanent-only in Embedded buffer (@kbd{m R}).
16100 Record modes as global in Embedded buffer (@kbd{m R}).
16103 Automatic recomputation turned off (@kbd{m C}; @pxref{Automatic
16107 GNUPLOT process is alive in background (@pxref{Graphics}).
16110 Top-of-stack has a selection (Embedded only; @pxref{Making Selections}).
16113 The stack display may not be up-to-date (@pxref{Display Modes}).
16116 ``Inverse'' prefix was pressed (@kbd{I}; @pxref{Inverse and Hyperbolic}).
16119 ``Hyperbolic'' prefix was pressed (@kbd{H}).
16122 ``Keep-arguments'' prefix was pressed (@kbd{K}).
16125 Stack is truncated (@kbd{d t}; @pxref{Truncating the Stack}).
16128 In addition, the symbols @code{Active} and @code{~Active} can appear
16129 as minor modes on an Embedded buffer's mode line. @xref{Embedded Mode}.
16131 @node Arithmetic, Scientific Functions, Mode Settings, Top
16132 @chapter Arithmetic Functions
16135 This chapter describes the Calc commands for doing simple calculations
16136 on numbers, such as addition, absolute value, and square roots. These
16137 commands work by removing the top one or two values from the stack,
16138 performing the desired operation, and pushing the result back onto the
16139 stack. If the operation cannot be performed, the result pushed is a
16140 formula instead of a number, such as @samp{2/0} (because division by zero
16141 is invalid) or @samp{sqrt(x)} (because the argument @samp{x} is a formula).
16143 Most of the commands described here can be invoked by a single keystroke.
16144 Some of the more obscure ones are two-letter sequences beginning with
16145 the @kbd{f} (``functions'') prefix key.
16147 @xref{Prefix Arguments}, for a discussion of the effect of numeric
16148 prefix arguments on commands in this chapter which do not otherwise
16149 interpret a prefix argument.
16152 * Basic Arithmetic::
16153 * Integer Truncation::
16154 * Complex Number Functions::
16156 * Date Arithmetic::
16157 * Financial Functions::
16158 * Binary Functions::
16161 @node Basic Arithmetic, Integer Truncation, Arithmetic, Arithmetic
16162 @section Basic Arithmetic
16171 The @kbd{+} (@code{calc-plus}) command adds two numbers. The numbers may
16172 be any of the standard Calc data types. The resulting sum is pushed back
16175 If both arguments of @kbd{+} are vectors or matrices (of matching dimensions),
16176 the result is a vector or matrix sum. If one argument is a vector and the
16177 other a scalar (i.e., a non-vector), the scalar is added to each of the
16178 elements of the vector to form a new vector. If the scalar is not a
16179 number, the operation is left in symbolic form: Suppose you added @samp{x}
16180 to the vector @samp{[1,2]}. You may want the result @samp{[1+x,2+x]}, or
16181 you may plan to substitute a 2-vector for @samp{x} in the future. Since
16182 the Calculator can't tell which interpretation you want, it makes the
16183 safest assumption. @xref{Reducing and Mapping}, for a way to add @samp{x}
16184 to every element of a vector.
16186 If either argument of @kbd{+} is a complex number, the result will in general
16187 be complex. If one argument is in rectangular form and the other polar,
16188 the current Polar mode determines the form of the result. If Symbolic
16189 mode is enabled, the sum may be left as a formula if the necessary
16190 conversions for polar addition are non-trivial.
16192 If both arguments of @kbd{+} are HMS forms, the forms are added according to
16193 the usual conventions of hours-minutes-seconds notation. If one argument
16194 is an HMS form and the other is a number, that number is converted from
16195 degrees or radians (depending on the current Angular mode) to HMS format
16196 and then the two HMS forms are added.
16198 If one argument of @kbd{+} is a date form, the other can be either a
16199 real number, which advances the date by a certain number of days, or
16200 an HMS form, which advances the date by a certain amount of time.
16201 Subtracting two date forms yields the number of days between them.
16202 Adding two date forms is meaningless, but Calc interprets it as the
16203 subtraction of one date form and the negative of the other. (The
16204 negative of a date form can be understood by remembering that dates
16205 are stored as the number of days before or after Jan 1, 1 AD.)
16207 If both arguments of @kbd{+} are error forms, the result is an error form
16208 with an appropriately computed standard deviation. If one argument is an
16209 error form and the other is a number, the number is taken to have zero error.
16210 Error forms may have symbolic formulas as their mean and/or error parts;
16211 adding these will produce a symbolic error form result. However, adding an
16212 error form to a plain symbolic formula (as in @samp{(a +/- b) + c}) will not
16213 work, for the same reasons just mentioned for vectors. Instead you must
16214 write @samp{(a +/- b) + (c +/- 0)}.
16216 If both arguments of @kbd{+} are modulo forms with equal values of @expr{M},
16217 or if one argument is a modulo form and the other a plain number, the
16218 result is a modulo form which represents the sum, modulo @expr{M}, of
16221 If both arguments of @kbd{+} are intervals, the result is an interval
16222 which describes all possible sums of the possible input values. If
16223 one argument is a plain number, it is treated as the interval
16224 @w{@samp{[x ..@: x]}}.
16226 If one argument of @kbd{+} is an infinity and the other is not, the
16227 result is that same infinity. If both arguments are infinite and in
16228 the same direction, the result is the same infinity, but if they are
16229 infinite in different directions the result is @code{nan}.
16237 The @kbd{-} (@code{calc-minus}) command subtracts two values. The top
16238 number on the stack is subtracted from the one behind it, so that the
16239 computation @kbd{5 @key{RET} 2 -} produces 3, not @mathit{-3}. All options
16240 available for @kbd{+} are available for @kbd{-} as well.
16248 The @kbd{*} (@code{calc-times}) command multiplies two numbers. If one
16249 argument is a vector and the other a scalar, the scalar is multiplied by
16250 the elements of the vector to produce a new vector. If both arguments
16251 are vectors, the interpretation depends on the dimensions of the
16252 vectors: If both arguments are matrices, a matrix multiplication is
16253 done. If one argument is a matrix and the other a plain vector, the
16254 vector is interpreted as a row vector or column vector, whichever is
16255 dimensionally correct. If both arguments are plain vectors, the result
16256 is a single scalar number which is the dot product of the two vectors.
16258 If one argument of @kbd{*} is an HMS form and the other a number, the
16259 HMS form is multiplied by that amount. It is an error to multiply two
16260 HMS forms together, or to attempt any multiplication involving date
16261 forms. Error forms, modulo forms, and intervals can be multiplied;
16262 see the comments for addition of those forms. When two error forms
16263 or intervals are multiplied they are considered to be statistically
16264 independent; thus, @samp{[-2 ..@: 3] * [-2 ..@: 3]} is @samp{[-6 ..@: 9]},
16265 whereas @w{@samp{[-2 ..@: 3] ^ 2}} is @samp{[0 ..@: 9]}.
16268 @pindex calc-divide
16273 The @kbd{/} (@code{calc-divide}) command divides two numbers.
16275 When combining multiplication and division in an algebraic formula, it
16276 is good style to use parentheses to distinguish between possible
16277 interpretations; the expression @samp{a/b*c} should be written
16278 @samp{(a/b)*c} or @samp{a/(b*c)}, as appropriate. Without the
16279 parentheses, Calc will interpret @samp{a/b*c} as @samp{a/(b*c)}, since
16280 in algebraic entry Calc gives division a lower precedence than
16281 multiplication. (This is not standard across all computer languages, and
16282 Calc may change the precedence depending on the language mode being used.
16283 @xref{Language Modes}.) This default ordering can be changed by setting
16284 the customizable variable @code{calc-multiplication-has-precedence} to
16285 @code{nil} (@pxref{Customizing Calc}); this will give multiplication and
16286 division equal precedences. Note that Calc's default choice of
16287 precedence allows @samp{a b / c d} to be used as a shortcut for
16296 When dividing a scalar @expr{B} by a square matrix @expr{A}, the
16297 computation performed is @expr{B} times the inverse of @expr{A}. This
16298 also occurs if @expr{B} is itself a vector or matrix, in which case the
16299 effect is to solve the set of linear equations represented by @expr{B}.
16300 If @expr{B} is a matrix with the same number of rows as @expr{A}, or a
16301 plain vector (which is interpreted here as a column vector), then the
16302 equation @expr{A X = B} is solved for the vector or matrix @expr{X}.
16303 Otherwise, if @expr{B} is a non-square matrix with the same number of
16304 @emph{columns} as @expr{A}, the equation @expr{X A = B} is solved. If
16305 you wish a vector @expr{B} to be interpreted as a row vector to be
16306 solved as @expr{X A = B}, make it into a one-row matrix with @kbd{C-u 1
16307 v p} first. To force a left-handed solution with a square matrix
16308 @expr{B}, transpose @expr{A} and @expr{B} before dividing, then
16309 transpose the result.
16311 HMS forms can be divided by real numbers or by other HMS forms. Error
16312 forms can be divided in any combination of ways. Modulo forms where both
16313 values and the modulo are integers can be divided to get an integer modulo
16314 form result. Intervals can be divided; dividing by an interval that
16315 encompasses zero or has zero as a limit will result in an infinite
16324 The @kbd{^} (@code{calc-power}) command raises a number to a power. If
16325 the power is an integer, an exact result is computed using repeated
16326 multiplications. For non-integer powers, Calc uses Newton's method or
16327 logarithms and exponentials. Square matrices can be raised to integer
16328 powers. If either argument is an error (or interval or modulo) form,
16329 the result is also an error (or interval or modulo) form.
16333 If you press the @kbd{I} (inverse) key first, the @kbd{I ^} command
16334 computes an Nth root: @kbd{125 @key{RET} 3 I ^} computes the number 5.
16335 (This is entirely equivalent to @kbd{125 @key{RET} 1:3 ^}.)
16344 The @kbd{\} (@code{calc-idiv}) command divides two numbers on the stack
16345 to produce an integer result. It is equivalent to dividing with
16346 @key{/}, then rounding down with @kbd{F} (@code{calc-floor}), only a bit
16347 more convenient and efficient. Also, since it is an all-integer
16348 operation when the arguments are integers, it avoids problems that
16349 @kbd{/ F} would have with floating-point roundoff.
16357 The @kbd{%} (@code{calc-mod}) command performs a ``modulo'' (or ``remainder'')
16358 operation. Mathematically, @samp{a%b = a - (a\b)*b}, and is defined
16359 for all real numbers @expr{a} and @expr{b} (except @expr{b=0}). For
16360 positive @expr{b}, the result will always be between 0 (inclusive) and
16361 @expr{b} (exclusive). Modulo does not work for HMS forms and error forms.
16362 If @expr{a} is a modulo form, its modulo is changed to @expr{b}, which
16363 must be positive real number.
16368 The @kbd{:} (@code{calc-fdiv}) [@code{fdiv}] command
16369 divides the two integers on the top of the stack to produce a fractional
16370 result. This is a convenient shorthand for enabling Fraction mode (with
16371 @kbd{m f}) temporarily and using @samp{/}. Note that during numeric entry
16372 the @kbd{:} key is interpreted as a fraction separator, so to divide 8 by 6
16373 you would have to type @kbd{8 @key{RET} 6 @key{RET} :}. (Of course, in
16374 this case, it would be much easier simply to enter the fraction directly
16375 as @kbd{8:6 @key{RET}}!)
16378 @pindex calc-change-sign
16379 The @kbd{n} (@code{calc-change-sign}) command negates the number on the top
16380 of the stack. It works on numbers, vectors and matrices, HMS forms, date
16381 forms, error forms, intervals, and modulo forms.
16386 The @kbd{A} (@code{calc-abs}) [@code{abs}] command computes the absolute
16387 value of a number. The result of @code{abs} is always a nonnegative
16388 real number: With a complex argument, it computes the complex magnitude.
16389 With a vector or matrix argument, it computes the Frobenius norm, i.e.,
16390 the square root of the sum of the squares of the absolute values of the
16391 elements. The absolute value of an error form is defined by replacing
16392 the mean part with its absolute value and leaving the error part the same.
16393 The absolute value of a modulo form is undefined. The absolute value of
16394 an interval is defined in the obvious way.
16397 @pindex calc-abssqr
16399 The @kbd{f A} (@code{calc-abssqr}) [@code{abssqr}] command computes the
16400 absolute value squared of a number, vector or matrix, or error form.
16405 The @kbd{f s} (@code{calc-sign}) [@code{sign}] command returns 1 if its
16406 argument is positive, @mathit{-1} if its argument is negative, or 0 if its
16407 argument is zero. In algebraic form, you can also write @samp{sign(a,x)}
16408 which evaluates to @samp{x * sign(a)}, i.e., either @samp{x}, @samp{-x}, or
16409 zero depending on the sign of @samp{a}.
16415 The @kbd{&} (@code{calc-inv}) [@code{inv}] command computes the
16416 reciprocal of a number, i.e., @expr{1 / x}. Operating on a square
16417 matrix, it computes the inverse of that matrix.
16422 The @kbd{Q} (@code{calc-sqrt}) [@code{sqrt}] command computes the square
16423 root of a number. For a negative real argument, the result will be a
16424 complex number whose form is determined by the current Polar mode.
16429 The @kbd{f h} (@code{calc-hypot}) [@code{hypot}] command computes the square
16430 root of the sum of the squares of two numbers. That is, @samp{hypot(a,b)}
16431 is the length of the hypotenuse of a right triangle with sides @expr{a}
16432 and @expr{b}. If the arguments are complex numbers, their squared
16433 magnitudes are used.
16438 The @kbd{f Q} (@code{calc-isqrt}) [@code{isqrt}] command computes the
16439 integer square root of an integer. This is the true square root of the
16440 number, rounded down to an integer. For example, @samp{isqrt(10)}
16441 produces 3. Note that, like @kbd{\} [@code{idiv}], this uses exact
16442 integer arithmetic throughout to avoid roundoff problems. If the input
16443 is a floating-point number or other non-integer value, this is exactly
16444 the same as @samp{floor(sqrt(x))}.
16452 The @kbd{f n} (@code{calc-min}) [@code{min}] and @kbd{f x} (@code{calc-max})
16453 [@code{max}] commands take the minimum or maximum of two real numbers,
16454 respectively. These commands also work on HMS forms, date forms,
16455 intervals, and infinities. (In algebraic expressions, these functions
16456 take any number of arguments and return the maximum or minimum among
16457 all the arguments.)
16461 @pindex calc-mant-part
16463 @pindex calc-xpon-part
16465 The @kbd{f M} (@code{calc-mant-part}) [@code{mant}] function extracts
16466 the ``mantissa'' part @expr{m} of its floating-point argument; @kbd{f X}
16467 (@code{calc-xpon-part}) [@code{xpon}] extracts the ``exponent'' part
16468 @expr{e}. The original number is equal to
16469 @texline @math{m \times 10^e},
16470 @infoline @expr{m * 10^e},
16471 where @expr{m} is in the interval @samp{[1.0 ..@: 10.0)} except that
16472 @expr{m=e=0} if the original number is zero. For integers
16473 and fractions, @code{mant} returns the number unchanged and @code{xpon}
16474 returns zero. The @kbd{v u} (@code{calc-unpack}) command can also be
16475 used to ``unpack'' a floating-point number; this produces an integer
16476 mantissa and exponent, with the constraint that the mantissa is not
16477 a multiple of ten (again except for the @expr{m=e=0} case).
16480 @pindex calc-scale-float
16482 The @kbd{f S} (@code{calc-scale-float}) [@code{scf}] function scales a number
16483 by a given power of ten. Thus, @samp{scf(mant(x), xpon(x)) = x} for any
16484 real @samp{x}. The second argument must be an integer, but the first
16485 may actually be any numeric value. For example, @samp{scf(5,-2) = 0.05}
16486 or @samp{1:20} depending on the current Fraction mode.
16490 @pindex calc-decrement
16491 @pindex calc-increment
16494 The @kbd{f [} (@code{calc-decrement}) [@code{decr}] and @kbd{f ]}
16495 (@code{calc-increment}) [@code{incr}] functions decrease or increase
16496 a number by one unit. For integers, the effect is obvious. For
16497 floating-point numbers, the change is by one unit in the last place.
16498 For example, incrementing @samp{12.3456} when the current precision
16499 is 6 digits yields @samp{12.3457}. If the current precision had been
16500 8 digits, the result would have been @samp{12.345601}. Incrementing
16501 @samp{0.0} produces
16502 @texline @math{10^{-p}},
16503 @infoline @expr{10^-p},
16504 where @expr{p} is the current
16505 precision. These operations are defined only on integers and floats.
16506 With numeric prefix arguments, they change the number by @expr{n} units.
16508 Note that incrementing followed by decrementing, or vice-versa, will
16509 almost but not quite always cancel out. Suppose the precision is
16510 6 digits and the number @samp{9.99999} is on the stack. Incrementing
16511 will produce @samp{10.0000}; decrementing will produce @samp{9.9999}.
16512 One digit has been dropped. This is an unavoidable consequence of the
16513 way floating-point numbers work.
16515 Incrementing a date/time form adjusts it by a certain number of seconds.
16516 Incrementing a pure date form adjusts it by a certain number of days.
16518 @node Integer Truncation, Complex Number Functions, Basic Arithmetic, Arithmetic
16519 @section Integer Truncation
16522 There are four commands for truncating a real number to an integer,
16523 differing mainly in their treatment of negative numbers. All of these
16524 commands have the property that if the argument is an integer, the result
16525 is the same integer. An integer-valued floating-point argument is converted
16528 If you press @kbd{H} (@code{calc-hyperbolic}) first, the result will be
16529 expressed as an integer-valued floating-point number.
16531 @cindex Integer part of a number
16540 The @kbd{F} (@code{calc-floor}) [@code{floor} or @code{ffloor}] command
16541 truncates a real number to the next lower integer, i.e., toward minus
16542 infinity. Thus @kbd{3.6 F} produces 3, but @kbd{_3.6 F} produces
16546 @pindex calc-ceiling
16553 The @kbd{I F} (@code{calc-ceiling}) [@code{ceil} or @code{fceil}]
16554 command truncates toward positive infinity. Thus @kbd{3.6 I F} produces
16555 4, and @kbd{_3.6 I F} produces @mathit{-3}.
16565 The @kbd{R} (@code{calc-round}) [@code{round} or @code{fround}] command
16566 rounds to the nearest integer. When the fractional part is .5 exactly,
16567 this command rounds away from zero. (All other rounding in the
16568 Calculator uses this convention as well.) Thus @kbd{3.5 R} produces 4
16569 but @kbd{3.4 R} produces 3; @kbd{_3.5 R} produces @mathit{-4}.
16579 The @kbd{I R} (@code{calc-trunc}) [@code{trunc} or @code{ftrunc}]
16580 command truncates toward zero. In other words, it ``chops off''
16581 everything after the decimal point. Thus @kbd{3.6 I R} produces 3 and
16582 @kbd{_3.6 I R} produces @mathit{-3}.
16584 These functions may not be applied meaningfully to error forms, but they
16585 do work for intervals. As a convenience, applying @code{floor} to a
16586 modulo form floors the value part of the form. Applied to a vector,
16587 these functions operate on all elements of the vector one by one.
16588 Applied to a date form, they operate on the internal numerical
16589 representation of dates, converting a date/time form into a pure date.
16607 There are two more rounding functions which can only be entered in
16608 algebraic notation. The @code{roundu} function is like @code{round}
16609 except that it rounds up, toward plus infinity, when the fractional
16610 part is .5. This distinction matters only for negative arguments.
16611 Also, @code{rounde} rounds to an even number in the case of a tie,
16612 rounding up or down as necessary. For example, @samp{rounde(3.5)} and
16613 @samp{rounde(4.5)} both return 4, but @samp{rounde(5.5)} returns 6.
16614 The advantage of round-to-even is that the net error due to rounding
16615 after a long calculation tends to cancel out to zero. An important
16616 subtle point here is that the number being fed to @code{rounde} will
16617 already have been rounded to the current precision before @code{rounde}
16618 begins. For example, @samp{rounde(2.500001)} with a current precision
16619 of 6 will incorrectly, or at least surprisingly, yield 2 because the
16620 argument will first have been rounded down to @expr{2.5} (which
16621 @code{rounde} sees as an exact tie between 2 and 3).
16623 Each of these functions, when written in algebraic formulas, allows
16624 a second argument which specifies the number of digits after the
16625 decimal point to keep. For example, @samp{round(123.4567, 2)} will
16626 produce the answer 123.46, and @samp{round(123.4567, -1)} will
16627 produce 120 (i.e., the cutoff is one digit to the @emph{left} of
16628 the decimal point). A second argument of zero is equivalent to
16629 no second argument at all.
16631 @cindex Fractional part of a number
16632 To compute the fractional part of a number (i.e., the amount which, when
16633 added to `@tfn{floor(}@var{n}@tfn{)}', will produce @var{n}) just take @var{n}
16634 modulo 1 using the @code{%} command.
16636 Note also the @kbd{\} (integer quotient), @kbd{f I} (integer logarithm),
16637 and @kbd{f Q} (integer square root) commands, which are analogous to
16638 @kbd{/}, @kbd{B}, and @kbd{Q}, respectively, except that they take integer
16639 arguments and return the result rounded down to an integer.
16641 @node Complex Number Functions, Conversions, Integer Truncation, Arithmetic
16642 @section Complex Number Functions
16648 The @kbd{J} (@code{calc-conj}) [@code{conj}] command computes the
16649 complex conjugate of a number. For complex number @expr{a+bi}, the
16650 complex conjugate is @expr{a-bi}. If the argument is a real number,
16651 this command leaves it the same. If the argument is a vector or matrix,
16652 this command replaces each element by its complex conjugate.
16655 @pindex calc-argument
16657 The @kbd{G} (@code{calc-argument}) [@code{arg}] command computes the
16658 ``argument'' or polar angle of a complex number. For a number in polar
16659 notation, this is simply the second component of the pair
16660 @texline `@tfn{(}@var{r}@tfn{;}@math{\theta}@tfn{)}'.
16661 @infoline `@tfn{(}@var{r}@tfn{;}@var{theta}@tfn{)}'.
16662 The result is expressed according to the current angular mode and will
16663 be in the range @mathit{-180} degrees (exclusive) to @mathit{+180} degrees
16664 (inclusive), or the equivalent range in radians.
16666 @pindex calc-imaginary
16667 The @code{calc-imaginary} command multiplies the number on the
16668 top of the stack by the imaginary number @expr{i = (0,1)}. This
16669 command is not normally bound to a key in Calc, but it is available
16670 on the @key{IMAG} button in Keypad mode.
16675 The @kbd{f r} (@code{calc-re}) [@code{re}] command replaces a complex number
16676 by its real part. This command has no effect on real numbers. (As an
16677 added convenience, @code{re} applied to a modulo form extracts
16683 The @kbd{f i} (@code{calc-im}) [@code{im}] command replaces a complex number
16684 by its imaginary part; real numbers are converted to zero. With a vector
16685 or matrix argument, these functions operate element-wise.
16690 @kindex v p (complex)
16691 @kindex V p (complex)
16693 The @kbd{v p} (@code{calc-pack}) command can pack the top two numbers on
16694 the stack into a composite object such as a complex number. With
16695 a prefix argument of @mathit{-1}, it produces a rectangular complex number;
16696 with an argument of @mathit{-2}, it produces a polar complex number.
16697 (Also, @pxref{Building Vectors}.)
16702 @kindex v u (complex)
16703 @kindex V u (complex)
16704 @pindex calc-unpack
16705 The @kbd{v u} (@code{calc-unpack}) command takes the complex number
16706 (or other composite object) on the top of the stack and unpacks it
16707 into its separate components.
16709 @node Conversions, Date Arithmetic, Complex Number Functions, Arithmetic
16710 @section Conversions
16713 The commands described in this section convert numbers from one form
16714 to another; they are two-key sequences beginning with the letter @kbd{c}.
16719 The @kbd{c f} (@code{calc-float}) [@code{pfloat}] command converts the
16720 number on the top of the stack to floating-point form. For example,
16721 @expr{23} is converted to @expr{23.0}, @expr{3:2} is converted to
16722 @expr{1.5}, and @expr{2.3} is left the same. If the value is a composite
16723 object such as a complex number or vector, each of the components is
16724 converted to floating-point. If the value is a formula, all numbers
16725 in the formula are converted to floating-point. Note that depending
16726 on the current floating-point precision, conversion to floating-point
16727 format may lose information.
16729 As a special exception, integers which appear as powers or subscripts
16730 are not floated by @kbd{c f}. If you really want to float a power,
16731 you can use a @kbd{j s} command to select the power followed by @kbd{c f}.
16732 Because @kbd{c f} cannot examine the formula outside of the selection,
16733 it does not notice that the thing being floated is a power.
16734 @xref{Selecting Subformulas}.
16736 The normal @kbd{c f} command is ``pervasive'' in the sense that it
16737 applies to all numbers throughout the formula. The @code{pfloat}
16738 algebraic function never stays around in a formula; @samp{pfloat(a + 1)}
16739 changes to @samp{a + 1.0} as soon as it is evaluated.
16743 With the Hyperbolic flag, @kbd{H c f} [@code{float}] operates
16744 only on the number or vector of numbers at the top level of its
16745 argument. Thus, @samp{float(1)} is 1.0, but @samp{float(a + 1)}
16746 is left unevaluated because its argument is not a number.
16748 You should use @kbd{H c f} if you wish to guarantee that the final
16749 value, once all the variables have been assigned, is a float; you
16750 would use @kbd{c f} if you wish to do the conversion on the numbers
16751 that appear right now.
16754 @pindex calc-fraction
16756 The @kbd{c F} (@code{calc-fraction}) [@code{pfrac}] command converts a
16757 floating-point number into a fractional approximation. By default, it
16758 produces a fraction whose decimal representation is the same as the
16759 input number, to within the current precision. You can also give a
16760 numeric prefix argument to specify a tolerance, either directly, or,
16761 if the prefix argument is zero, by using the number on top of the stack
16762 as the tolerance. If the tolerance is a positive integer, the fraction
16763 is correct to within that many significant figures. If the tolerance is
16764 a non-positive integer, it specifies how many digits fewer than the current
16765 precision to use. If the tolerance is a floating-point number, the
16766 fraction is correct to within that absolute amount.
16770 The @code{pfrac} function is pervasive, like @code{pfloat}.
16771 There is also a non-pervasive version, @kbd{H c F} [@code{frac}],
16772 which is analogous to @kbd{H c f} discussed above.
16775 @pindex calc-to-degrees
16777 The @kbd{c d} (@code{calc-to-degrees}) [@code{deg}] command converts a
16778 number into degrees form. The value on the top of the stack may be an
16779 HMS form (interpreted as degrees-minutes-seconds), or a real number which
16780 will be interpreted in radians regardless of the current angular mode.
16783 @pindex calc-to-radians
16785 The @kbd{c r} (@code{calc-to-radians}) [@code{rad}] command converts an
16786 HMS form or angle in degrees into an angle in radians.
16789 @pindex calc-to-hms
16791 The @kbd{c h} (@code{calc-to-hms}) [@code{hms}] command converts a real
16792 number, interpreted according to the current angular mode, to an HMS
16793 form describing the same angle. In algebraic notation, the @code{hms}
16794 function also accepts three arguments: @samp{hms(@var{h}, @var{m}, @var{s})}.
16795 (The three-argument version is independent of the current angular mode.)
16797 @pindex calc-from-hms
16798 The @code{calc-from-hms} command converts the HMS form on the top of the
16799 stack into a real number according to the current angular mode.
16806 The @kbd{c p} (@code{calc-polar}) command converts the complex number on
16807 the top of the stack from polar to rectangular form, or from rectangular
16808 to polar form, whichever is appropriate. Real numbers are left the same.
16809 This command is equivalent to the @code{rect} or @code{polar}
16810 functions in algebraic formulas, depending on the direction of
16811 conversion. (It uses @code{polar}, except that if the argument is
16812 already a polar complex number, it uses @code{rect} instead. The
16813 @kbd{I c p} command always uses @code{rect}.)
16818 The @kbd{c c} (@code{calc-clean}) [@code{pclean}] command ``cleans'' the
16819 number on the top of the stack. Floating point numbers are re-rounded
16820 according to the current precision. Polar numbers whose angular
16821 components have strayed from the @mathit{-180} to @mathit{+180} degree range
16822 are normalized. (Note that results will be undesirable if the current
16823 angular mode is different from the one under which the number was
16824 produced!) Integers and fractions are generally unaffected by this
16825 operation. Vectors and formulas are cleaned by cleaning each component
16826 number (i.e., pervasively).
16828 If the simplification mode is set below basic simplification, it is raised
16829 for the purposes of this command. Thus, @kbd{c c} applies the basic
16830 simplifications even if their automatic application is disabled.
16831 @xref{Simplification Modes}.
16833 @cindex Roundoff errors, correcting
16834 A numeric prefix argument to @kbd{c c} sets the floating-point precision
16835 to that value for the duration of the command. A positive prefix (of at
16836 least 3) sets the precision to the specified value; a negative or zero
16837 prefix decreases the precision by the specified amount.
16840 @pindex calc-clean-num
16841 The keystroke sequences @kbd{c 0} through @kbd{c 9} are equivalent
16842 to @kbd{c c} with the corresponding negative prefix argument. If roundoff
16843 errors have changed 2.0 into 1.999999, typing @kbd{c 1} to clip off one
16844 decimal place often conveniently does the trick.
16846 The @kbd{c c} command with a numeric prefix argument, and the @kbd{c 0}
16847 through @kbd{c 9} commands, also ``clip'' very small floating-point
16848 numbers to zero. If the exponent is less than or equal to the negative
16849 of the specified precision, the number is changed to 0.0. For example,
16850 if the current precision is 12, then @kbd{c 2} changes the vector
16851 @samp{[1e-8, 1e-9, 1e-10, 1e-11]} to @samp{[1e-8, 1e-9, 0, 0]}.
16852 Numbers this small generally arise from roundoff noise.
16854 If the numbers you are using really are legitimately this small,
16855 you should avoid using the @kbd{c 0} through @kbd{c 9} commands.
16856 (The plain @kbd{c c} command rounds to the current precision but
16857 does not clip small numbers.)
16859 One more property of @kbd{c 0} through @kbd{c 9}, and of @kbd{c c} with
16860 a prefix argument, is that integer-valued floats are converted to
16861 plain integers, so that @kbd{c 1} on @samp{[1., 1.5, 2., 2.5, 3.]}
16862 produces @samp{[1, 1.5, 2, 2.5, 3]}. This is not done for huge
16863 numbers (@samp{1e100} is technically an integer-valued float, but
16864 you wouldn't want it automatically converted to a 100-digit integer).
16869 With the Hyperbolic flag, @kbd{H c c} and @kbd{H c 0} through @kbd{H c 9}
16870 operate non-pervasively [@code{clean}].
16872 @node Date Arithmetic, Financial Functions, Conversions, Arithmetic
16873 @section Date Arithmetic
16876 @cindex Date arithmetic, additional functions
16877 The commands described in this section perform various conversions
16878 and calculations involving date forms (@pxref{Date Forms}). They
16879 use the @kbd{t} (for time/date) prefix key followed by shifted
16882 The simplest date arithmetic is done using the regular @kbd{+} and @kbd{-}
16883 commands. In particular, adding a number to a date form advances the
16884 date form by a certain number of days; adding an HMS form to a date
16885 form advances the date by a certain amount of time; and subtracting two
16886 date forms produces a difference measured in days. The commands
16887 described here provide additional, more specialized operations on dates.
16889 Many of these commands accept a numeric prefix argument; if you give
16890 plain @kbd{C-u} as the prefix, these commands will instead take the
16891 additional argument from the top of the stack.
16894 * Date Conversions::
16900 @node Date Conversions, Date Functions, Date Arithmetic, Date Arithmetic
16901 @subsection Date Conversions
16907 The @kbd{t D} (@code{calc-date}) [@code{date}] command converts a
16908 date form into a number, measured in days since Jan 1, 1 AD@. The
16909 result will be an integer if @var{date} is a pure date form, or a
16910 fraction or float if @var{date} is a date/time form. Or, if its
16911 argument is a number, it converts this number into a date form.
16913 With a numeric prefix argument, @kbd{t D} takes that many objects
16914 (up to six) from the top of the stack and interprets them in one
16915 of the following ways:
16917 The @samp{date(@var{year}, @var{month}, @var{day})} function
16918 builds a pure date form out of the specified year, month, and
16919 day, which must all be integers. @var{Year} is a year number,
16920 such as 1991 (@emph{not} the same as 91!). @var{Month} must be
16921 an integer in the range 1 to 12; @var{day} must be in the range
16922 1 to 31. If the specified month has fewer than 31 days and
16923 @var{day} is too large, the equivalent day in the following
16924 month will be used.
16926 The @samp{date(@var{month}, @var{day})} function builds a
16927 pure date form using the current year, as determined by the
16930 The @samp{date(@var{year}, @var{month}, @var{day}, @var{hms})}
16931 function builds a date/time form using an @var{hms} form.
16933 The @samp{date(@var{year}, @var{month}, @var{day}, @var{hour},
16934 @var{minute}, @var{second})} function builds a date/time form.
16935 @var{hour} should be an integer in the range 0 to 23;
16936 @var{minute} should be an integer in the range 0 to 59;
16937 @var{second} should be any real number in the range @samp{[0 .. 60)}.
16938 The last two arguments default to zero if omitted.
16941 @pindex calc-julian
16943 @cindex Julian day counts, conversions
16944 The @kbd{t J} (@code{calc-julian}) [@code{julian}] command converts
16945 a date form into a Julian day count, which is the number of days
16946 since noon (GMT) on Jan 1, 4713 BC@. A pure date is converted to an
16947 integer Julian count representing noon of that day. A date/time form
16948 is converted to an exact floating-point Julian count, adjusted to
16949 interpret the date form in the current time zone but the Julian
16950 day count in Greenwich Mean Time. A numeric prefix argument allows
16951 you to specify the time zone; @pxref{Time Zones}. Use a prefix of
16952 zero to suppress the time zone adjustment. Note that pure date forms
16953 are never time-zone adjusted.
16955 This command can also do the opposite conversion, from a Julian day
16956 count (either an integer day, or a floating-point day and time in
16957 the GMT zone), into a pure date form or a date/time form in the
16958 current or specified time zone.
16961 @pindex calc-unix-time
16963 @cindex Unix time format, conversions
16964 The @kbd{t U} (@code{calc-unix-time}) [@code{unixtime}] command
16965 converts a date form into a Unix time value, which is the number of
16966 seconds since midnight on Jan 1, 1970, or vice-versa. The numeric result
16967 will be an integer if the current precision is 12 or less; for higher
16968 precision, the result may be a float with (@var{precision}@minus{}12)
16969 digits after the decimal. Just as for @kbd{t J}, the numeric time
16970 is interpreted in the GMT time zone and the date form is interpreted
16971 in the current or specified zone. Some systems use Unix-like
16972 numbering but with the local time zone; give a prefix of zero to
16973 suppress the adjustment if so.
16976 @pindex calc-convert-time-zones
16978 @cindex Time Zones, converting between
16979 The @kbd{t C} (@code{calc-convert-time-zones}) [@code{tzconv}]
16980 command converts a date form from one time zone to another. You
16981 are prompted for each time zone name in turn; you can answer with
16982 any suitable Calc time zone expression (@pxref{Time Zones}).
16983 If you answer either prompt with a blank line, the local time
16984 zone is used for that prompt. You can also answer the first
16985 prompt with @kbd{$} to take the two time zone names from the
16986 stack (and the date to be converted from the third stack level).
16988 @node Date Functions, Business Days, Date Conversions, Date Arithmetic
16989 @subsection Date Functions
16995 The @kbd{t N} (@code{calc-now}) [@code{now}] command pushes the
16996 current date and time on the stack as a date form. The time is
16997 reported in terms of the specified time zone; with no numeric prefix
16998 argument, @kbd{t N} reports for the current time zone.
17001 @pindex calc-date-part
17002 The @kbd{t P} (@code{calc-date-part}) command extracts one part
17003 of a date form. The prefix argument specifies the part; with no
17004 argument, this command prompts for a part code from 1 to 9.
17005 The various part codes are described in the following paragraphs.
17008 The @kbd{M-1 t P} [@code{year}] function extracts the year number
17009 from a date form as an integer, e.g., 1991. This and the
17010 following functions will also accept a real number for an
17011 argument, which is interpreted as a standard Calc day number.
17012 Note that this function will never return zero, since the year
17013 1 BC immediately precedes the year 1 AD.
17016 The @kbd{M-2 t P} [@code{month}] function extracts the month number
17017 from a date form as an integer in the range 1 to 12.
17020 The @kbd{M-3 t P} [@code{day}] function extracts the day number
17021 from a date form as an integer in the range 1 to 31.
17024 The @kbd{M-4 t P} [@code{hour}] function extracts the hour from
17025 a date form as an integer in the range 0 (midnight) to 23. Note
17026 that 24-hour time is always used. This returns zero for a pure
17027 date form. This function (and the following two) also accept
17028 HMS forms as input.
17031 The @kbd{M-5 t P} [@code{minute}] function extracts the minute
17032 from a date form as an integer in the range 0 to 59.
17035 The @kbd{M-6 t P} [@code{second}] function extracts the second
17036 from a date form. If the current precision is 12 or less,
17037 the result is an integer in the range 0 to 59. For higher
17038 precision, the result may instead be a floating-point number.
17041 The @kbd{M-7 t P} [@code{weekday}] function extracts the weekday
17042 number from a date form as an integer in the range 0 (Sunday)
17046 The @kbd{M-8 t P} [@code{yearday}] function extracts the day-of-year
17047 number from a date form as an integer in the range 1 (January 1)
17048 to 366 (December 31 of a leap year).
17051 The @kbd{M-9 t P} [@code{time}] function extracts the time portion
17052 of a date form as an HMS form. This returns @samp{0@@ 0' 0"}
17053 for a pure date form.
17056 @pindex calc-new-month
17058 The @kbd{t M} (@code{calc-new-month}) [@code{newmonth}] command
17059 computes a new date form that represents the first day of the month
17060 specified by the input date. The result is always a pure date
17061 form; only the year and month numbers of the input are retained.
17062 With a numeric prefix argument @var{n} in the range from 1 to 31,
17063 @kbd{t M} computes the @var{n}th day of the month. (If @var{n}
17064 is greater than the actual number of days in the month, or if
17065 @var{n} is zero, the last day of the month is used.)
17068 @pindex calc-new-year
17070 The @kbd{t Y} (@code{calc-new-year}) [@code{newyear}] command
17071 computes a new pure date form that represents the first day of
17072 the year specified by the input. The month, day, and time
17073 of the input date form are lost. With a numeric prefix argument
17074 @var{n} in the range from 1 to 366, @kbd{t Y} computes the
17075 @var{n}th day of the year (366 is treated as 365 in non-leap
17076 years). A prefix argument of 0 computes the last day of the
17077 year (December 31). A negative prefix argument from @mathit{-1} to
17078 @mathit{-12} computes the first day of the @var{n}th month of the year.
17081 @pindex calc-new-week
17083 The @kbd{t W} (@code{calc-new-week}) [@code{newweek}] command
17084 computes a new pure date form that represents the Sunday on or before
17085 the input date. With a numeric prefix argument, it can be made to
17086 use any day of the week as the starting day; the argument must be in
17087 the range from 0 (Sunday) to 6 (Saturday). This function always
17088 subtracts between 0 and 6 days from the input date.
17090 Here's an example use of @code{newweek}: Find the date of the next
17091 Wednesday after a given date. Using @kbd{M-3 t W} or @samp{newweek(d, 3)}
17092 will give you the @emph{preceding} Wednesday, so @samp{newweek(d+7, 3)}
17093 will give you the following Wednesday. A further look at the definition
17094 of @code{newweek} shows that if the input date is itself a Wednesday,
17095 this formula will return the Wednesday one week in the future. An
17096 exercise for the reader is to modify this formula to yield the same day
17097 if the input is already a Wednesday. Another interesting exercise is
17098 to preserve the time-of-day portion of the input (@code{newweek} resets
17099 the time to midnight; hint: how can @code{newweek} be defined in terms
17100 of the @code{weekday} function?).
17106 The @samp{pwday(@var{date})} function (not on any key) computes the
17107 day-of-month number of the Sunday on or before @var{date}. With
17108 two arguments, @samp{pwday(@var{date}, @var{day})} computes the day
17109 number of the Sunday on or before day number @var{day} of the month
17110 specified by @var{date}. The @var{day} must be in the range from
17111 7 to 31; if the day number is greater than the actual number of days
17112 in the month, the true number of days is used instead. Thus
17113 @samp{pwday(@var{date}, 7)} finds the first Sunday of the month, and
17114 @samp{pwday(@var{date}, 31)} finds the last Sunday of the month.
17115 With a third @var{weekday} argument, @code{pwday} can be made to look
17116 for any day of the week instead of Sunday.
17119 @pindex calc-inc-month
17121 The @kbd{t I} (@code{calc-inc-month}) [@code{incmonth}] command
17122 increases a date form by one month, or by an arbitrary number of
17123 months specified by a numeric prefix argument. The time portion,
17124 if any, of the date form stays the same. The day also stays the
17125 same, except that if the new month has fewer days the day
17126 number may be reduced to lie in the valid range. For example,
17127 @samp{incmonth(<Jan 31, 1991>)} produces @samp{<Feb 28, 1991>}.
17128 Because of this, @kbd{t I t I} and @kbd{M-2 t I} do not always give
17129 the same results (@samp{<Mar 28, 1991>} versus @samp{<Mar 31, 1991>}
17136 The @samp{incyear(@var{date}, @var{step})} function increases
17137 a date form by the specified number of years, which may be
17138 any positive or negative integer. Note that @samp{incyear(d, n)}
17139 is equivalent to @w{@samp{incmonth(d, 12*n)}}, but these do not have
17140 simple equivalents in terms of day arithmetic because
17141 months and years have varying lengths. If the @var{step}
17142 argument is omitted, 1 year is assumed. There is no keyboard
17143 command for this function; use @kbd{C-u 12 t I} instead.
17145 There is no @code{newday} function at all because @kbd{F} [@code{floor}]
17146 serves this purpose. Similarly, instead of @code{incday} and
17147 @code{incweek} simply use @expr{d + n} or @expr{d + 7 n}.
17149 @xref{Basic Arithmetic}, for the @kbd{f ]} [@code{incr}] command
17150 which can adjust a date/time form by a certain number of seconds.
17152 @node Business Days, Time Zones, Date Functions, Date Arithmetic
17153 @subsection Business Days
17156 Often time is measured in ``business days'' or ``working days,''
17157 where weekends and holidays are skipped. Calc's normal date
17158 arithmetic functions use calendar days, so that subtracting two
17159 consecutive Mondays will yield a difference of 7 days. By contrast,
17160 subtracting two consecutive Mondays would yield 5 business days
17161 (assuming two-day weekends and the absence of holidays).
17167 @pindex calc-business-days-plus
17168 @pindex calc-business-days-minus
17169 The @kbd{t +} (@code{calc-business-days-plus}) [@code{badd}]
17170 and @kbd{t -} (@code{calc-business-days-minus}) [@code{bsub}]
17171 commands perform arithmetic using business days. For @kbd{t +},
17172 one argument must be a date form and the other must be a real
17173 number (positive or negative). If the number is not an integer,
17174 then a certain amount of time is added as well as a number of
17175 days; for example, adding 0.5 business days to a time in Friday
17176 evening will produce a time in Monday morning. It is also
17177 possible to add an HMS form; adding @samp{12@@ 0' 0"} also adds
17178 half a business day. For @kbd{t -}, the arguments are either a
17179 date form and a number or HMS form, or two date forms, in which
17180 case the result is the number of business days between the two
17183 @cindex @code{Holidays} variable
17185 By default, Calc considers any day that is not a Saturday or
17186 Sunday to be a business day. You can define any number of
17187 additional holidays by editing the variable @code{Holidays}.
17188 (There is an @w{@kbd{s H}} convenience command for editing this
17189 variable.) Initially, @code{Holidays} contains the vector
17190 @samp{[sat, sun]}. Entries in the @code{Holidays} vector may
17191 be any of the following kinds of objects:
17195 Date forms (pure dates, not date/time forms). These specify
17196 particular days which are to be treated as holidays.
17199 Intervals of date forms. These specify a range of days, all of
17200 which are holidays (e.g., Christmas week). @xref{Interval Forms}.
17203 Nested vectors of date forms. Each date form in the vector is
17204 considered to be a holiday.
17207 Any Calc formula which evaluates to one of the above three things.
17208 If the formula involves the variable @expr{y}, it stands for a
17209 yearly repeating holiday; @expr{y} will take on various year
17210 numbers like 1992. For example, @samp{date(y, 12, 25)} specifies
17211 Christmas day, and @samp{newweek(date(y, 11, 7), 4) + 21} specifies
17212 Thanksgiving (which is held on the fourth Thursday of November).
17213 If the formula involves the variable @expr{m}, that variable
17214 takes on month numbers from 1 to 12: @samp{date(y, m, 15)} is
17215 a holiday that takes place on the 15th of every month.
17218 A weekday name, such as @code{sat} or @code{sun}. This is really
17219 a variable whose name is a three-letter, lower-case day name.
17222 An interval of year numbers (integers). This specifies the span of
17223 years over which this holiday list is to be considered valid. Any
17224 business-day arithmetic that goes outside this range will result
17225 in an error message. Use this if you are including an explicit
17226 list of holidays, rather than a formula to generate them, and you
17227 want to make sure you don't accidentally go beyond the last point
17228 where the holidays you entered are complete. If there is no
17229 limiting interval in the @code{Holidays} vector, the default
17230 @samp{[1 .. 2737]} is used. (This is the absolute range of years
17231 for which Calc's business-day algorithms will operate.)
17234 An interval of HMS forms. This specifies the span of hours that
17235 are to be considered one business day. For example, if this
17236 range is @samp{[9@@ 0' 0" .. 17@@ 0' 0"]} (i.e., 9am to 5pm), then
17237 the business day is only eight hours long, so that @kbd{1.5 t +}
17238 on @samp{<4:00pm Fri Dec 13, 1991>} will add one business day and
17239 four business hours to produce @samp{<12:00pm Tue Dec 17, 1991>}.
17240 Likewise, @kbd{t -} will now express differences in time as
17241 fractions of an eight-hour day. Times before 9am will be treated
17242 as 9am by business date arithmetic, and times at or after 5pm will
17243 be treated as 4:59:59pm. If there is no HMS interval in @code{Holidays},
17244 the full 24-hour day @samp{[0@ 0' 0" .. 24@ 0' 0"]} is assumed.
17245 (Regardless of the type of bounds you specify, the interval is
17246 treated as inclusive on the low end and exclusive on the high end,
17247 so that the work day goes from 9am up to, but not including, 5pm.)
17250 If the @code{Holidays} vector is empty, then @kbd{t +} and
17251 @kbd{t -} will act just like @kbd{+} and @kbd{-} because there will
17252 then be no difference between business days and calendar days.
17254 Calc expands the intervals and formulas you give into a complete
17255 list of holidays for internal use. This is done mainly to make
17256 sure it can detect multiple holidays. (For example,
17257 @samp{<Jan 1, 1989>} is both New Year's Day and a Sunday, but
17258 Calc's algorithms take care to count it only once when figuring
17259 the number of holidays between two dates.)
17261 Since the complete list of holidays for all the years from 1 to
17262 2737 would be huge, Calc actually computes only the part of the
17263 list between the smallest and largest years that have been involved
17264 in business-day calculations so far. Normally, you won't have to
17265 worry about this. Keep in mind, however, that if you do one
17266 calculation for 1992, and another for 1792, even if both involve
17267 only a small range of years, Calc will still work out all the
17268 holidays that fall in that 200-year span.
17270 If you add a (positive) number of days to a date form that falls on a
17271 weekend or holiday, the date form is treated as if it were the most
17272 recent business day. (Thus adding one business day to a Friday,
17273 Saturday, or Sunday will all yield the following Monday.) If you
17274 subtract a number of days from a weekend or holiday, the date is
17275 effectively on the following business day. (So subtracting one business
17276 day from Saturday, Sunday, or Monday yields the preceding Friday.) The
17277 difference between two dates one or both of which fall on holidays
17278 equals the number of actual business days between them. These
17279 conventions are consistent in the sense that, if you add @var{n}
17280 business days to any date, the difference between the result and the
17281 original date will come out to @var{n} business days. (It can't be
17282 completely consistent though; a subtraction followed by an addition
17283 might come out a bit differently, since @kbd{t +} is incapable of
17284 producing a date that falls on a weekend or holiday.)
17290 There is a @code{holiday} function, not on any keys, that takes
17291 any date form and returns 1 if that date falls on a weekend or
17292 holiday, as defined in @code{Holidays}, or 0 if the date is a
17295 @node Time Zones, , Business Days, Date Arithmetic
17296 @subsection Time Zones
17300 @cindex Daylight saving time
17301 Time zones and daylight saving time are a complicated business.
17302 The conversions to and from Julian and Unix-style dates automatically
17303 compute the correct time zone and daylight saving adjustment to use,
17304 provided they can figure out this information. This section describes
17305 Calc's time zone adjustment algorithm in detail, in case you want to
17306 do conversions in different time zones or in case Calc's algorithms
17307 can't determine the right correction to use.
17309 Adjustments for time zones and daylight saving time are done by
17310 @kbd{t U}, @kbd{t J}, @kbd{t N}, and @kbd{t C}, but not by any other
17311 commands. In particular, @samp{<may 1 1991> - <apr 1 1991>} evaluates
17312 to exactly 30 days even though there is a daylight-saving
17313 transition in between. This is also true for Julian pure dates:
17314 @samp{julian(<may 1 1991>) - julian(<apr 1 1991>)}. But Julian
17315 and Unix date/times will adjust for daylight saving time: using Calc's
17316 default daylight saving time rule (see the explanation below),
17317 @samp{julian(<12am may 1 1991>) - julian(<12am apr 1 1991>)}
17318 evaluates to @samp{29.95833} (that's 29 days and 23 hours)
17319 because one hour was lost when daylight saving commenced on
17322 In brief, the idiom @samp{julian(@var{date1}) - julian(@var{date2})}
17323 computes the actual number of 24-hour periods between two dates, whereas
17324 @samp{@var{date1} - @var{date2}} computes the number of calendar
17325 days between two dates without taking daylight saving into account.
17327 @pindex calc-time-zone
17332 The @code{calc-time-zone} [@code{tzone}] command converts the time
17333 zone specified by its numeric prefix argument into a number of
17334 seconds difference from Greenwich mean time (GMT). If the argument
17335 is a number, the result is simply that value multiplied by 3600.
17336 Typical arguments for North America are 5 (Eastern) or 8 (Pacific). If
17337 Daylight Saving time is in effect, one hour should be subtracted from
17338 the normal difference.
17340 If you give a prefix of plain @kbd{C-u}, @code{calc-time-zone} (like other
17341 date arithmetic commands that include a time zone argument) takes the
17342 zone argument from the top of the stack. (In the case of @kbd{t J}
17343 and @kbd{t U}, the normal argument is then taken from the second-to-top
17344 stack position.) This allows you to give a non-integer time zone
17345 adjustment. The time-zone argument can also be an HMS form, or
17346 it can be a variable which is a time zone name in upper- or lower-case.
17347 For example @samp{tzone(PST) = tzone(8)} and @samp{tzone(pdt) = tzone(7)}
17348 (for Pacific standard and daylight saving times, respectively).
17350 North American and European time zone names are defined as follows;
17351 note that for each time zone there is one name for standard time,
17352 another for daylight saving time, and a third for ``generalized'' time
17353 in which the daylight saving adjustment is computed from context.
17357 YST PST MST CST EST AST NST GMT WET MET MEZ
17358 9 8 7 6 5 4 3.5 0 -1 -2 -2
17360 YDT PDT MDT CDT EDT ADT NDT BST WETDST METDST MESZ
17361 8 7 6 5 4 3 2.5 -1 -2 -3 -3
17363 YGT PGT MGT CGT EGT AGT NGT BGT WEGT MEGT MEGZ
17364 9/8 8/7 7/6 6/5 5/4 4/3 3.5/2.5 0/-1 -1/-2 -2/-3 -2/-3
17368 @vindex math-tzone-names
17369 To define time zone names that do not appear in the above table,
17370 you must modify the Lisp variable @code{math-tzone-names}. This
17371 is a list of lists describing the different time zone names; its
17372 structure is best explained by an example. The three entries for
17373 Pacific Time look like this:
17377 ( ( "PST" 8 0 ) ; Name as an upper-case string, then standard
17378 ( "PDT" 8 -1 ) ; adjustment, then daylight saving adjustment.
17379 ( "PGT" 8 "PST" "PDT" ) ) ; Generalized time zone.
17383 @cindex @code{TimeZone} variable
17385 With no arguments, @code{calc-time-zone} or @samp{tzone()} will by
17386 default get the time zone and daylight saving information from the
17387 calendar (@pxref{Daylight Saving,Calendar/Diary,The Calendar and the Diary,
17388 emacs,The GNU Emacs Manual}). To use a different time zone, or if the
17389 calendar does not give the desired result, you can set the Calc variable
17390 @code{TimeZone} (which is by default @code{nil}) to an appropriate
17391 time zone name. (The easiest way to do this is to edit the
17392 @code{TimeZone} variable using Calc's @kbd{s T} command, then use the
17393 @kbd{s p} (@code{calc-permanent-variable}) command to save the value of
17394 @code{TimeZone} permanently.)
17395 If the time zone given by @code{TimeZone} is a generalized time zone,
17396 e.g., @code{EGT}, Calc examines the date being converted to tell whether
17397 to use standard or daylight saving time. But if the current time zone
17398 is explicit, e.g., @code{EST} or @code{EDT}, then that adjustment is
17399 used exactly and Calc's daylight saving algorithm is not consulted.
17400 The special time zone name @code{local}
17401 is equivalent to no argument; i.e., it uses the information obtained
17404 The @kbd{t J} and @code{t U} commands with no numeric prefix
17405 arguments do the same thing as @samp{tzone()}; namely, use the
17406 information from the calendar if @code{TimeZone} is @code{nil},
17407 otherwise use the time zone given by @code{TimeZone}.
17409 @vindex math-daylight-savings-hook
17410 @findex math-std-daylight-savings
17411 When Calc computes the daylight saving information itself (i.e., when
17412 the @code{TimeZone} variable is set), it will by default consider
17413 daylight saving time to begin at 2 a.m.@: on the second Sunday of March
17414 (for years from 2007 on) or on the last Sunday in April (for years
17415 before 2007), and to end at 2 a.m.@: on the first Sunday of
17416 November. (for years from 2007 on) or the last Sunday in October (for
17417 years before 2007). These are the rules that have been in effect in
17418 much of North America since 1966 and take into account the rule change
17419 that began in 2007. If you are in a country that uses different rules
17420 for computing daylight saving time, you have two choices: Write your own
17421 daylight saving hook, or control time zones explicitly by setting the
17422 @code{TimeZone} variable and/or always giving a time-zone argument for
17423 the conversion functions.
17425 The Lisp variable @code{math-daylight-savings-hook} holds the
17426 name of a function that is used to compute the daylight saving
17427 adjustment for a given date. The default is
17428 @code{math-std-daylight-savings}, which computes an adjustment
17429 (either 0 or @mathit{-1}) using the North American rules given above.
17431 The daylight saving hook function is called with four arguments:
17432 The date, as a floating-point number in standard Calc format;
17433 a six-element list of the date decomposed into year, month, day,
17434 hour, minute, and second, respectively; a string which contains
17435 the generalized time zone name in upper-case, e.g., @code{"WEGT"};
17436 and a special adjustment to be applied to the hour value when
17437 converting into a generalized time zone (see below).
17439 @findex math-prev-weekday-in-month
17440 The Lisp function @code{math-prev-weekday-in-month} is useful for
17441 daylight saving computations. This is an internal version of
17442 the user-level @code{pwday} function described in the previous
17443 section. It takes four arguments: The floating-point date value,
17444 the corresponding six-element date list, the day-of-month number,
17445 and the weekday number (0--6).
17447 The default daylight saving hook ignores the time zone name, but a
17448 more sophisticated hook could use different algorithms for different
17449 time zones. It would also be possible to use different algorithms
17450 depending on the year number, but the default hook always uses the
17451 algorithm for 1987 and later. Here is a listing of the default
17452 daylight saving hook:
17455 (defun math-std-daylight-savings (date dt zone bump)
17456 (cond ((< (nth 1 dt) 4) 0)
17458 (let ((sunday (math-prev-weekday-in-month date dt 7 0)))
17459 (cond ((< (nth 2 dt) sunday) 0)
17460 ((= (nth 2 dt) sunday)
17461 (if (>= (nth 3 dt) (+ 3 bump)) -1 0))
17463 ((< (nth 1 dt) 10) -1)
17465 (let ((sunday (math-prev-weekday-in-month date dt 31 0)))
17466 (cond ((< (nth 2 dt) sunday) -1)
17467 ((= (nth 2 dt) sunday)
17468 (if (>= (nth 3 dt) (+ 2 bump)) 0 -1))
17475 The @code{bump} parameter is equal to zero when Calc is converting
17476 from a date form in a generalized time zone into a GMT date value.
17477 It is @mathit{-1} when Calc is converting in the other direction. The
17478 adjustments shown above ensure that the conversion behaves correctly
17479 and reasonably around the 2 a.m.@: transition in each direction.
17481 There is a ``missing'' hour between 2 a.m.@: and 3 a.m.@: at the
17482 beginning of daylight saving time; converting a date/time form that
17483 falls in this hour results in a time value for the following hour,
17484 from 3 a.m.@: to 4 a.m. At the end of daylight saving time, the
17485 hour from 1 a.m.@: to 2 a.m.@: repeats itself; converting a date/time
17486 form that falls in this hour results in a time value for the first
17487 manifestation of that time (@emph{not} the one that occurs one hour
17490 If @code{math-daylight-savings-hook} is @code{nil}, then the
17491 daylight saving adjustment is always taken to be zero.
17493 In algebraic formulas, @samp{tzone(@var{zone}, @var{date})}
17494 computes the time zone adjustment for a given zone name at a
17495 given date. The @var{date} is ignored unless @var{zone} is a
17496 generalized time zone. If @var{date} is a date form, the
17497 daylight saving computation is applied to it as it appears.
17498 If @var{date} is a numeric date value, it is adjusted for the
17499 daylight-saving version of @var{zone} before being given to
17500 the daylight saving hook. This odd-sounding rule ensures
17501 that the daylight-saving computation is always done in
17502 local time, not in the GMT time that a numeric @var{date}
17503 is typically represented in.
17509 The @samp{dsadj(@var{date}, @var{zone})} function computes the
17510 daylight saving adjustment that is appropriate for @var{date} in
17511 time zone @var{zone}. If @var{zone} is explicitly in or not in
17512 daylight saving time (e.g., @code{PDT} or @code{PST}) the
17513 @var{date} is ignored. If @var{zone} is a generalized time zone,
17514 the algorithms described above are used. If @var{zone} is omitted,
17515 the computation is done for the current time zone.
17517 @node Financial Functions, Binary Functions, Date Arithmetic, Arithmetic
17518 @section Financial Functions
17521 Calc's financial or business functions use the @kbd{b} prefix
17522 key followed by a shifted letter. (The @kbd{b} prefix followed by
17523 a lower-case letter is used for operations on binary numbers.)
17525 Note that the rate and the number of intervals given to these
17526 functions must be on the same time scale, e.g., both months or
17527 both years. Mixing an annual interest rate with a time expressed
17528 in months will give you very wrong answers!
17530 It is wise to compute these functions to a higher precision than
17531 you really need, just to make sure your answer is correct to the
17532 last penny; also, you may wish to check the definitions at the end
17533 of this section to make sure the functions have the meaning you expect.
17539 * Related Financial Functions::
17540 * Depreciation Functions::
17541 * Definitions of Financial Functions::
17544 @node Percentages, Future Value, Financial Functions, Financial Functions
17545 @subsection Percentages
17548 @pindex calc-percent
17551 The @kbd{M-%} (@code{calc-percent}) command takes a percentage value,
17552 say 5.4, and converts it to an equivalent actual number. For example,
17553 @kbd{5.4 M-%} enters 0.054 on the stack. (That's the @key{META} or
17554 @key{ESC} key combined with @kbd{%}.)
17556 Actually, @kbd{M-%} creates a formula of the form @samp{5.4%}.
17557 You can enter @samp{5.4%} yourself during algebraic entry. The
17558 @samp{%} operator simply means, ``the preceding value divided by
17559 100.'' The @samp{%} operator has very high precedence, so that
17560 @samp{1+8%} is interpreted as @samp{1+(8%)}, not as @samp{(1+8)%}.
17561 (The @samp{%} operator is just a postfix notation for the
17562 @code{percent} function, just like @samp{20!} is the notation for
17563 @samp{fact(20)}, or twenty-factorial.)
17565 The formula @samp{5.4%} would normally evaluate immediately to
17566 0.054, but the @kbd{M-%} command suppresses evaluation as it puts
17567 the formula onto the stack. However, the next Calc command that
17568 uses the formula @samp{5.4%} will evaluate it as its first step.
17569 The net effect is that you get to look at @samp{5.4%} on the stack,
17570 but Calc commands see it as @samp{0.054}, which is what they expect.
17572 In particular, @samp{5.4%} and @samp{0.054} are suitable values
17573 for the @var{rate} arguments of the various financial functions,
17574 but the number @samp{5.4} is probably @emph{not} suitable---it
17575 represents a rate of 540 percent!
17577 The key sequence @kbd{M-% *} effectively means ``percent-of.''
17578 For example, @kbd{68 @key{RET} 25 M-% *} computes 17, which is 25% of
17579 68 (and also 68% of 25, which comes out to the same thing).
17582 @pindex calc-convert-percent
17583 The @kbd{c %} (@code{calc-convert-percent}) command converts the
17584 value on the top of the stack from numeric to percentage form.
17585 For example, if 0.08 is on the stack, @kbd{c %} converts it to
17586 @samp{8%}. The quantity is the same, it's just represented
17587 differently. (Contrast this with @kbd{M-%}, which would convert
17588 this number to @samp{0.08%}.) The @kbd{=} key is a convenient way
17589 to convert a formula like @samp{8%} back to numeric form, 0.08.
17591 To compute what percentage one quantity is of another quantity,
17592 use @kbd{/ c %}. For example, @w{@kbd{17 @key{RET} 68 / c %}} displays
17596 @pindex calc-percent-change
17598 The @kbd{b %} (@code{calc-percent-change}) [@code{relch}] command
17599 calculates the percentage change from one number to another.
17600 For example, @kbd{40 @key{RET} 50 b %} produces the answer @samp{25%},
17601 since 50 is 25% larger than 40. A negative result represents a
17602 decrease: @kbd{50 @key{RET} 40 b %} produces @samp{-20%}, since 40 is
17603 20% smaller than 50. (The answers are different in magnitude
17604 because, in the first case, we're increasing by 25% of 40, but
17605 in the second case, we're decreasing by 20% of 50.) The effect
17606 of @kbd{40 @key{RET} 50 b %} is to compute @expr{(50-40)/40}, converting
17607 the answer to percentage form as if by @kbd{c %}.
17609 @node Future Value, Present Value, Percentages, Financial Functions
17610 @subsection Future Value
17614 @pindex calc-fin-fv
17616 The @kbd{b F} (@code{calc-fin-fv}) [@code{fv}] command computes
17617 the future value of an investment. It takes three arguments
17618 from the stack: @samp{fv(@var{rate}, @var{n}, @var{payment})}.
17619 If you give payments of @var{payment} every year for @var{n}
17620 years, and the money you have paid earns interest at @var{rate} per
17621 year, then this function tells you what your investment would be
17622 worth at the end of the period. (The actual interval doesn't
17623 have to be years, as long as @var{n} and @var{rate} are expressed
17624 in terms of the same intervals.) This function assumes payments
17625 occur at the @emph{end} of each interval.
17629 The @kbd{I b F} [@code{fvb}] command does the same computation,
17630 but assuming your payments are at the beginning of each interval.
17631 Suppose you plan to deposit $1000 per year in a savings account
17632 earning 5.4% interest, starting right now. How much will be
17633 in the account after five years? @code{fvb(5.4%, 5, 1000) = 5870.73}.
17634 Thus you will have earned $870 worth of interest over the years.
17635 Using the stack, this calculation would have been
17636 @kbd{5.4 M-% 5 @key{RET} 1000 I b F}. Note that the rate is expressed
17637 as a number between 0 and 1, @emph{not} as a percentage.
17641 The @kbd{H b F} [@code{fvl}] command computes the future value
17642 of an initial lump sum investment. Suppose you could deposit
17643 those five thousand dollars in the bank right now; how much would
17644 they be worth in five years? @code{fvl(5.4%, 5, 5000) = 6503.89}.
17646 The algebraic functions @code{fv} and @code{fvb} accept an optional
17647 fourth argument, which is used as an initial lump sum in the sense
17648 of @code{fvl}. In other words, @code{fv(@var{rate}, @var{n},
17649 @var{payment}, @var{initial}) = fv(@var{rate}, @var{n}, @var{payment})
17650 + fvl(@var{rate}, @var{n}, @var{initial})}.
17652 To illustrate the relationships between these functions, we could
17653 do the @code{fvb} calculation ``by hand'' using @code{fvl}. The
17654 final balance will be the sum of the contributions of our five
17655 deposits at various times. The first deposit earns interest for
17656 five years: @code{fvl(5.4%, 5, 1000) = 1300.78}. The second
17657 deposit only earns interest for four years: @code{fvl(5.4%, 4, 1000) =
17658 1234.13}. And so on down to the last deposit, which earns one
17659 year's interest: @code{fvl(5.4%, 1, 1000) = 1054.00}. The sum of
17660 these five values is, sure enough, $5870.73, just as was computed
17661 by @code{fvb} directly.
17663 What does @code{fv(5.4%, 5, 1000) = 5569.96} mean? The payments
17664 are now at the ends of the periods. The end of one year is the same
17665 as the beginning of the next, so what this really means is that we've
17666 lost the payment at year zero (which contributed $1300.78), but we're
17667 now counting the payment at year five (which, since it didn't have
17668 a chance to earn interest, counts as $1000). Indeed, @expr{5569.96 =
17669 5870.73 - 1300.78 + 1000} (give or take a bit of roundoff error).
17671 @node Present Value, Related Financial Functions, Future Value, Financial Functions
17672 @subsection Present Value
17676 @pindex calc-fin-pv
17678 The @kbd{b P} (@code{calc-fin-pv}) [@code{pv}] command computes
17679 the present value of an investment. Like @code{fv}, it takes
17680 three arguments: @code{pv(@var{rate}, @var{n}, @var{payment})}.
17681 It computes the present value of a series of regular payments.
17682 Suppose you have the chance to make an investment that will
17683 pay $2000 per year over the next four years; as you receive
17684 these payments you can put them in the bank at 9% interest.
17685 You want to know whether it is better to make the investment, or
17686 to keep the money in the bank where it earns 9% interest right
17687 from the start. The calculation @code{pv(9%, 4, 2000)} gives the
17688 result 6479.44. If your initial investment must be less than this,
17689 say, $6000, then the investment is worthwhile. But if you had to
17690 put up $7000, then it would be better just to leave it in the bank.
17692 Here is the interpretation of the result of @code{pv}: You are
17693 trying to compare the return from the investment you are
17694 considering, which is @code{fv(9%, 4, 2000) = 9146.26}, with
17695 the return from leaving the money in the bank, which is
17696 @code{fvl(9%, 4, @var{x})} where @var{x} is the amount of money
17697 you would have to put up in advance. The @code{pv} function
17698 finds the break-even point, @expr{x = 6479.44}, at which
17699 @code{fvl(9%, 4, 6479.44)} is also equal to 9146.26. This is
17700 the largest amount you should be willing to invest.
17704 The @kbd{I b P} [@code{pvb}] command solves the same problem,
17705 but with payments occurring at the beginning of each interval.
17706 It has the same relationship to @code{fvb} as @code{pv} has
17707 to @code{fv}. For example @code{pvb(9%, 4, 2000) = 7062.59},
17708 a larger number than @code{pv} produced because we get to start
17709 earning interest on the return from our investment sooner.
17713 The @kbd{H b P} [@code{pvl}] command computes the present value of
17714 an investment that will pay off in one lump sum at the end of the
17715 period. For example, if we get our $8000 all at the end of the
17716 four years, @code{pvl(9%, 4, 8000) = 5667.40}. This is much
17717 less than @code{pv} reported, because we don't earn any interest
17718 on the return from this investment. Note that @code{pvl} and
17719 @code{fvl} are simple inverses: @code{fvl(9%, 4, 5667.40) = 8000}.
17721 You can give an optional fourth lump-sum argument to @code{pv}
17722 and @code{pvb}; this is handled in exactly the same way as the
17723 fourth argument for @code{fv} and @code{fvb}.
17726 @pindex calc-fin-npv
17728 The @kbd{b N} (@code{calc-fin-npv}) [@code{npv}] command computes
17729 the net present value of a series of irregular investments.
17730 The first argument is the interest rate. The second argument is
17731 a vector which represents the expected return from the investment
17732 at the end of each interval. For example, if the rate represents
17733 a yearly interest rate, then the vector elements are the return
17734 from the first year, second year, and so on.
17736 Thus, @code{npv(9%, [2000,2000,2000,2000]) = pv(9%, 4, 2000) = 6479.44}.
17737 Obviously this function is more interesting when the payments are
17740 The @code{npv} function can actually have two or more arguments.
17741 Multiple arguments are interpreted in the same way as for the
17742 vector statistical functions like @code{vsum}.
17743 @xref{Single-Variable Statistics}. Basically, if there are several
17744 payment arguments, each either a vector or a plain number, all these
17745 values are collected left-to-right into the complete list of payments.
17746 A numeric prefix argument on the @kbd{b N} command says how many
17747 payment values or vectors to take from the stack.
17751 The @kbd{I b N} [@code{npvb}] command computes the net present
17752 value where payments occur at the beginning of each interval
17753 rather than at the end.
17755 @node Related Financial Functions, Depreciation Functions, Present Value, Financial Functions
17756 @subsection Related Financial Functions
17759 The functions in this section are basically inverses of the
17760 present value functions with respect to the various arguments.
17763 @pindex calc-fin-pmt
17765 The @kbd{b M} (@code{calc-fin-pmt}) [@code{pmt}] command computes
17766 the amount of periodic payment necessary to amortize a loan.
17767 Thus @code{pmt(@var{rate}, @var{n}, @var{amount})} equals the
17768 value of @var{payment} such that @code{pv(@var{rate}, @var{n},
17769 @var{payment}) = @var{amount}}.
17773 The @kbd{I b M} [@code{pmtb}] command does the same computation
17774 but using @code{pvb} instead of @code{pv}. Like @code{pv} and
17775 @code{pvb}, these functions can also take a fourth argument which
17776 represents an initial lump-sum investment.
17779 The @kbd{H b M} key just invokes the @code{fvl} function, which is
17780 the inverse of @code{pvl}. There is no explicit @code{pmtl} function.
17783 @pindex calc-fin-nper
17785 The @kbd{b #} (@code{calc-fin-nper}) [@code{nper}] command computes
17786 the number of regular payments necessary to amortize a loan.
17787 Thus @code{nper(@var{rate}, @var{payment}, @var{amount})} equals
17788 the value of @var{n} such that @code{pv(@var{rate}, @var{n},
17789 @var{payment}) = @var{amount}}. If @var{payment} is too small
17790 ever to amortize a loan for @var{amount} at interest rate @var{rate},
17791 the @code{nper} function is left in symbolic form.
17795 The @kbd{I b #} [@code{nperb}] command does the same computation
17796 but using @code{pvb} instead of @code{pv}. You can give a fourth
17797 lump-sum argument to these functions, but the computation will be
17798 rather slow in the four-argument case.
17802 The @kbd{H b #} [@code{nperl}] command does the same computation
17803 using @code{pvl}. By exchanging @var{payment} and @var{amount} you
17804 can also get the solution for @code{fvl}. For example,
17805 @code{nperl(8%, 2000, 1000) = 9.006}, so if you place $1000 in a
17806 bank account earning 8%, it will take nine years to grow to $2000.
17809 @pindex calc-fin-rate
17811 The @kbd{b T} (@code{calc-fin-rate}) [@code{rate}] command computes
17812 the rate of return on an investment. This is also an inverse of @code{pv}:
17813 @code{rate(@var{n}, @var{payment}, @var{amount})} computes the value of
17814 @var{rate} such that @code{pv(@var{rate}, @var{n}, @var{payment}) =
17815 @var{amount}}. The result is expressed as a formula like @samp{6.3%}.
17821 The @kbd{I b T} [@code{rateb}] and @kbd{H b T} [@code{ratel}]
17822 commands solve the analogous equations with @code{pvb} or @code{pvl}
17823 in place of @code{pv}. Also, @code{rate} and @code{rateb} can
17824 accept an optional fourth argument just like @code{pv} and @code{pvb}.
17825 To redo the above example from a different perspective,
17826 @code{ratel(9, 2000, 1000) = 8.00597%}, which says you will need an
17827 interest rate of 8% in order to double your account in nine years.
17830 @pindex calc-fin-irr
17832 The @kbd{b I} (@code{calc-fin-irr}) [@code{irr}] command is the
17833 analogous function to @code{rate} but for net present value.
17834 Its argument is a vector of payments. Thus @code{irr(@var{payments})}
17835 computes the @var{rate} such that @code{npv(@var{rate}, @var{payments}) = 0};
17836 this rate is known as the @dfn{internal rate of return}.
17840 The @kbd{I b I} [@code{irrb}] command computes the internal rate of
17841 return assuming payments occur at the beginning of each period.
17843 @node Depreciation Functions, Definitions of Financial Functions, Related Financial Functions, Financial Functions
17844 @subsection Depreciation Functions
17847 The functions in this section calculate @dfn{depreciation}, which is
17848 the amount of value that a possession loses over time. These functions
17849 are characterized by three parameters: @var{cost}, the original cost
17850 of the asset; @var{salvage}, the value the asset will have at the end
17851 of its expected ``useful life''; and @var{life}, the number of years
17852 (or other periods) of the expected useful life.
17854 There are several methods for calculating depreciation that differ in
17855 the way they spread the depreciation over the lifetime of the asset.
17858 @pindex calc-fin-sln
17860 The @kbd{b S} (@code{calc-fin-sln}) [@code{sln}] command computes the
17861 ``straight-line'' depreciation. In this method, the asset depreciates
17862 by the same amount every year (or period). For example,
17863 @samp{sln(12000, 2000, 5)} returns 2000. The asset costs $12000
17864 initially and will be worth $2000 after five years; it loses $2000
17868 @pindex calc-fin-syd
17870 The @kbd{b Y} (@code{calc-fin-syd}) [@code{syd}] command computes the
17871 accelerated ``sum-of-years'-digits'' depreciation. Here the depreciation
17872 is higher during the early years of the asset's life. Since the
17873 depreciation is different each year, @kbd{b Y} takes a fourth @var{period}
17874 parameter which specifies which year is requested, from 1 to @var{life}.
17875 If @var{period} is outside this range, the @code{syd} function will
17879 @pindex calc-fin-ddb
17881 The @kbd{b D} (@code{calc-fin-ddb}) [@code{ddb}] command computes an
17882 accelerated depreciation using the double-declining balance method.
17883 It also takes a fourth @var{period} parameter.
17885 For symmetry, the @code{sln} function will accept a @var{period}
17886 parameter as well, although it will ignore its value except that the
17887 return value will as usual be zero if @var{period} is out of range.
17889 For example, pushing the vector @expr{[1,2,3,4,5]} (perhaps with @kbd{v x 5})
17890 and then mapping @kbd{V M ' [sln(12000,2000,5,$), syd(12000,2000,5,$),
17891 ddb(12000,2000,5,$)] @key{RET}} produces a matrix that allows us to compare
17892 the three depreciation methods:
17896 [ [ 2000, 3333, 4800 ]
17897 [ 2000, 2667, 2880 ]
17898 [ 2000, 2000, 1728 ]
17899 [ 2000, 1333, 592 ]
17905 (Values have been rounded to nearest integers in this figure.)
17906 We see that @code{sln} depreciates by the same amount each year,
17907 @kbd{syd} depreciates more at the beginning and less at the end,
17908 and @kbd{ddb} weights the depreciation even more toward the beginning.
17910 Summing columns with @kbd{V R : +} yields @expr{[10000, 10000, 10000]};
17911 the total depreciation in any method is (by definition) the
17912 difference between the cost and the salvage value.
17914 @node Definitions of Financial Functions, , Depreciation Functions, Financial Functions
17915 @subsection Definitions
17918 For your reference, here are the actual formulas used to compute
17919 Calc's financial functions.
17921 Calc will not evaluate a financial function unless the @var{rate} or
17922 @var{n} argument is known. However, @var{payment} or @var{amount} can
17923 be a variable. Calc expands these functions according to the
17924 formulas below for symbolic arguments only when you use the @kbd{a "}
17925 (@code{calc-expand-formula}) command, or when taking derivatives or
17926 integrals or solving equations involving the functions.
17929 These formulas are shown using the conventions of Big display
17930 mode (@kbd{d B}); for example, the formula for @code{fv} written
17931 linearly is @samp{pmt * ((1 + rate)^n) - 1) / rate}.
17936 fv(rate, n, pmt) = pmt * ---------------
17940 ((1 + rate) - 1) (1 + rate)
17941 fvb(rate, n, pmt) = pmt * ----------------------------
17945 fvl(rate, n, pmt) = pmt * (1 + rate)
17949 pv(rate, n, pmt) = pmt * ----------------
17953 (1 - (1 + rate) ) (1 + rate)
17954 pvb(rate, n, pmt) = pmt * -----------------------------
17958 pvl(rate, n, pmt) = pmt * (1 + rate)
17961 npv(rate, [a, b, c]) = a*(1 + rate) + b*(1 + rate) + c*(1 + rate)
17964 npvb(rate, [a, b, c]) = a + b*(1 + rate) + c*(1 + rate)
17967 (amt - x * (1 + rate) ) * rate
17968 pmt(rate, n, amt, x) = -------------------------------
17973 (amt - x * (1 + rate) ) * rate
17974 pmtb(rate, n, amt, x) = -------------------------------
17976 (1 - (1 + rate) ) (1 + rate)
17979 nper(rate, pmt, amt) = - log(1 - ------------, 1 + rate)
17983 nperb(rate, pmt, amt) = - log(1 - ---------------, 1 + rate)
17987 nperl(rate, pmt, amt) = - log(---, 1 + rate)
17992 ratel(n, pmt, amt) = ------ - 1
17997 sln(cost, salv, life) = -----------
18000 (cost - salv) * (life - per + 1)
18001 syd(cost, salv, life, per) = --------------------------------
18002 life * (life + 1) / 2
18005 ddb(cost, salv, life, per) = --------, book = cost - depreciation so far
18010 $$ \code{fv}(r, n, p) = p { (1 + r)^n - 1 \over r } $$
18011 $$ \code{fvb}(r, n, p) = p { ((1 + r)^n - 1) (1 + r) \over r } $$
18012 $$ \code{fvl}(r, n, p) = p (1 + r)^n $$
18013 $$ \code{pv}(r, n, p) = p { 1 - (1 + r)^{-n} \over r } $$
18014 $$ \code{pvb}(r, n, p) = p { (1 - (1 + r)^{-n}) (1 + r) \over r } $$
18015 $$ \code{pvl}(r, n, p) = p (1 + r)^{-n} $$
18016 $$ \code{npv}(r, [a,b,c]) = a (1 + r)^{-1} + b (1 + r)^{-2} + c (1 + r)^{-3} $$
18017 $$ \code{npvb}(r, [a,b,c]) = a + b (1 + r)^{-1} + c (1 + r)^{-2} $$
18018 $$ \code{pmt}(r, n, a, x) = { (a - x (1 + r)^{-n}) r \over 1 - (1 + r)^{-n} }$$
18019 $$ \code{pmtb}(r, n, a, x) = { (a - x (1 + r)^{-n}) r \over
18020 (1 - (1 + r)^{-n}) (1 + r) } $$
18021 $$ \code{nper}(r, p, a) = -\code{log}(1 - { a r \over p }, 1 + r) $$
18022 $$ \code{nperb}(r, p, a) = -\code{log}(1 - { a r \over p (1 + r) }, 1 + r) $$
18023 $$ \code{nperl}(r, p, a) = -\code{log}({a \over p}, 1 + r) $$
18024 $$ \code{ratel}(n, p, a) = { p^{1/n} \over a^{1/n} } - 1 $$
18025 $$ \code{sln}(c, s, l) = { c - s \over l } $$
18026 $$ \code{syd}(c, s, l, p) = { (c - s) (l - p + 1) \over l (l+1) / 2 } $$
18027 $$ \code{ddb}(c, s, l, p) = { 2 (c - \hbox{depreciation so far}) \over l } $$
18031 In @code{pmt} and @code{pmtb}, @expr{x=0} if omitted.
18033 These functions accept any numeric objects, including error forms,
18034 intervals, and even (though not very usefully) complex numbers. The
18035 above formulas specify exactly the behavior of these functions with
18036 all sorts of inputs.
18038 Note that if the first argument to the @code{log} in @code{nper} is
18039 negative, @code{nper} leaves itself in symbolic form rather than
18040 returning a (financially meaningless) complex number.
18042 @samp{rate(num, pmt, amt)} solves the equation
18043 @samp{pv(rate, num, pmt) = amt} for @samp{rate} using @kbd{H a R}
18044 (@code{calc-find-root}), with the interval @samp{[.01% .. 100%]}
18045 for an initial guess. The @code{rateb} function is the same except
18046 that it uses @code{pvb}. Note that @code{ratel} can be solved
18047 directly; its formula is shown in the above list.
18049 Similarly, @samp{irr(pmts)} solves the equation @samp{npv(rate, pmts) = 0}
18052 If you give a fourth argument to @code{nper} or @code{nperb}, Calc
18053 will also use @kbd{H a R} to solve the equation using an initial
18054 guess interval of @samp{[0 .. 100]}.
18056 A fourth argument to @code{fv} simply sums the two components
18057 calculated from the above formulas for @code{fv} and @code{fvl}.
18058 The same is true of @code{fvb}, @code{pv}, and @code{pvb}.
18060 The @kbd{ddb} function is computed iteratively; the ``book'' value
18061 starts out equal to @var{cost}, and decreases according to the above
18062 formula for the specified number of periods. If the book value
18063 would decrease below @var{salvage}, it only decreases to @var{salvage}
18064 and the depreciation is zero for all subsequent periods. The @code{ddb}
18065 function returns the amount the book value decreased in the specified
18068 @node Binary Functions, , Financial Functions, Arithmetic
18069 @section Binary Number Functions
18072 The commands in this chapter all use two-letter sequences beginning with
18073 the @kbd{b} prefix.
18075 @cindex Binary numbers
18076 The ``binary'' operations actually work regardless of the currently
18077 displayed radix, although their results make the most sense in a radix
18078 like 2, 8, or 16 (as obtained by the @kbd{d 2}, @kbd{d 8}, or @w{@kbd{d 6}}
18079 commands, respectively). You may also wish to enable display of leading
18080 zeros with @kbd{d z}. @xref{Radix Modes}.
18082 @cindex Word size for binary operations
18083 The Calculator maintains a current @dfn{word size} @expr{w}, an
18084 arbitrary positive or negative integer. For a positive word size, all
18085 of the binary operations described here operate modulo @expr{2^w}. In
18086 particular, negative arguments are converted to positive integers modulo
18087 @expr{2^w} by all binary functions.
18089 If the word size is negative, binary operations produce twos-complement
18091 @texline @math{-2^{-w-1}}
18092 @infoline @expr{-(2^(-w-1))}
18094 @texline @math{2^{-w-1}-1}
18095 @infoline @expr{2^(-w-1)-1}
18096 inclusive. Either mode accepts inputs in any range; the sign of
18097 @expr{w} affects only the results produced.
18102 The @kbd{b c} (@code{calc-clip})
18103 [@code{clip}] command can be used to clip a number by reducing it modulo
18104 @expr{2^w}. The commands described in this chapter automatically clip
18105 their results to the current word size. Note that other operations like
18106 addition do not use the current word size, since integer addition
18107 generally is not ``binary.'' (However, @pxref{Simplification Modes},
18108 @code{calc-bin-simplify-mode}.) For example, with a word size of 8
18109 bits @kbd{b c} converts a number to the range 0 to 255; with a word
18110 size of @mathit{-8} @kbd{b c} converts to the range @mathit{-128} to 127.
18113 @pindex calc-word-size
18114 The default word size is 32 bits. All operations except the shifts and
18115 rotates allow you to specify a different word size for that one
18116 operation by giving a numeric prefix argument: @kbd{C-u 8 b c} clips the
18117 top of stack to the range 0 to 255 regardless of the current word size.
18118 To set the word size permanently, use @kbd{b w} (@code{calc-word-size}).
18119 This command displays a prompt with the current word size; press @key{RET}
18120 immediately to keep this word size, or type a new word size at the prompt.
18122 When the binary operations are written in symbolic form, they take an
18123 optional second (or third) word-size parameter. When a formula like
18124 @samp{and(a,b)} is finally evaluated, the word size current at that time
18125 will be used, but when @samp{and(a,b,-8)} is evaluated, a word size of
18126 @mathit{-8} will always be used. A symbolic binary function will be left
18127 in symbolic form unless the all of its argument(s) are integers or
18128 integer-valued floats.
18130 If either or both arguments are modulo forms for which @expr{M} is a
18131 power of two, that power of two is taken as the word size unless a
18132 numeric prefix argument overrides it. The current word size is never
18133 consulted when modulo-power-of-two forms are involved.
18138 The @kbd{b a} (@code{calc-and}) [@code{and}] command computes the bitwise
18139 AND of the two numbers on the top of the stack. In other words, for each
18140 of the @expr{w} binary digits of the two numbers (pairwise), the corresponding
18141 bit of the result is 1 if and only if both input bits are 1:
18142 @samp{and(2#1100, 2#1010) = 2#1000}.
18147 The @kbd{b o} (@code{calc-or}) [@code{or}] command computes the bitwise
18148 inclusive OR of two numbers. A bit is 1 if either of the input bits, or
18149 both, are 1: @samp{or(2#1100, 2#1010) = 2#1110}.
18154 The @kbd{b x} (@code{calc-xor}) [@code{xor}] command computes the bitwise
18155 exclusive OR of two numbers. A bit is 1 if exactly one of the input bits
18156 is 1: @samp{xor(2#1100, 2#1010) = 2#0110}.
18161 The @kbd{b d} (@code{calc-diff}) [@code{diff}] command computes the bitwise
18162 difference of two numbers; this is defined by @samp{diff(a,b) = and(a,not(b))},
18163 so that @samp{diff(2#1100, 2#1010) = 2#0100}.
18168 The @kbd{b n} (@code{calc-not}) [@code{not}] command computes the bitwise
18169 NOT of a number. A bit is 1 if the input bit is 0 and vice-versa.
18172 @pindex calc-lshift-binary
18174 The @kbd{b l} (@code{calc-lshift-binary}) [@code{lsh}] command shifts a
18175 number left by one bit, or by the number of bits specified in the numeric
18176 prefix argument. A negative prefix argument performs a logical right shift,
18177 in which zeros are shifted in on the left. In symbolic form, @samp{lsh(a)}
18178 is short for @samp{lsh(a,1)}, which in turn is short for @samp{lsh(a,n,w)}.
18179 Bits shifted ``off the end,'' according to the current word size, are lost.
18195 The @kbd{H b l} command also does a left shift, but it takes two arguments
18196 from the stack (the value to shift, and, at top-of-stack, the number of
18197 bits to shift). This version interprets the prefix argument just like
18198 the regular binary operations, i.e., as a word size. The Hyperbolic flag
18199 has a similar effect on the rest of the binary shift and rotate commands.
18202 @pindex calc-rshift-binary
18204 The @kbd{b r} (@code{calc-rshift-binary}) [@code{rsh}] command shifts a
18205 number right by one bit, or by the number of bits specified in the numeric
18206 prefix argument: @samp{rsh(a,n) = lsh(a,-n)}.
18209 @pindex calc-lshift-arith
18211 The @kbd{b L} (@code{calc-lshift-arith}) [@code{ash}] command shifts a
18212 number left. It is analogous to @code{lsh}, except that if the shift
18213 is rightward (the prefix argument is negative), an arithmetic shift
18214 is performed as described below.
18217 @pindex calc-rshift-arith
18219 The @kbd{b R} (@code{calc-rshift-arith}) [@code{rash}] command performs
18220 an ``arithmetic'' shift to the right, in which the leftmost bit (according
18221 to the current word size) is duplicated rather than shifting in zeros.
18222 This corresponds to dividing by a power of two where the input is interpreted
18223 as a signed, twos-complement number. (The distinction between the @samp{rsh}
18224 and @samp{rash} operations is totally independent from whether the word
18225 size is positive or negative.) With a negative prefix argument, this
18226 performs a standard left shift.
18229 @pindex calc-rotate-binary
18231 The @kbd{b t} (@code{calc-rotate-binary}) [@code{rot}] command rotates a
18232 number one bit to the left. The leftmost bit (according to the current
18233 word size) is dropped off the left and shifted in on the right. With a
18234 numeric prefix argument, the number is rotated that many bits to the left
18237 @xref{Set Operations}, for the @kbd{b p} and @kbd{b u} commands that
18238 pack and unpack binary integers into sets. (For example, @kbd{b u}
18239 unpacks the number @samp{2#11001} to the set of bit-numbers
18240 @samp{[0, 3, 4]}.) Type @kbd{b u V #} to count the number of ``1''
18241 bits in a binary integer.
18243 Another interesting use of the set representation of binary integers
18244 is to reverse the bits in, say, a 32-bit integer. Type @kbd{b u} to
18245 unpack; type @kbd{31 @key{TAB} -} to replace each bit-number in the set
18246 with 31 minus that bit-number; type @kbd{b p} to pack the set back
18247 into a binary integer.
18249 @node Scientific Functions, Matrix Functions, Arithmetic, Top
18250 @chapter Scientific Functions
18253 The functions described here perform trigonometric and other transcendental
18254 calculations. They generally produce floating-point answers correct to the
18255 full current precision. The @kbd{H} (Hyperbolic) and @kbd{I} (Inverse)
18256 flag keys must be used to get some of these functions from the keyboard.
18260 @cindex @code{pi} variable
18263 @cindex @code{e} variable
18266 @cindex @code{gamma} variable
18268 @cindex Gamma constant, Euler's
18269 @cindex Euler's gamma constant
18271 @cindex @code{phi} variable
18272 @cindex Phi, golden ratio
18273 @cindex Golden ratio
18274 One miscellaneous command is shift-@kbd{P} (@code{calc-pi}), which pushes
18275 the value of @cpi{} (at the current precision) onto the stack. With the
18276 Hyperbolic flag, it pushes the value @expr{e}, the base of natural logarithms.
18277 With the Inverse flag, it pushes Euler's constant
18278 @texline @math{\gamma}
18279 @infoline @expr{gamma}
18280 (about 0.5772). With both Inverse and Hyperbolic, it
18281 pushes the ``golden ratio''
18282 @texline @math{\phi}
18283 @infoline @expr{phi}
18284 (about 1.618). (At present, Euler's constant is not available
18285 to unlimited precision; Calc knows only the first 100 digits.)
18286 In Symbolic mode, these commands push the
18287 actual variables @samp{pi}, @samp{e}, @samp{gamma}, and @samp{phi},
18288 respectively, instead of their values; @pxref{Symbolic Mode}.
18298 The @kbd{Q} (@code{calc-sqrt}) [@code{sqrt}] function is described elsewhere;
18299 @pxref{Basic Arithmetic}. With the Inverse flag [@code{sqr}], this command
18300 computes the square of the argument.
18302 @xref{Prefix Arguments}, for a discussion of the effect of numeric
18303 prefix arguments on commands in this chapter which do not otherwise
18304 interpret a prefix argument.
18307 * Logarithmic Functions::
18308 * Trigonometric and Hyperbolic Functions::
18309 * Advanced Math Functions::
18312 * Combinatorial Functions::
18313 * Probability Distribution Functions::
18316 @node Logarithmic Functions, Trigonometric and Hyperbolic Functions, Scientific Functions, Scientific Functions
18317 @section Logarithmic Functions
18327 The shift-@kbd{L} (@code{calc-ln}) [@code{ln}] command computes the natural
18328 logarithm of the real or complex number on the top of the stack. With
18329 the Inverse flag it computes the exponential function instead, although
18330 this is redundant with the @kbd{E} command.
18339 The shift-@kbd{E} (@code{calc-exp}) [@code{exp}] command computes the
18340 exponential, i.e., @expr{e} raised to the power of the number on the stack.
18341 The meanings of the Inverse and Hyperbolic flags follow from those for
18342 the @code{calc-ln} command.
18357 The @kbd{H L} (@code{calc-log10}) [@code{log10}] command computes the common
18358 (base-10) logarithm of a number. (With the Inverse flag [@code{exp10}],
18359 it raises ten to a given power.) Note that the common logarithm of a
18360 complex number is computed by taking the natural logarithm and dividing
18362 @texline @math{\ln10}.
18363 @infoline @expr{ln(10)}.
18370 The @kbd{B} (@code{calc-log}) [@code{log}] command computes a logarithm
18371 to any base. For example, @kbd{1024 @key{RET} 2 B} produces 10, since
18372 @texline @math{2^{10} = 1024}.
18373 @infoline @expr{2^10 = 1024}.
18374 In certain cases like @samp{log(3,9)}, the result
18375 will be either @expr{1:2} or @expr{0.5} depending on the current Fraction
18376 mode setting. With the Inverse flag [@code{alog}], this command is
18377 similar to @kbd{^} except that the order of the arguments is reversed.
18382 The @kbd{f I} (@code{calc-ilog}) [@code{ilog}] command computes the
18383 integer logarithm of a number to any base. The number and the base must
18384 themselves be positive integers. This is the true logarithm, rounded
18385 down to an integer. Thus @kbd{ilog(x,10)} is 3 for all @expr{x} in the
18386 range from 1000 to 9999. If both arguments are positive integers, exact
18387 integer arithmetic is used; otherwise, this is equivalent to
18388 @samp{floor(log(x,b))}.
18393 The @kbd{f E} (@code{calc-expm1}) [@code{expm1}] command computes
18394 @texline @math{e^x - 1},
18395 @infoline @expr{exp(x)-1},
18396 but using an algorithm that produces a more accurate
18397 answer when the result is close to zero, i.e., when
18398 @texline @math{e^x}
18399 @infoline @expr{exp(x)}
18405 The @kbd{f L} (@code{calc-lnp1}) [@code{lnp1}] command computes
18406 @texline @math{\ln(x+1)},
18407 @infoline @expr{ln(x+1)},
18408 producing a more accurate answer when @expr{x} is close to zero.
18410 @node Trigonometric and Hyperbolic Functions, Advanced Math Functions, Logarithmic Functions, Scientific Functions
18411 @section Trigonometric/Hyperbolic Functions
18417 The shift-@kbd{S} (@code{calc-sin}) [@code{sin}] command computes the sine
18418 of an angle or complex number. If the input is an HMS form, it is interpreted
18419 as degrees-minutes-seconds; otherwise, the input is interpreted according
18420 to the current angular mode. It is best to use Radians mode when operating
18421 on complex numbers.
18423 Calc's ``units'' mechanism includes angular units like @code{deg},
18424 @code{rad}, and @code{grad}. While @samp{sin(45 deg)} is not evaluated
18425 all the time, the @kbd{u s} (@code{calc-simplify-units}) command will
18426 simplify @samp{sin(45 deg)} by taking the sine of 45 degrees, regardless
18427 of the current angular mode. @xref{Basic Operations on Units}.
18429 Also, the symbolic variable @code{pi} is not ordinarily recognized in
18430 arguments to trigonometric functions, as in @samp{sin(3 pi / 4)}, but
18431 the default algebraic simplifications recognize many such
18432 formulas when the current angular mode is Radians @emph{and} Symbolic
18433 mode is enabled; this example would be replaced by @samp{sqrt(2) / 2}.
18434 @xref{Symbolic Mode}. Beware, this simplification occurs even if you
18435 have stored a different value in the variable @samp{pi}; this is one
18436 reason why changing built-in variables is a bad idea. Arguments of
18437 the form @expr{x} plus a multiple of @cpiover{2} are also simplified.
18438 Calc includes similar formulas for @code{cos} and @code{tan}.
18440 Calc's algebraic simplifications know all angles which are integer multiples of
18441 @cpiover{12}, @cpiover{10}, or @cpiover{8} radians. In Degrees mode,
18442 analogous simplifications occur for integer multiples of 15 or 18
18443 degrees, and for arguments plus multiples of 90 degrees.
18446 @pindex calc-arcsin
18448 With the Inverse flag, @code{calc-sin} computes an arcsine. This is also
18449 available as the @code{calc-arcsin} command or @code{arcsin} algebraic
18450 function. The returned argument is converted to degrees, radians, or HMS
18451 notation depending on the current angular mode.
18457 @pindex calc-arcsinh
18459 With the Hyperbolic flag, @code{calc-sin} computes the hyperbolic
18460 sine, also available as @code{calc-sinh} [@code{sinh}]. With the
18461 Hyperbolic and Inverse flags, it computes the hyperbolic arcsine
18462 (@code{calc-arcsinh}) [@code{arcsinh}].
18471 @pindex calc-arccos
18489 @pindex calc-arccosh
18507 @pindex calc-arctan
18525 @pindex calc-arctanh
18530 The shift-@kbd{C} (@code{calc-cos}) [@code{cos}] command computes the cosine
18531 of an angle or complex number, and shift-@kbd{T} (@code{calc-tan}) [@code{tan}]
18532 computes the tangent, along with all the various inverse and hyperbolic
18533 variants of these functions.
18536 @pindex calc-arctan2
18538 The @kbd{f T} (@code{calc-arctan2}) [@code{arctan2}] command takes two
18539 numbers from the stack and computes the arc tangent of their ratio. The
18540 result is in the full range from @mathit{-180} (exclusive) to @mathit{+180}
18541 (inclusive) degrees, or the analogous range in radians. A similar
18542 result would be obtained with @kbd{/} followed by @kbd{I T}, but the
18543 value would only be in the range from @mathit{-90} to @mathit{+90} degrees
18544 since the division loses information about the signs of the two
18545 components, and an error might result from an explicit division by zero
18546 which @code{arctan2} would avoid. By (arbitrary) definition,
18547 @samp{arctan2(0,0)=0}.
18549 @pindex calc-sincos
18561 The @code{calc-sincos} [@code{sincos}] command computes the sine and
18562 cosine of a number, returning them as a vector of the form
18563 @samp{[@var{cos}, @var{sin}]}.
18564 With the Inverse flag [@code{arcsincos}], this command takes a two-element
18565 vector as an argument and computes @code{arctan2} of the elements.
18566 (This command does not accept the Hyperbolic flag.)
18580 The remaining trigonometric functions, @code{calc-sec} [@code{sec}],
18581 @code{calc-csc} [@code{csc}] and @code{calc-cot} [@code{cot}], are also
18582 available. With the Hyperbolic flag, these compute their hyperbolic
18583 counterparts, which are also available separately as @code{calc-sech}
18584 [@code{sech}], @code{calc-csch} [@code{csch}] and @code{calc-coth}
18585 [@code{coth}]. (These commands do not accept the Inverse flag.)
18587 @node Advanced Math Functions, Branch Cuts, Trigonometric and Hyperbolic Functions, Scientific Functions
18588 @section Advanced Mathematical Functions
18591 Calc can compute a variety of less common functions that arise in
18592 various branches of mathematics. All of the functions described in
18593 this section allow arbitrary complex arguments and, except as noted,
18594 will work to arbitrarily large precision. They can not at present
18595 handle error forms or intervals as arguments.
18597 NOTE: These functions are still experimental. In particular, their
18598 accuracy is not guaranteed in all domains. It is advisable to set the
18599 current precision comfortably higher than you actually need when
18600 using these functions. Also, these functions may be impractically
18601 slow for some values of the arguments.
18606 The @kbd{f g} (@code{calc-gamma}) [@code{gamma}] command computes the Euler
18607 gamma function. For positive integer arguments, this is related to the
18608 factorial function: @samp{gamma(n+1) = fact(n)}. For general complex
18609 arguments the gamma function can be defined by the following definite
18611 @texline @math{\Gamma(a) = \int_0^\infty t^{a-1} e^t dt}.
18612 @infoline @expr{gamma(a) = integ(t^(a-1) exp(t), t, 0, inf)}.
18613 (The actual implementation uses far more efficient computational methods.)
18629 @pindex calc-inc-gamma
18642 The @kbd{f G} (@code{calc-inc-gamma}) [@code{gammaP}] command computes
18643 the incomplete gamma function, denoted @samp{P(a,x)}. This is defined by
18645 @texline @math{P(a,x) = \left( \int_0^x t^{a-1} e^t dt \right) / \Gamma(a)}.
18646 @infoline @expr{gammaP(a,x) = integ(t^(a-1) exp(t), t, 0, x) / gamma(a)}.
18647 This implies that @samp{gammaP(a,inf) = 1} for any @expr{a} (see the
18648 definition of the normal gamma function).
18650 Several other varieties of incomplete gamma function are defined.
18651 The complement of @expr{P(a,x)}, called @expr{Q(a,x) = 1-P(a,x)} by
18652 some authors, is computed by the @kbd{I f G} [@code{gammaQ}] command.
18653 You can think of this as taking the other half of the integral, from
18654 @expr{x} to infinity.
18657 The functions corresponding to the integrals that define @expr{P(a,x)}
18658 and @expr{Q(a,x)} but without the normalizing @expr{1/gamma(a)}
18659 factor are called @expr{g(a,x)} and @expr{G(a,x)}, respectively
18660 (where @expr{g} and @expr{G} represent the lower- and upper-case Greek
18661 letter gamma). You can obtain these using the @kbd{H f G} [@code{gammag}]
18662 and @kbd{H I f G} [@code{gammaG}] commands.
18665 The functions corresponding to the integrals that define $P(a,x)$
18666 and $Q(a,x)$ but without the normalizing $1/\Gamma(a)$
18667 factor are called $\gamma(a,x)$ and $\Gamma(a,x)$, respectively.
18668 You can obtain these using the \kbd{H f G} [\code{gammag}] and
18669 \kbd{I H f G} [\code{gammaG}] commands.
18675 The @kbd{f b} (@code{calc-beta}) [@code{beta}] command computes the
18676 Euler beta function, which is defined in terms of the gamma function as
18677 @texline @math{B(a,b) = \Gamma(a) \Gamma(b) / \Gamma(a+b)},
18678 @infoline @expr{beta(a,b) = gamma(a) gamma(b) / gamma(a+b)},
18680 @texline @math{B(a,b) = \int_0^1 t^{a-1} (1-t)^{b-1} dt}.
18681 @infoline @expr{beta(a,b) = integ(t^(a-1) (1-t)^(b-1), t, 0, 1)}.
18685 @pindex calc-inc-beta
18688 The @kbd{f B} (@code{calc-inc-beta}) [@code{betaI}] command computes
18689 the incomplete beta function @expr{I(x,a,b)}. It is defined by
18690 @texline @math{I(x,a,b) = \left( \int_0^x t^{a-1} (1-t)^{b-1} dt \right) / B(a,b)}.
18691 @infoline @expr{betaI(x,a,b) = integ(t^(a-1) (1-t)^(b-1), t, 0, x) / beta(a,b)}.
18692 Once again, the @kbd{H} (hyperbolic) prefix gives the corresponding
18693 un-normalized version [@code{betaB}].
18700 The @kbd{f e} (@code{calc-erf}) [@code{erf}] command computes the
18702 @texline @math{\hbox{erf}(x) = {2 \over \sqrt{\pi}} \int_0^x e^{-t^2} dt}.
18703 @infoline @expr{erf(x) = 2 integ(exp(-(t^2)), t, 0, x) / sqrt(pi)}.
18704 The complementary error function @kbd{I f e} (@code{calc-erfc}) [@code{erfc}]
18705 is the corresponding integral from @samp{x} to infinity; the sum
18706 @texline @math{\hbox{erf}(x) + \hbox{erfc}(x) = 1}.
18707 @infoline @expr{erf(x) + erfc(x) = 1}.
18711 @pindex calc-bessel-J
18712 @pindex calc-bessel-Y
18715 The @kbd{f j} (@code{calc-bessel-J}) [@code{besJ}] and @kbd{f y}
18716 (@code{calc-bessel-Y}) [@code{besY}] commands compute the Bessel
18717 functions of the first and second kinds, respectively.
18718 In @samp{besJ(n,x)} and @samp{besY(n,x)} the ``order'' parameter
18719 @expr{n} is often an integer, but is not required to be one.
18720 Calc's implementation of the Bessel functions currently limits the
18721 precision to 8 digits, and may not be exact even to that precision.
18724 @node Branch Cuts, Random Numbers, Advanced Math Functions, Scientific Functions
18725 @section Branch Cuts and Principal Values
18728 @cindex Branch cuts
18729 @cindex Principal values
18730 All of the logarithmic, trigonometric, and other scientific functions are
18731 defined for complex numbers as well as for reals.
18732 This section describes the values
18733 returned in cases where the general result is a family of possible values.
18734 Calc follows section 12.5.3 of Steele's @dfn{Common Lisp, the Language},
18735 second edition, in these matters. This section will describe each
18736 function briefly; for a more detailed discussion (including some nifty
18737 diagrams), consult Steele's book.
18739 Note that the branch cuts for @code{arctan} and @code{arctanh} were
18740 changed between the first and second editions of Steele. Recent
18741 versions of Calc follow the second edition.
18743 The new branch cuts exactly match those of the HP-28/48 calculators.
18744 They also match those of Mathematica 1.2, except that Mathematica's
18745 @code{arctan} cut is always in the right half of the complex plane,
18746 and its @code{arctanh} cut is always in the top half of the plane.
18747 Calc's cuts are continuous with quadrants I and III for @code{arctan},
18748 or II and IV for @code{arctanh}.
18750 Note: The current implementations of these functions with complex arguments
18751 are designed with proper behavior around the branch cuts in mind, @emph{not}
18752 efficiency or accuracy. You may need to increase the floating precision
18753 and wait a while to get suitable answers from them.
18755 For @samp{sqrt(a+bi)}: When @expr{a<0} and @expr{b} is small but positive
18756 or zero, the result is close to the @expr{+i} axis. For @expr{b} small and
18757 negative, the result is close to the @expr{-i} axis. The result always lies
18758 in the right half of the complex plane.
18760 For @samp{ln(a+bi)}: The real part is defined as @samp{ln(abs(a+bi))}.
18761 The imaginary part is defined as @samp{arg(a+bi) = arctan2(b,a)}.
18762 Thus the branch cuts for @code{sqrt} and @code{ln} both lie on the
18763 negative real axis.
18765 The following table describes these branch cuts in another way.
18766 If the real and imaginary parts of @expr{z} are as shown, then
18767 the real and imaginary parts of @expr{f(z)} will be as shown.
18768 Here @code{eps} stands for a small positive value; each
18769 occurrence of @code{eps} may stand for a different small value.
18773 ----------------------------------------
18776 -, +eps +eps, + +eps, +
18777 -, -eps +eps, - +eps, -
18780 For @samp{z1^z2}: This is defined by @samp{exp(ln(z1)*z2)}.
18781 One interesting consequence of this is that @samp{(-8)^1:3} does
18782 not evaluate to @mathit{-2} as you might expect, but to the complex
18783 number @expr{(1., 1.732)}. Both of these are valid cube roots
18784 of @mathit{-8} (as is @expr{(1., -1.732)}); Calc chooses a perhaps
18785 less-obvious root for the sake of mathematical consistency.
18787 For @samp{arcsin(z)}: This is defined by @samp{-i*ln(i*z + sqrt(1-z^2))}.
18788 The branch cuts are on the real axis, less than @mathit{-1} and greater than 1.
18790 For @samp{arccos(z)}: This is defined by @samp{-i*ln(z + i*sqrt(1-z^2))},
18791 or equivalently by @samp{pi/2 - arcsin(z)}. The branch cuts are on
18792 the real axis, less than @mathit{-1} and greater than 1.
18794 For @samp{arctan(z)}: This is defined by
18795 @samp{(ln(1+i*z) - ln(1-i*z)) / (2*i)}. The branch cuts are on the
18796 imaginary axis, below @expr{-i} and above @expr{i}.
18798 For @samp{arcsinh(z)}: This is defined by @samp{ln(z + sqrt(1+z^2))}.
18799 The branch cuts are on the imaginary axis, below @expr{-i} and
18802 For @samp{arccosh(z)}: This is defined by
18803 @samp{ln(z + (z+1)*sqrt((z-1)/(z+1)))}. The branch cut is on the
18804 real axis less than 1.
18806 For @samp{arctanh(z)}: This is defined by @samp{(ln(1+z) - ln(1-z)) / 2}.
18807 The branch cuts are on the real axis, less than @mathit{-1} and greater than 1.
18809 The following tables for @code{arcsin}, @code{arccos}, and
18810 @code{arctan} assume the current angular mode is Radians. The
18811 hyperbolic functions operate independently of the angular mode.
18814 z arcsin(z) arccos(z)
18815 -------------------------------------------------------
18816 (-1..1), 0 (-pi/2..pi/2), 0 (0..pi), 0
18817 (-1..1), +eps (-pi/2..pi/2), +eps (0..pi), -eps
18818 (-1..1), -eps (-pi/2..pi/2), -eps (0..pi), +eps
18819 <-1, 0 -pi/2, + pi, -
18820 <-1, +eps -pi/2 + eps, + pi - eps, -
18821 <-1, -eps -pi/2 + eps, - pi - eps, +
18823 >1, +eps pi/2 - eps, + +eps, -
18824 >1, -eps pi/2 - eps, - +eps, +
18828 z arccosh(z) arctanh(z)
18829 -----------------------------------------------------
18830 (-1..1), 0 0, (0..pi) any, 0
18831 (-1..1), +eps +eps, (0..pi) any, +eps
18832 (-1..1), -eps +eps, (-pi..0) any, -eps
18833 <-1, 0 +, pi -, pi/2
18834 <-1, +eps +, pi - eps -, pi/2 - eps
18835 <-1, -eps +, -pi + eps -, -pi/2 + eps
18836 >1, 0 +, 0 +, -pi/2
18837 >1, +eps +, +eps +, pi/2 - eps
18838 >1, -eps +, -eps +, -pi/2 + eps
18842 z arcsinh(z) arctan(z)
18843 -----------------------------------------------------
18844 0, (-1..1) 0, (-pi/2..pi/2) 0, any
18845 0, <-1 -, -pi/2 -pi/2, -
18846 +eps, <-1 +, -pi/2 + eps pi/2 - eps, -
18847 -eps, <-1 -, -pi/2 + eps -pi/2 + eps, -
18848 0, >1 +, pi/2 pi/2, +
18849 +eps, >1 +, pi/2 - eps pi/2 - eps, +
18850 -eps, >1 -, pi/2 - eps -pi/2 + eps, +
18853 Finally, the following identities help to illustrate the relationship
18854 between the complex trigonometric and hyperbolic functions. They
18855 are valid everywhere, including on the branch cuts.
18858 sin(i*z) = i*sinh(z) arcsin(i*z) = i*arcsinh(z)
18859 cos(i*z) = cosh(z) arcsinh(i*z) = i*arcsin(z)
18860 tan(i*z) = i*tanh(z) arctan(i*z) = i*arctanh(z)
18861 sinh(i*z) = i*sin(z) cosh(i*z) = cos(z)
18864 The ``advanced math'' functions (gamma, Bessel, etc.@:) are also defined
18865 for general complex arguments, but their branch cuts and principal values
18866 are not rigorously specified at present.
18868 @node Random Numbers, Combinatorial Functions, Branch Cuts, Scientific Functions
18869 @section Random Numbers
18873 @pindex calc-random
18875 The @kbd{k r} (@code{calc-random}) [@code{random}] command produces
18876 random numbers of various sorts.
18878 Given a positive numeric prefix argument @expr{M}, it produces a random
18879 integer @expr{N} in the range
18880 @texline @math{0 \le N < M}.
18881 @infoline @expr{0 <= N < M}.
18882 Each possible value @expr{N} appears with equal probability.
18884 With no numeric prefix argument, the @kbd{k r} command takes its argument
18885 from the stack instead. Once again, if this is a positive integer @expr{M}
18886 the result is a random integer less than @expr{M}. However, note that
18887 while numeric prefix arguments are limited to six digits or so, an @expr{M}
18888 taken from the stack can be arbitrarily large. If @expr{M} is negative,
18889 the result is a random integer in the range
18890 @texline @math{M < N \le 0}.
18891 @infoline @expr{M < N <= 0}.
18893 If the value on the stack is a floating-point number @expr{M}, the result
18894 is a random floating-point number @expr{N} in the range
18895 @texline @math{0 \le N < M}
18896 @infoline @expr{0 <= N < M}
18898 @texline @math{M < N \le 0},
18899 @infoline @expr{M < N <= 0},
18900 according to the sign of @expr{M}.
18902 If @expr{M} is zero, the result is a Gaussian-distributed random real
18903 number; the distribution has a mean of zero and a standard deviation
18904 of one. The algorithm used generates random numbers in pairs; thus,
18905 every other call to this function will be especially fast.
18907 If @expr{M} is an error form
18908 @texline @math{m} @code{+/-} @math{\sigma}
18909 @infoline @samp{m +/- s}
18911 @texline @math{\sigma}
18913 are both real numbers, the result uses a Gaussian distribution with mean
18914 @var{m} and standard deviation
18915 @texline @math{\sigma}.
18918 If @expr{M} is an interval form, the lower and upper bounds specify the
18919 acceptable limits of the random numbers. If both bounds are integers,
18920 the result is a random integer in the specified range. If either bound
18921 is floating-point, the result is a random real number in the specified
18922 range. If the interval is open at either end, the result will be sure
18923 not to equal that end value. (This makes a big difference for integer
18924 intervals, but for floating-point intervals it's relatively minor:
18925 with a precision of 6, @samp{random([1.0..2.0))} will return any of one
18926 million numbers from 1.00000 to 1.99999; @samp{random([1.0..2.0])} may
18927 additionally return 2.00000, but the probability of this happening is
18930 If @expr{M} is a vector, the result is one element taken at random from
18931 the vector. All elements of the vector are given equal probabilities.
18934 The sequence of numbers produced by @kbd{k r} is completely random by
18935 default, i.e., the sequence is seeded each time you start Calc using
18936 the current time and other information. You can get a reproducible
18937 sequence by storing a particular ``seed value'' in the Calc variable
18938 @code{RandSeed}. Any integer will do for a seed; integers of from 1
18939 to 12 digits are good. If you later store a different integer into
18940 @code{RandSeed}, Calc will switch to a different pseudo-random
18941 sequence. If you ``unstore'' @code{RandSeed}, Calc will re-seed itself
18942 from the current time. If you store the same integer that you used
18943 before back into @code{RandSeed}, you will get the exact same sequence
18944 of random numbers as before.
18946 @pindex calc-rrandom
18947 The @code{calc-rrandom} command (not on any key) produces a random real
18948 number between zero and one. It is equivalent to @samp{random(1.0)}.
18951 @pindex calc-random-again
18952 The @kbd{k a} (@code{calc-random-again}) command produces another random
18953 number, re-using the most recent value of @expr{M}. With a numeric
18954 prefix argument @var{n}, it produces @var{n} more random numbers using
18955 that value of @expr{M}.
18958 @pindex calc-shuffle
18960 The @kbd{k h} (@code{calc-shuffle}) command produces a vector of several
18961 random values with no duplicates. The value on the top of the stack
18962 specifies the set from which the random values are drawn, and may be any
18963 of the @expr{M} formats described above. The numeric prefix argument
18964 gives the length of the desired list. (If you do not provide a numeric
18965 prefix argument, the length of the list is taken from the top of the
18966 stack, and @expr{M} from second-to-top.)
18968 If @expr{M} is a floating-point number, zero, or an error form (so
18969 that the random values are being drawn from the set of real numbers)
18970 there is little practical difference between using @kbd{k h} and using
18971 @kbd{k r} several times. But if the set of possible values consists
18972 of just a few integers, or the elements of a vector, then there is
18973 a very real chance that multiple @kbd{k r}'s will produce the same
18974 number more than once. The @kbd{k h} command produces a vector whose
18975 elements are always distinct. (Actually, there is a slight exception:
18976 If @expr{M} is a vector, no given vector element will be drawn more
18977 than once, but if several elements of @expr{M} are equal, they may
18978 each make it into the result vector.)
18980 One use of @kbd{k h} is to rearrange a list at random. This happens
18981 if the prefix argument is equal to the number of values in the list:
18982 @kbd{[1, 1.5, 2, 2.5, 3] 5 k h} might produce the permuted list
18983 @samp{[2.5, 1, 1.5, 3, 2]}. As a convenient feature, if the argument
18984 @var{n} is negative it is replaced by the size of the set represented
18985 by @expr{M}. Naturally, this is allowed only when @expr{M} specifies
18986 a small discrete set of possibilities.
18988 To do the equivalent of @kbd{k h} but with duplications allowed,
18989 given @expr{M} on the stack and with @var{n} just entered as a numeric
18990 prefix, use @kbd{v b} to build a vector of copies of @expr{M}, then use
18991 @kbd{V M k r} to ``map'' the normal @kbd{k r} function over the
18992 elements of this vector. @xref{Matrix Functions}.
18995 * Random Number Generator:: (Complete description of Calc's algorithm)
18998 @node Random Number Generator, , Random Numbers, Random Numbers
18999 @subsection Random Number Generator
19001 Calc's random number generator uses several methods to ensure that
19002 the numbers it produces are highly random. Knuth's @emph{Art of
19003 Computer Programming}, Volume II, contains a thorough description
19004 of the theory of random number generators and their measurement and
19007 If @code{RandSeed} has no stored value, Calc calls Emacs's built-in
19008 @code{random} function to get a stream of random numbers, which it
19009 then treats in various ways to avoid problems inherent in the simple
19010 random number generators that many systems use to implement @code{random}.
19012 When Calc's random number generator is first invoked, it ``seeds''
19013 the low-level random sequence using the time of day, so that the
19014 random number sequence will be different every time you use Calc.
19016 Since Emacs Lisp doesn't specify the range of values that will be
19017 returned by its @code{random} function, Calc exercises the function
19018 several times to estimate the range. When Calc subsequently uses
19019 the @code{random} function, it takes only 10 bits of the result
19020 near the most-significant end. (It avoids at least the bottom
19021 four bits, preferably more, and also tries to avoid the top two
19022 bits.) This strategy works well with the linear congruential
19023 generators that are typically used to implement @code{random}.
19025 If @code{RandSeed} contains an integer, Calc uses this integer to
19026 seed an ``additive congruential'' method (Knuth's algorithm 3.2.2A,
19028 @texline @math{X_{n-55} - X_{n-24}}.
19029 @infoline @expr{X_n-55 - X_n-24}).
19030 This method expands the seed
19031 value into a large table which is maintained internally; the variable
19032 @code{RandSeed} is changed from, e.g., 42 to the vector @expr{[42]}
19033 to indicate that the seed has been absorbed into this table. When
19034 @code{RandSeed} contains a vector, @kbd{k r} and related commands
19035 continue to use the same internal table as last time. There is no
19036 way to extract the complete state of the random number generator
19037 so that you can restart it from any point; you can only restart it
19038 from the same initial seed value. A simple way to restart from the
19039 same seed is to type @kbd{s r RandSeed} to get the seed vector,
19040 @kbd{v u} to unpack it back into a number, then @kbd{s t RandSeed}
19041 to reseed the generator with that number.
19043 Calc uses a ``shuffling'' method as described in algorithm 3.2.2B
19044 of Knuth. It fills a table with 13 random 10-bit numbers. Then,
19045 to generate a new random number, it uses the previous number to
19046 index into the table, picks the value it finds there as the new
19047 random number, then replaces that table entry with a new value
19048 obtained from a call to the base random number generator (either
19049 the additive congruential generator or the @code{random} function
19050 supplied by the system). If there are any flaws in the base
19051 generator, shuffling will tend to even them out. But if the system
19052 provides an excellent @code{random} function, shuffling will not
19053 damage its randomness.
19055 To create a random integer of a certain number of digits, Calc
19056 builds the integer three decimal digits at a time. For each group
19057 of three digits, Calc calls its 10-bit shuffling random number generator
19058 (which returns a value from 0 to 1023); if the random value is 1000
19059 or more, Calc throws it out and tries again until it gets a suitable
19062 To create a random floating-point number with precision @var{p}, Calc
19063 simply creates a random @var{p}-digit integer and multiplies by
19064 @texline @math{10^{-p}}.
19065 @infoline @expr{10^-p}.
19066 The resulting random numbers should be very clean, but note
19067 that relatively small numbers will have few significant random digits.
19068 In other words, with a precision of 12, you will occasionally get
19069 numbers on the order of
19070 @texline @math{10^{-9}}
19071 @infoline @expr{10^-9}
19073 @texline @math{10^{-10}},
19074 @infoline @expr{10^-10},
19075 but those numbers will only have two or three random digits since they
19076 correspond to small integers times
19077 @texline @math{10^{-12}}.
19078 @infoline @expr{10^-12}.
19080 To create a random integer in the interval @samp{[0 .. @var{m})}, Calc
19081 counts the digits in @var{m}, creates a random integer with three
19082 additional digits, then reduces modulo @var{m}. Unless @var{m} is a
19083 power of ten the resulting values will be very slightly biased toward
19084 the lower numbers, but this bias will be less than 0.1%. (For example,
19085 if @var{m} is 42, Calc will reduce a random integer less than 100000
19086 modulo 42 to get a result less than 42. It is easy to show that the
19087 numbers 40 and 41 will be only 2380/2381 as likely to result from this
19088 modulo operation as numbers 39 and below.) If @var{m} is a power of
19089 ten, however, the numbers should be completely unbiased.
19091 The Gaussian random numbers generated by @samp{random(0.0)} use the
19092 ``polar'' method described in Knuth section 3.4.1C@. This method
19093 generates a pair of Gaussian random numbers at a time, so only every
19094 other call to @samp{random(0.0)} will require significant calculations.
19096 @node Combinatorial Functions, Probability Distribution Functions, Random Numbers, Scientific Functions
19097 @section Combinatorial Functions
19100 Commands relating to combinatorics and number theory begin with the
19101 @kbd{k} key prefix.
19106 The @kbd{k g} (@code{calc-gcd}) [@code{gcd}] command computes the
19107 Greatest Common Divisor of two integers. It also accepts fractions;
19108 the GCD of two fractions is defined by taking the GCD of the
19109 numerators, and the LCM of the denominators. This definition is
19110 consistent with the idea that @samp{a / gcd(a,x)} should yield an
19111 integer for any @samp{a} and @samp{x}. For other types of arguments,
19112 the operation is left in symbolic form.
19117 The @kbd{k l} (@code{calc-lcm}) [@code{lcm}] command computes the
19118 Least Common Multiple of two integers or fractions. The product of
19119 the LCM and GCD of two numbers is equal to the product of the
19123 @pindex calc-extended-gcd
19125 The @kbd{k E} (@code{calc-extended-gcd}) [@code{egcd}] command computes
19126 the GCD of two integers @expr{x} and @expr{y} and returns a vector
19127 @expr{[g, a, b]} where
19128 @texline @math{g = \gcd(x,y) = a x + b y}.
19129 @infoline @expr{g = gcd(x,y) = a x + b y}.
19132 @pindex calc-factorial
19138 The @kbd{!} (@code{calc-factorial}) [@code{fact}] command computes the
19139 factorial of the number at the top of the stack. If the number is an
19140 integer, the result is an exact integer. If the number is an
19141 integer-valued float, the result is a floating-point approximation. If
19142 the number is a non-integral real number, the generalized factorial is used,
19143 as defined by the Euler Gamma function. Please note that computation of
19144 large factorials can be slow; using floating-point format will help
19145 since fewer digits must be maintained. The same is true of many of
19146 the commands in this section.
19149 @pindex calc-double-factorial
19155 The @kbd{k d} (@code{calc-double-factorial}) [@code{dfact}] command
19156 computes the ``double factorial'' of an integer. For an even integer,
19157 this is the product of even integers from 2 to @expr{N}. For an odd
19158 integer, this is the product of odd integers from 3 to @expr{N}. If
19159 the argument is an integer-valued float, the result is a floating-point
19160 approximation. This function is undefined for negative even integers.
19161 The notation @expr{N!!} is also recognized for double factorials.
19164 @pindex calc-choose
19166 The @kbd{k c} (@code{calc-choose}) [@code{choose}] command computes the
19167 binomial coefficient @expr{N}-choose-@expr{M}, where @expr{M} is the number
19168 on the top of the stack and @expr{N} is second-to-top. If both arguments
19169 are integers, the result is an exact integer. Otherwise, the result is a
19170 floating-point approximation. The binomial coefficient is defined for all
19172 @texline @math{N! \over M! (N-M)!\,}.
19173 @infoline @expr{N! / M! (N-M)!}.
19179 The @kbd{H k c} (@code{calc-perm}) [@code{perm}] command computes the
19180 number-of-permutations function @expr{N! / (N-M)!}.
19183 The \kbd{H k c} (\code{calc-perm}) [\code{perm}] command computes the
19184 number-of-perm\-utations function $N! \over (N-M)!\,$.
19189 @pindex calc-bernoulli-number
19191 The @kbd{k b} (@code{calc-bernoulli-number}) [@code{bern}] command
19192 computes a given Bernoulli number. The value at the top of the stack
19193 is a nonnegative integer @expr{n} that specifies which Bernoulli number
19194 is desired. The @kbd{H k b} command computes a Bernoulli polynomial,
19195 taking @expr{n} from the second-to-top position and @expr{x} from the
19196 top of the stack. If @expr{x} is a variable or formula the result is
19197 a polynomial in @expr{x}; if @expr{x} is a number the result is a number.
19201 @pindex calc-euler-number
19203 The @kbd{k e} (@code{calc-euler-number}) [@code{euler}] command similarly
19204 computes an Euler number, and @w{@kbd{H k e}} computes an Euler polynomial.
19205 Bernoulli and Euler numbers occur in the Taylor expansions of several
19210 @pindex calc-stirling-number
19213 The @kbd{k s} (@code{calc-stirling-number}) [@code{stir1}] command
19214 computes a Stirling number of the first
19215 @texline kind@tie{}@math{n \brack m},
19217 given two integers @expr{n} and @expr{m} on the stack. The @kbd{H k s}
19218 [@code{stir2}] command computes a Stirling number of the second
19219 @texline kind@tie{}@math{n \brace m}.
19221 These are the number of @expr{m}-cycle permutations of @expr{n} objects,
19222 and the number of ways to partition @expr{n} objects into @expr{m}
19223 non-empty sets, respectively.
19226 @pindex calc-prime-test
19228 The @kbd{k p} (@code{calc-prime-test}) command checks if the integer on
19229 the top of the stack is prime. For integers less than eight million, the
19230 answer is always exact and reasonably fast. For larger integers, a
19231 probabilistic method is used (see Knuth vol. II, section 4.5.4, algorithm P).
19232 The number is first checked against small prime factors (up to 13). Then,
19233 any number of iterations of the algorithm are performed. Each step either
19234 discovers that the number is non-prime, or substantially increases the
19235 certainty that the number is prime. After a few steps, the chance that
19236 a number was mistakenly described as prime will be less than one percent.
19237 (Indeed, this is a worst-case estimate of the probability; in practice
19238 even a single iteration is quite reliable.) After the @kbd{k p} command,
19239 the number will be reported as definitely prime or non-prime if possible,
19240 or otherwise ``probably'' prime with a certain probability of error.
19246 The normal @kbd{k p} command performs one iteration of the primality
19247 test. Pressing @kbd{k p} repeatedly for the same integer will perform
19248 additional iterations. Also, @kbd{k p} with a numeric prefix performs
19249 the specified number of iterations. There is also an algebraic function
19250 @samp{prime(n)} or @samp{prime(n,iters)} which returns 1 if @expr{n}
19251 is (probably) prime and 0 if not.
19254 @pindex calc-prime-factors
19256 The @kbd{k f} (@code{calc-prime-factors}) [@code{prfac}] command
19257 attempts to decompose an integer into its prime factors. For numbers up
19258 to 25 million, the answer is exact although it may take some time. The
19259 result is a vector of the prime factors in increasing order. For larger
19260 inputs, prime factors above 5000 may not be found, in which case the
19261 last number in the vector will be an unfactored integer greater than 25
19262 million (with a warning message). For negative integers, the first
19263 element of the list will be @mathit{-1}. For inputs @mathit{-1}, @mathit{0}, and
19264 @mathit{1}, the result is a list of the same number.
19267 @pindex calc-next-prime
19269 @mindex nextpr@idots
19272 The @kbd{k n} (@code{calc-next-prime}) [@code{nextprime}] command finds
19273 the next prime above a given number. Essentially, it searches by calling
19274 @code{calc-prime-test} on successive integers until it finds one that
19275 passes the test. This is quite fast for integers less than eight million,
19276 but once the probabilistic test comes into play the search may be rather
19277 slow. Ordinarily this command stops for any prime that passes one iteration
19278 of the primality test. With a numeric prefix argument, a number must pass
19279 the specified number of iterations before the search stops. (This only
19280 matters when searching above eight million.) You can always use additional
19281 @kbd{k p} commands to increase your certainty that the number is indeed
19285 @pindex calc-prev-prime
19287 @mindex prevpr@idots
19290 The @kbd{I k n} (@code{calc-prev-prime}) [@code{prevprime}] command
19291 analogously finds the next prime less than a given number.
19294 @pindex calc-totient
19296 The @kbd{k t} (@code{calc-totient}) [@code{totient}] command computes the
19298 @texline function@tie{}@math{\phi(n)},
19299 @infoline function,
19300 the number of integers less than @expr{n} which
19301 are relatively prime to @expr{n}.
19304 @pindex calc-moebius
19306 The @kbd{k m} (@code{calc-moebius}) [@code{moebius}] command computes the
19307 @texline M@"obius @math{\mu}
19308 @infoline Moebius ``mu''
19309 function. If the input number is a product of @expr{k}
19310 distinct factors, this is @expr{(-1)^k}. If the input number has any
19311 duplicate factors (i.e., can be divided by the same prime more than once),
19312 the result is zero.
19314 @node Probability Distribution Functions, , Combinatorial Functions, Scientific Functions
19315 @section Probability Distribution Functions
19318 The functions in this section compute various probability distributions.
19319 For continuous distributions, this is the integral of the probability
19320 density function from @expr{x} to infinity. (These are the ``upper
19321 tail'' distribution functions; there are also corresponding ``lower
19322 tail'' functions which integrate from minus infinity to @expr{x}.)
19323 For discrete distributions, the upper tail function gives the sum
19324 from @expr{x} to infinity; the lower tail function gives the sum
19325 from minus infinity up to, but not including,@w{ }@expr{x}.
19327 To integrate from @expr{x} to @expr{y}, just use the distribution
19328 function twice and subtract. For example, the probability that a
19329 Gaussian random variable with mean 2 and standard deviation 1 will
19330 lie in the range from 2.5 to 2.8 is @samp{utpn(2.5,2,1) - utpn(2.8,2,1)}
19331 (``the probability that it is greater than 2.5, but not greater than 2.8''),
19332 or equivalently @samp{ltpn(2.8,2,1) - ltpn(2.5,2,1)}.
19339 The @kbd{k B} (@code{calc-utpb}) [@code{utpb}] function uses the
19340 binomial distribution. Push the parameters @var{n}, @var{p}, and
19341 then @var{x} onto the stack; the result (@samp{utpb(x,n,p)}) is the
19342 probability that an event will occur @var{x} or more times out
19343 of @var{n} trials, if its probability of occurring in any given
19344 trial is @var{p}. The @kbd{I k B} [@code{ltpb}] function is
19345 the probability that the event will occur fewer than @var{x} times.
19347 The other probability distribution functions similarly take the
19348 form @kbd{k @var{X}} (@code{calc-utp@var{x}}) [@code{utp@var{x}}]
19349 and @kbd{I k @var{X}} [@code{ltp@var{x}}], for various letters
19350 @var{x}. The arguments to the algebraic functions are the value of
19351 the random variable first, then whatever other parameters define the
19352 distribution. Note these are among the few Calc functions where the
19353 order of the arguments in algebraic form differs from the order of
19354 arguments as found on the stack. (The random variable comes last on
19355 the stack, so that you can type, e.g., @kbd{2 @key{RET} 1 @key{RET} 2.5
19356 k N M-@key{RET} @key{DEL} 2.8 k N -}, using @kbd{M-@key{RET} @key{DEL}} to
19357 recover the original arguments but substitute a new value for @expr{x}.)
19370 The @samp{utpc(x,v)} function uses the chi-square distribution with
19371 @texline @math{\nu}
19373 degrees of freedom. It is the probability that a model is
19374 correct if its chi-square statistic is @expr{x}.
19387 The @samp{utpf(F,v1,v2)} function uses the F distribution, used in
19388 various statistical tests. The parameters
19389 @texline @math{\nu_1}
19390 @infoline @expr{v1}
19392 @texline @math{\nu_2}
19393 @infoline @expr{v2}
19394 are the degrees of freedom in the numerator and denominator,
19395 respectively, used in computing the statistic @expr{F}.
19408 The @samp{utpn(x,m,s)} function uses a normal (Gaussian) distribution
19409 with mean @expr{m} and standard deviation
19410 @texline @math{\sigma}.
19411 @infoline @expr{s}.
19412 It is the probability that such a normal-distributed random variable
19413 would exceed @expr{x}.
19426 The @samp{utpp(n,x)} function uses a Poisson distribution with
19427 mean @expr{x}. It is the probability that @expr{n} or more such
19428 Poisson random events will occur.
19441 The @samp{utpt(t,v)} function uses the Student's ``t'' distribution
19443 @texline @math{\nu}
19445 degrees of freedom. It is the probability that a
19446 t-distributed random variable will be greater than @expr{t}.
19447 (Note: This computes the distribution function
19448 @texline @math{A(t|\nu)}
19449 @infoline @expr{A(t|v)}
19451 @texline @math{A(0|\nu) = 1}
19452 @infoline @expr{A(0|v) = 1}
19454 @texline @math{A(\infty|\nu) \to 0}.
19455 @infoline @expr{A(inf|v) -> 0}.
19456 The @code{UTPT} operation on the HP-48 uses a different definition which
19457 returns half of Calc's value: @samp{UTPT(t,v) = .5*utpt(t,v)}.)
19459 While Calc does not provide inverses of the probability distribution
19460 functions, the @kbd{a R} command can be used to solve for the inverse.
19461 Since the distribution functions are monotonic, @kbd{a R} is guaranteed
19462 to be able to find a solution given any initial guess.
19463 @xref{Numerical Solutions}.
19465 @node Matrix Functions, Algebra, Scientific Functions, Top
19466 @chapter Vector/Matrix Functions
19469 Many of the commands described here begin with the @kbd{v} prefix.
19470 (For convenience, the shift-@kbd{V} prefix is equivalent to @kbd{v}.)
19471 The commands usually apply to both plain vectors and matrices; some
19472 apply only to matrices or only to square matrices. If the argument
19473 has the wrong dimensions the operation is left in symbolic form.
19475 Vectors are entered and displayed using @samp{[a,b,c]} notation.
19476 Matrices are vectors of which all elements are vectors of equal length.
19477 (Though none of the standard Calc commands use this concept, a
19478 three-dimensional matrix or rank-3 tensor could be defined as a
19479 vector of matrices, and so on.)
19482 * Packing and Unpacking::
19483 * Building Vectors::
19484 * Extracting Elements::
19485 * Manipulating Vectors::
19486 * Vector and Matrix Arithmetic::
19488 * Statistical Operations::
19489 * Reducing and Mapping::
19490 * Vector and Matrix Formats::
19493 @node Packing and Unpacking, Building Vectors, Matrix Functions, Matrix Functions
19494 @section Packing and Unpacking
19497 Calc's ``pack'' and ``unpack'' commands collect stack entries to build
19498 composite objects such as vectors and complex numbers. They are
19499 described in this chapter because they are most often used to build
19505 The @kbd{v p} (@code{calc-pack}) [@code{pack}] command collects several
19506 elements from the stack into a matrix, complex number, HMS form, error
19507 form, etc. It uses a numeric prefix argument to specify the kind of
19508 object to be built; this argument is referred to as the ``packing mode.''
19509 If the packing mode is a nonnegative integer, a vector of that
19510 length is created. For example, @kbd{C-u 5 v p} will pop the top
19511 five stack elements and push back a single vector of those five
19512 elements. (@kbd{C-u 0 v p} simply creates an empty vector.)
19514 The same effect can be had by pressing @kbd{[} to push an incomplete
19515 vector on the stack, using @key{TAB} (@code{calc-roll-down}) to sneak
19516 the incomplete object up past a certain number of elements, and
19517 then pressing @kbd{]} to complete the vector.
19519 Negative packing modes create other kinds of composite objects:
19523 Two values are collected to build a complex number. For example,
19524 @kbd{5 @key{RET} 7 C-u -1 v p} creates the complex number
19525 @expr{(5, 7)}. The result is always a rectangular complex
19526 number. The two input values must both be real numbers,
19527 i.e., integers, fractions, or floats. If they are not, Calc
19528 will instead build a formula like @samp{a + (0, 1) b}. (The
19529 other packing modes also create a symbolic answer if the
19530 components are not suitable.)
19533 Two values are collected to build a polar complex number.
19534 The first is the magnitude; the second is the phase expressed
19535 in either degrees or radians according to the current angular
19539 Three values are collected into an HMS form. The first
19540 two values (hours and minutes) must be integers or
19541 integer-valued floats. The third value may be any real
19545 Two values are collected into an error form. The inputs
19546 may be real numbers or formulas.
19549 Two values are collected into a modulo form. The inputs
19550 must be real numbers.
19553 Two values are collected into the interval @samp{[a .. b]}.
19554 The inputs may be real numbers, HMS or date forms, or formulas.
19557 Two values are collected into the interval @samp{[a .. b)}.
19560 Two values are collected into the interval @samp{(a .. b]}.
19563 Two values are collected into the interval @samp{(a .. b)}.
19566 Two integer values are collected into a fraction.
19569 Two values are collected into a floating-point number.
19570 The first is the mantissa; the second, which must be an
19571 integer, is the exponent. The result is the mantissa
19572 times ten to the power of the exponent.
19575 This is treated the same as @mathit{-11} by the @kbd{v p} command.
19576 When unpacking, @mathit{-12} specifies that a floating-point mantissa
19580 A real number is converted into a date form.
19583 Three numbers (year, month, day) are packed into a pure date form.
19586 Six numbers are packed into a date/time form.
19589 With any of the two-input negative packing modes, either or both
19590 of the inputs may be vectors. If both are vectors of the same
19591 length, the result is another vector made by packing corresponding
19592 elements of the input vectors. If one input is a vector and the
19593 other is a plain number, the number is packed along with each vector
19594 element to produce a new vector. For example, @kbd{C-u -4 v p}
19595 could be used to convert a vector of numbers and a vector of errors
19596 into a single vector of error forms; @kbd{C-u -5 v p} could convert
19597 a vector of numbers and a single number @var{M} into a vector of
19598 numbers modulo @var{M}.
19600 If you don't give a prefix argument to @kbd{v p}, it takes
19601 the packing mode from the top of the stack. The elements to
19602 be packed then begin at stack level 2. Thus
19603 @kbd{1 @key{RET} 2 @key{RET} 4 n v p} is another way to
19604 enter the error form @samp{1 +/- 2}.
19606 If the packing mode taken from the stack is a vector, the result is a
19607 matrix with the dimensions specified by the elements of the vector,
19608 which must each be integers. For example, if the packing mode is
19609 @samp{[2, 3]}, then six numbers will be taken from the stack and
19610 returned in the form @samp{[@w{[a, b, c]}, [d, e, f]]}.
19612 If any elements of the vector are negative, other kinds of
19613 packing are done at that level as described above. For
19614 example, @samp{[2, 3, -4]} takes 12 objects and creates a
19615 @texline @math{2\times3}
19617 matrix of error forms: @samp{[[a +/- b, c +/- d ... ]]}.
19618 Also, @samp{[-4, -10]} will convert four integers into an
19619 error form consisting of two fractions: @samp{a:b +/- c:d}.
19625 There is an equivalent algebraic function,
19626 @samp{pack(@var{mode}, @var{items})} where @var{mode} is a
19627 packing mode (an integer or a vector of integers) and @var{items}
19628 is a vector of objects to be packed (re-packed, really) according
19629 to that mode. For example, @samp{pack([3, -4], [a,b,c,d,e,f])}
19630 yields @samp{[a +/- b, @w{c +/- d}, e +/- f]}. The function is
19631 left in symbolic form if the packing mode is invalid, or if the
19632 number of data items does not match the number of items required
19637 @pindex calc-unpack
19638 The @kbd{v u} (@code{calc-unpack}) command takes the vector, complex
19639 number, HMS form, or other composite object on the top of the stack and
19640 ``unpacks'' it, pushing each of its elements onto the stack as separate
19641 objects. Thus, it is the ``inverse'' of @kbd{v p}. If the value
19642 at the top of the stack is a formula, @kbd{v u} unpacks it by pushing
19643 each of the arguments of the top-level operator onto the stack.
19645 You can optionally give a numeric prefix argument to @kbd{v u}
19646 to specify an explicit (un)packing mode. If the packing mode is
19647 negative and the input is actually a vector or matrix, the result
19648 will be two or more similar vectors or matrices of the elements.
19649 For example, given the vector @samp{[@w{a +/- b}, c^2, d +/- 7]},
19650 the result of @kbd{C-u -4 v u} will be the two vectors
19651 @samp{[a, c^2, d]} and @w{@samp{[b, 0, 7]}}.
19653 Note that the prefix argument can have an effect even when the input is
19654 not a vector. For example, if the input is the number @mathit{-5}, then
19655 @kbd{c-u -1 v u} yields @mathit{-5} and 0 (the components of @mathit{-5}
19656 when viewed as a rectangular complex number); @kbd{C-u -2 v u} yields 5
19657 and 180 (assuming Degrees mode); and @kbd{C-u -10 v u} yields @mathit{-5}
19658 and 1 (the numerator and denominator of @mathit{-5}, viewed as a rational
19659 number). Plain @kbd{v u} with this input would complain that the input
19660 is not a composite object.
19662 Unpacking mode @mathit{-11} converts a float into an integer mantissa and
19663 an integer exponent, where the mantissa is not divisible by 10
19664 (except that 0.0 is represented by a mantissa and exponent of 0).
19665 Unpacking mode @mathit{-12} converts a float into a floating-point mantissa
19666 and integer exponent, where the mantissa (for non-zero numbers)
19667 is guaranteed to lie in the range [1 .. 10). In both cases,
19668 the mantissa is shifted left or right (and the exponent adjusted
19669 to compensate) in order to satisfy these constraints.
19671 Positive unpacking modes are treated differently than for @kbd{v p}.
19672 A mode of 1 is much like plain @kbd{v u} with no prefix argument,
19673 except that in addition to the components of the input object,
19674 a suitable packing mode to re-pack the object is also pushed.
19675 Thus, @kbd{C-u 1 v u} followed by @kbd{v p} will re-build the
19678 A mode of 2 unpacks two levels of the object; the resulting
19679 re-packing mode will be a vector of length 2. This might be used
19680 to unpack a matrix, say, or a vector of error forms. Higher
19681 unpacking modes unpack the input even more deeply.
19687 There are two algebraic functions analogous to @kbd{v u}.
19688 The @samp{unpack(@var{mode}, @var{item})} function unpacks the
19689 @var{item} using the given @var{mode}, returning the result as
19690 a vector of components. Here the @var{mode} must be an
19691 integer, not a vector. For example, @samp{unpack(-4, a +/- b)}
19692 returns @samp{[a, b]}, as does @samp{unpack(1, a +/- b)}.
19698 The @code{unpackt} function is like @code{unpack} but instead
19699 of returning a simple vector of items, it returns a vector of
19700 two things: The mode, and the vector of items. For example,
19701 @samp{unpackt(1, 2:3 +/- 1:4)} returns @samp{[-4, [2:3, 1:4]]},
19702 and @samp{unpackt(2, 2:3 +/- 1:4)} returns @samp{[[-4, -10], [2, 3, 1, 4]]}.
19703 The identity for re-building the original object is
19704 @samp{apply(pack, unpackt(@var{n}, @var{x})) = @var{x}}. (The
19705 @code{apply} function builds a function call given the function
19706 name and a vector of arguments.)
19708 @cindex Numerator of a fraction, extracting
19709 Subscript notation is a useful way to extract a particular part
19710 of an object. For example, to get the numerator of a rational
19711 number, you can use @samp{unpack(-10, @var{x})_1}.
19713 @node Building Vectors, Extracting Elements, Packing and Unpacking, Matrix Functions
19714 @section Building Vectors
19717 Vectors and matrices can be added,
19718 subtracted, multiplied, and divided; @pxref{Basic Arithmetic}.
19721 @pindex calc-concat
19726 The @kbd{|} (@code{calc-concat}) [@code{vconcat}] command ``concatenates'' two vectors
19727 into one. For example, after @kbd{@w{[ 1 , 2 ]} [ 3 , 4 ] |}, the stack
19728 will contain the single vector @samp{[1, 2, 3, 4]}. If the arguments
19729 are matrices, the rows of the first matrix are concatenated with the
19730 rows of the second. (In other words, two matrices are just two vectors
19731 of row-vectors as far as @kbd{|} is concerned.)
19733 If either argument to @kbd{|} is a scalar (a non-vector), it is treated
19734 like a one-element vector for purposes of concatenation: @kbd{1 [ 2 , 3 ] |}
19735 produces the vector @samp{[1, 2, 3]}. Likewise, if one argument is a
19736 matrix and the other is a plain vector, the vector is treated as a
19741 The @kbd{H |} (@code{calc-append}) [@code{append}] command concatenates
19742 two vectors without any special cases. Both inputs must be vectors.
19743 Whether or not they are matrices is not taken into account. If either
19744 argument is a scalar, the @code{append} function is left in symbolic form.
19745 See also @code{cons} and @code{rcons} below.
19749 The @kbd{I |} and @kbd{H I |} commands are similar, but they use their
19750 two stack arguments in the opposite order. Thus @kbd{I |} is equivalent
19751 to @kbd{@key{TAB} |}, but possibly more convenient and also a bit faster.
19757 The @kbd{v d} (@code{calc-diag}) [@code{diag}] function builds a diagonal
19758 square matrix. The optional numeric prefix gives the number of rows
19759 and columns in the matrix. If the value at the top of the stack is a
19760 vector, the elements of the vector are used as the diagonal elements; the
19761 prefix, if specified, must match the size of the vector. If the value on
19762 the stack is a scalar, it is used for each element on the diagonal, and
19763 the prefix argument is required.
19765 To build a constant square matrix, e.g., a
19766 @texline @math{3\times3}
19768 matrix filled with ones, use @kbd{0 M-3 v d 1 +}, i.e., build a zero
19769 matrix first and then add a constant value to that matrix. (Another
19770 alternative would be to use @kbd{v b} and @kbd{v a}; see below.)
19776 The @kbd{v i} (@code{calc-ident}) [@code{idn}] function builds an identity
19777 matrix of the specified size. It is a convenient form of @kbd{v d}
19778 where the diagonal element is always one. If no prefix argument is given,
19779 this command prompts for one.
19781 In algebraic notation, @samp{idn(a,n)} acts much like @samp{diag(a,n)},
19782 except that @expr{a} is required to be a scalar (non-vector) quantity.
19783 If @expr{n} is omitted, @samp{idn(a)} represents @expr{a} times an
19784 identity matrix of unknown size. Calc can operate algebraically on
19785 such generic identity matrices, and if one is combined with a matrix
19786 whose size is known, it is converted automatically to an identity
19787 matrix of a suitable matching size. The @kbd{v i} command with an
19788 argument of zero creates a generic identity matrix, @samp{idn(1)}.
19789 Note that in dimensioned Matrix mode (@pxref{Matrix Mode}), generic
19790 identity matrices are immediately expanded to the current default
19797 The @kbd{v x} (@code{calc-index}) [@code{index}] function builds a vector
19798 of consecutive integers from 1 to @var{n}, where @var{n} is the numeric
19799 prefix argument. If you do not provide a prefix argument, you will be
19800 prompted to enter a suitable number. If @var{n} is negative, the result
19801 is a vector of negative integers from @var{n} to @mathit{-1}.
19803 With a prefix argument of just @kbd{C-u}, the @kbd{v x} command takes
19804 three values from the stack: @var{n}, @var{start}, and @var{incr} (with
19805 @var{incr} at top-of-stack). Counting starts at @var{start} and increases
19806 by @var{incr} for successive vector elements. If @var{start} or @var{n}
19807 is in floating-point format, the resulting vector elements will also be
19808 floats. Note that @var{start} and @var{incr} may in fact be any kind
19809 of numbers or formulas.
19811 When @var{start} and @var{incr} are specified, a negative @var{n} has a
19812 different interpretation: It causes a geometric instead of arithmetic
19813 sequence to be generated. For example, @samp{index(-3, a, b)} produces
19814 @samp{[a, a b, a b^2]}. If you omit @var{incr} in the algebraic form,
19815 @samp{index(@var{n}, @var{start})}, the default value for @var{incr}
19816 is one for positive @var{n} or two for negative @var{n}.
19820 @pindex calc-build-vector
19822 The @kbd{v b} (@code{calc-build-vector}) [@code{cvec}] function builds a
19823 vector of @var{n} copies of the value on the top of the stack, where @var{n}
19824 is the numeric prefix argument. In algebraic formulas, @samp{cvec(x,n,m)}
19825 can also be used to build an @var{n}-by-@var{m} matrix of copies of @var{x}.
19826 (Interactively, just use @kbd{v b} twice: once to build a row, then again
19827 to build a matrix of copies of that row.)
19837 The @kbd{v h} (@code{calc-head}) [@code{head}] function returns the first
19838 element of a vector. The @kbd{I v h} (@code{calc-tail}) [@code{tail}]
19839 function returns the vector with its first element removed. In both
19840 cases, the argument must be a non-empty vector.
19846 The @kbd{v k} (@code{calc-cons}) [@code{cons}] function takes a value @var{h}
19847 and a vector @var{t} from the stack, and produces the vector whose head is
19848 @var{h} and whose tail is @var{t}. This is similar to @kbd{|}, except
19849 if @var{h} is itself a vector, @kbd{|} will concatenate the two vectors
19850 whereas @code{cons} will insert @var{h} at the front of the vector @var{t}.
19873 Each of these three functions also accepts the Hyperbolic flag [@code{rhead},
19874 @code{rtail}, @code{rcons}] in which case @var{t} instead represents
19875 the @emph{last} single element of the vector, with @var{h}
19876 representing the remainder of the vector. Thus the vector
19877 @samp{[a, b, c, d] = cons(a, [b, c, d]) = rcons([a, b, c], d)}.
19878 Also, @samp{head([a, b, c, d]) = a}, @samp{tail([a, b, c, d]) = [b, c, d]},
19879 @samp{rhead([a, b, c, d]) = [a, b, c]}, and @samp{rtail([a, b, c, d]) = d}.
19881 @node Extracting Elements, Manipulating Vectors, Building Vectors, Matrix Functions
19882 @section Extracting Vector Elements
19889 The @kbd{v r} (@code{calc-mrow}) [@code{mrow}] command extracts one row of
19890 the matrix on the top of the stack, or one element of the plain vector on
19891 the top of the stack. The row or element is specified by the numeric
19892 prefix argument; the default is to prompt for the row or element number.
19893 The matrix or vector is replaced by the specified row or element in the
19894 form of a vector or scalar, respectively.
19896 @cindex Permutations, applying
19897 With a prefix argument of @kbd{C-u} only, @kbd{v r} takes the index of
19898 the element or row from the top of the stack, and the vector or matrix
19899 from the second-to-top position. If the index is itself a vector of
19900 integers, the result is a vector of the corresponding elements of the
19901 input vector, or a matrix of the corresponding rows of the input matrix.
19902 This command can be used to obtain any permutation of a vector.
19904 With @kbd{C-u}, if the index is an interval form with integer components,
19905 it is interpreted as a range of indices and the corresponding subvector or
19906 submatrix is returned.
19908 @cindex Subscript notation
19910 @pindex calc-subscript
19913 Subscript notation in algebraic formulas (@samp{a_b}) stands for the
19914 Calc function @code{subscr}, which is synonymous with @code{mrow}.
19915 Thus, @samp{[x, y, z]_k} produces @expr{x}, @expr{y}, or @expr{z} if
19916 @expr{k} is one, two, or three, respectively. A double subscript
19917 (@samp{M_i_j}, equivalent to @samp{subscr(subscr(M, i), j)}) will
19918 access the element at row @expr{i}, column @expr{j} of a matrix.
19919 The @kbd{a _} (@code{calc-subscript}) command creates a subscript
19920 formula @samp{a_b} out of two stack entries. (It is on the @kbd{a}
19921 ``algebra'' prefix because subscripted variables are often used
19922 purely as an algebraic notation.)
19925 Given a negative prefix argument, @kbd{v r} instead deletes one row or
19926 element from the matrix or vector on the top of the stack. Thus
19927 @kbd{C-u 2 v r} replaces a matrix with its second row, but @kbd{C-u -2 v r}
19928 replaces the matrix with the same matrix with its second row removed.
19929 In algebraic form this function is called @code{mrrow}.
19932 Given a prefix argument of zero, @kbd{v r} extracts the diagonal elements
19933 of a square matrix in the form of a vector. In algebraic form this
19934 function is called @code{getdiag}.
19941 The @kbd{v c} (@code{calc-mcol}) [@code{mcol} or @code{mrcol}] command is
19942 the analogous operation on columns of a matrix. Given a plain vector
19943 it extracts (or removes) one element, just like @kbd{v r}. If the
19944 index in @kbd{C-u v c} is an interval or vector and the argument is a
19945 matrix, the result is a submatrix with only the specified columns
19946 retained (and possibly permuted in the case of a vector index).
19948 To extract a matrix element at a given row and column, use @kbd{v r} to
19949 extract the row as a vector, then @kbd{v c} to extract the column element
19950 from that vector. In algebraic formulas, it is often more convenient to
19951 use subscript notation: @samp{m_i_j} gives row @expr{i}, column @expr{j}
19952 of matrix @expr{m}.
19956 @pindex calc-subvector
19958 The @kbd{v s} (@code{calc-subvector}) [@code{subvec}] command extracts
19959 a subvector of a vector. The arguments are the vector, the starting
19960 index, and the ending index, with the ending index in the top-of-stack
19961 position. The starting index indicates the first element of the vector
19962 to take. The ending index indicates the first element @emph{past} the
19963 range to be taken. Thus, @samp{subvec([a, b, c, d, e], 2, 4)} produces
19964 the subvector @samp{[b, c]}. You could get the same result using
19965 @samp{mrow([a, b, c, d, e], @w{[2 .. 4)})}.
19967 If either the start or the end index is zero or negative, it is
19968 interpreted as relative to the end of the vector. Thus
19969 @samp{subvec([a, b, c, d, e], 2, -2)} also produces @samp{[b, c]}. In
19970 the algebraic form, the end index can be omitted in which case it
19971 is taken as zero, i.e., elements from the starting element to the
19972 end of the vector are used. The infinity symbol, @code{inf}, also
19973 has this effect when used as the ending index.
19978 With the Inverse flag, @kbd{I v s} [@code{rsubvec}] removes a subvector
19979 from a vector. The arguments are interpreted the same as for the
19980 normal @kbd{v s} command. Thus, @samp{rsubvec([a, b, c, d, e], 2, 4)}
19981 produces @samp{[a, d, e]}. It is always true that @code{subvec} and
19982 @code{rsubvec} return complementary parts of the input vector.
19984 @xref{Selecting Subformulas}, for an alternative way to operate on
19985 vectors one element at a time.
19987 @node Manipulating Vectors, Vector and Matrix Arithmetic, Extracting Elements, Matrix Functions
19988 @section Manipulating Vectors
19993 @pindex calc-vlength
19995 The @kbd{v l} (@code{calc-vlength}) [@code{vlen}] command computes the
19996 length of a vector. The length of a non-vector is considered to be zero.
19997 Note that matrices are just vectors of vectors for the purposes of this
20003 With the Hyperbolic flag, @kbd{H v l} [@code{mdims}] computes a vector
20004 of the dimensions of a vector, matrix, or higher-order object. For
20005 example, @samp{mdims([[a,b,c],[d,e,f]])} returns @samp{[2, 3]} since
20007 @texline @math{2\times3}
20013 @pindex calc-vector-find
20015 The @kbd{v f} (@code{calc-vector-find}) [@code{find}] command searches
20016 along a vector for the first element equal to a given target. The target
20017 is on the top of the stack; the vector is in the second-to-top position.
20018 If a match is found, the result is the index of the matching element.
20019 Otherwise, the result is zero. The numeric prefix argument, if given,
20020 allows you to select any starting index for the search.
20024 @pindex calc-arrange-vector
20026 @cindex Arranging a matrix
20027 @cindex Reshaping a matrix
20028 @cindex Flattening a matrix
20029 The @kbd{v a} (@code{calc-arrange-vector}) [@code{arrange}] command
20030 rearranges a vector to have a certain number of columns and rows. The
20031 numeric prefix argument specifies the number of columns; if you do not
20032 provide an argument, you will be prompted for the number of columns.
20033 The vector or matrix on the top of the stack is @dfn{flattened} into a
20034 plain vector. If the number of columns is nonzero, this vector is
20035 then formed into a matrix by taking successive groups of @var{n} elements.
20036 If the number of columns does not evenly divide the number of elements
20037 in the vector, the last row will be short and the result will not be
20038 suitable for use as a matrix. For example, with the matrix
20039 @samp{[[1, 2], @w{[3, 4]}]} on the stack, @kbd{v a 4} produces
20040 @samp{[[1, 2, 3, 4]]} (a
20041 @texline @math{1\times4}
20043 matrix), @kbd{v a 1} produces @samp{[[1], [2], [3], [4]]} (a
20044 @texline @math{4\times1}
20046 matrix), @kbd{v a 2} produces @samp{[[1, 2], [3, 4]]} (the original
20047 @texline @math{2\times2}
20049 matrix), @w{@kbd{v a 3}} produces @samp{[[1, 2, 3], [4]]} (not a
20050 matrix), and @kbd{v a 0} produces the flattened list
20051 @samp{[1, 2, @w{3, 4}]}.
20053 @cindex Sorting data
20061 The @kbd{V S} (@code{calc-sort}) [@code{sort}] command sorts the elements of
20062 a vector into increasing order. Real numbers, real infinities, and
20063 constant interval forms come first in this ordering; next come other
20064 kinds of numbers, then variables (in alphabetical order), then finally
20065 come formulas and other kinds of objects; these are sorted according
20066 to a kind of lexicographic ordering with the useful property that
20067 one vector is less or greater than another if the first corresponding
20068 unequal elements are less or greater, respectively. Since quoted strings
20069 are stored by Calc internally as vectors of ASCII character codes
20070 (@pxref{Strings}), this means vectors of strings are also sorted into
20071 alphabetical order by this command.
20073 The @kbd{I V S} [@code{rsort}] command sorts a vector into decreasing order.
20075 @cindex Permutation, inverse of
20076 @cindex Inverse of permutation
20077 @cindex Index tables
20078 @cindex Rank tables
20086 The @kbd{V G} (@code{calc-grade}) [@code{grade}, @code{rgrade}] command
20087 produces an index table or permutation vector which, if applied to the
20088 input vector (as the index of @kbd{C-u v r}, say), would sort the vector.
20089 A permutation vector is just a vector of integers from 1 to @var{n}, where
20090 each integer occurs exactly once. One application of this is to sort a
20091 matrix of data rows using one column as the sort key; extract that column,
20092 grade it with @kbd{V G}, then use the result to reorder the original matrix
20093 with @kbd{C-u v r}. Another interesting property of the @code{V G} command
20094 is that, if the input is itself a permutation vector, the result will
20095 be the inverse of the permutation. The inverse of an index table is
20096 a rank table, whose @var{k}th element says where the @var{k}th original
20097 vector element will rest when the vector is sorted. To get a rank
20098 table, just use @kbd{V G V G}.
20100 With the Inverse flag, @kbd{I V G} produces an index table that would
20101 sort the input into decreasing order. Note that @kbd{V S} and @kbd{V G}
20102 use a ``stable'' sorting algorithm, i.e., any two elements which are equal
20103 will not be moved out of their original order. Generally there is no way
20104 to tell with @kbd{V S}, since two elements which are equal look the same,
20105 but with @kbd{V G} this can be an important issue. In the matrix-of-rows
20106 example, suppose you have names and telephone numbers as two columns and
20107 you wish to sort by phone number primarily, and by name when the numbers
20108 are equal. You can sort the data matrix by names first, and then again
20109 by phone numbers. Because the sort is stable, any two rows with equal
20110 phone numbers will remain sorted by name even after the second sort.
20115 @pindex calc-histogram
20117 @mindex histo@idots
20120 The @kbd{V H} (@code{calc-histogram}) [@code{histogram}] command builds a
20121 histogram of a vector of numbers. Vector elements are assumed to be
20122 integers or real numbers in the range [0..@var{n}) for some ``number of
20123 bins'' @var{n}, which is the numeric prefix argument given to the
20124 command. The result is a vector of @var{n} counts of how many times
20125 each value appeared in the original vector. Non-integers in the input
20126 are rounded down to integers. Any vector elements outside the specified
20127 range are ignored. (You can tell if elements have been ignored by noting
20128 that the counts in the result vector don't add up to the length of the
20131 If no prefix is given, then you will be prompted for a vector which
20132 will be used to determine the bins. (If a positive integer is given at
20133 this prompt, it will be still treated as if it were given as a
20134 prefix.) Each bin will consist of the interval of numbers closest to
20135 the corresponding number of this new vector; if the vector
20136 @expr{[a, b, c, ...]} is entered at the prompt, the bins will be
20137 @expr{(-inf, (a+b)/2]}, @expr{((a+b)/2, (b+c)/2]}, etc. The result of
20138 this command will be a vector counting how many elements of the
20139 original vector are in each bin.
20141 The result will then be a vector with the same length as this new vector;
20142 each element of the new vector will be replaced by the number of
20143 elements of the original vector which are closest to it.
20147 With the Hyperbolic flag, @kbd{H V H} pulls two vectors from the stack.
20148 The second-to-top vector is the list of numbers as before. The top
20149 vector is an equal-sized list of ``weights'' to attach to the elements
20150 of the data vector. For example, if the first data element is 4.2 and
20151 the first weight is 10, then 10 will be added to bin 4 of the result
20152 vector. Without the hyperbolic flag, every element has a weight of one.
20156 @pindex calc-transpose
20158 The @kbd{v t} (@code{calc-transpose}) [@code{trn}] command computes
20159 the transpose of the matrix at the top of the stack. If the argument
20160 is a plain vector, it is treated as a row vector and transposed into
20161 a one-column matrix.
20165 @pindex calc-reverse-vector
20167 The @kbd{v v} (@code{calc-reverse-vector}) [@code{rev}] command reverses
20168 a vector end-for-end. Given a matrix, it reverses the order of the rows.
20169 (To reverse the columns instead, just use @kbd{v t v v v t}. The same
20170 principle can be used to apply other vector commands to the columns of
20175 @pindex calc-mask-vector
20177 The @kbd{v m} (@code{calc-mask-vector}) [@code{vmask}] command uses
20178 one vector as a mask to extract elements of another vector. The mask
20179 is in the second-to-top position; the target vector is on the top of
20180 the stack. These vectors must have the same length. The result is
20181 the same as the target vector, but with all elements which correspond
20182 to zeros in the mask vector deleted. Thus, for example,
20183 @samp{vmask([1, 0, 1, 0, 1], [a, b, c, d, e])} produces @samp{[a, c, e]}.
20184 @xref{Logical Operations}.
20188 @pindex calc-expand-vector
20190 The @kbd{v e} (@code{calc-expand-vector}) [@code{vexp}] command
20191 expands a vector according to another mask vector. The result is a
20192 vector the same length as the mask, but with nonzero elements replaced
20193 by successive elements from the target vector. The length of the target
20194 vector is normally the number of nonzero elements in the mask. If the
20195 target vector is longer, its last few elements are lost. If the target
20196 vector is shorter, the last few nonzero mask elements are left
20197 unreplaced in the result. Thus @samp{vexp([2, 0, 3, 0, 7], [a, b])}
20198 produces @samp{[a, 0, b, 0, 7]}.
20202 With the Hyperbolic flag, @kbd{H v e} takes a filler value from the
20203 top of the stack; the mask and target vectors come from the third and
20204 second elements of the stack. This filler is used where the mask is
20205 zero: @samp{vexp([2, 0, 3, 0, 7], [a, b], z)} produces
20206 @samp{[a, z, c, z, 7]}. If the filler value is itself a vector,
20207 then successive values are taken from it, so that the effect is to
20208 interleave two vectors according to the mask:
20209 @samp{vexp([2, 0, 3, 7, 0, 0], [a, b], [x, y])} produces
20210 @samp{[a, x, b, 7, y, 0]}.
20212 Another variation on the masking idea is to combine @samp{[a, b, c, d, e]}
20213 with the mask @samp{[1, 0, 1, 0, 1]} to produce @samp{[a, 0, c, 0, e]}.
20214 You can accomplish this with @kbd{V M a &}, mapping the logical ``and''
20215 operation across the two vectors. @xref{Logical Operations}. Note that
20216 the @code{? :} operation also discussed there allows other types of
20217 masking using vectors.
20219 @node Vector and Matrix Arithmetic, Set Operations, Manipulating Vectors, Matrix Functions
20220 @section Vector and Matrix Arithmetic
20223 Basic arithmetic operations like addition and multiplication are defined
20224 for vectors and matrices as well as for numbers. Division of matrices, in
20225 the sense of multiplying by the inverse, is supported. (Division by a
20226 matrix actually uses LU-decomposition for greater accuracy and speed.)
20227 @xref{Basic Arithmetic}.
20229 The following functions are applied element-wise if their arguments are
20230 vectors or matrices: @code{change-sign}, @code{conj}, @code{arg},
20231 @code{re}, @code{im}, @code{polar}, @code{rect}, @code{clean},
20232 @code{float}, @code{frac}. @xref{Function Index}.
20236 @pindex calc-conj-transpose
20238 The @kbd{V J} (@code{calc-conj-transpose}) [@code{ctrn}] command computes
20239 the conjugate transpose of its argument, i.e., @samp{conj(trn(x))}.
20244 @kindex A (vectors)
20245 @pindex calc-abs (vectors)
20249 @tindex abs (vectors)
20250 The @kbd{A} (@code{calc-abs}) [@code{abs}] command computes the
20251 Frobenius norm of a vector or matrix argument. This is the square
20252 root of the sum of the squares of the absolute values of the
20253 elements of the vector or matrix. If the vector is interpreted as
20254 a point in two- or three-dimensional space, this is the distance
20255 from that point to the origin.
20261 The @kbd{v n} (@code{calc-rnorm}) [@code{rnorm}] command computes the
20262 infinity-norm of a vector, or the row norm of a matrix. For a plain
20263 vector, this is the maximum of the absolute values of the elements. For
20264 a matrix, this is the maximum of the row-absolute-value-sums, i.e., of
20265 the sums of the absolute values of the elements along the various rows.
20271 The @kbd{V N} (@code{calc-cnorm}) [@code{cnorm}] command computes
20272 the one-norm of a vector, or column norm of a matrix. For a plain
20273 vector, this is the sum of the absolute values of the elements.
20274 For a matrix, this is the maximum of the column-absolute-value-sums.
20275 General @expr{k}-norms for @expr{k} other than one or infinity are
20276 not provided. However, the 2-norm (or Frobenius norm) is provided for
20277 vectors by the @kbd{A} (@code{calc-abs}) command.
20283 The @kbd{V C} (@code{calc-cross}) [@code{cross}] command computes the
20284 right-handed cross product of two vectors, each of which must have
20285 exactly three elements.
20290 @kindex & (matrices)
20291 @pindex calc-inv (matrices)
20295 @tindex inv (matrices)
20296 The @kbd{&} (@code{calc-inv}) [@code{inv}] command computes the
20297 inverse of a square matrix. If the matrix is singular, the inverse
20298 operation is left in symbolic form. Matrix inverses are recorded so
20299 that once an inverse (or determinant) of a particular matrix has been
20300 computed, the inverse and determinant of the matrix can be recomputed
20301 quickly in the future.
20303 If the argument to @kbd{&} is a plain number @expr{x}, this
20304 command simply computes @expr{1/x}. This is okay, because the
20305 @samp{/} operator also does a matrix inversion when dividing one
20312 The @kbd{V D} (@code{calc-mdet}) [@code{det}] command computes the
20313 determinant of a square matrix.
20319 The @kbd{V L} (@code{calc-mlud}) [@code{lud}] command computes the
20320 LU decomposition of a matrix. The result is a list of three matrices
20321 which, when multiplied together left-to-right, form the original matrix.
20322 The first is a permutation matrix that arises from pivoting in the
20323 algorithm, the second is lower-triangular with ones on the diagonal,
20324 and the third is upper-triangular.
20328 @pindex calc-mtrace
20330 The @kbd{V T} (@code{calc-mtrace}) [@code{tr}] command computes the
20331 trace of a square matrix. This is defined as the sum of the diagonal
20332 elements of the matrix.
20338 The @kbd{V K} (@code{calc-kron}) [@code{kron}] command computes
20339 the Kronecker product of two matrices.
20341 @node Set Operations, Statistical Operations, Vector and Matrix Arithmetic, Matrix Functions
20342 @section Set Operations using Vectors
20345 @cindex Sets, as vectors
20346 Calc includes several commands which interpret vectors as @dfn{sets} of
20347 objects. A set is a collection of objects; any given object can appear
20348 only once in the set. Calc stores sets as vectors of objects in
20349 sorted order. Objects in a Calc set can be any of the usual things,
20350 such as numbers, variables, or formulas. Two set elements are considered
20351 equal if they are identical, except that numerically equal numbers like
20352 the integer 4 and the float 4.0 are considered equal even though they
20353 are not ``identical.'' Variables are treated like plain symbols without
20354 attached values by the set operations; subtracting the set @samp{[b]}
20355 from @samp{[a, b]} always yields the set @samp{[a]} even though if
20356 the variables @samp{a} and @samp{b} both equaled 17, you might
20357 expect the answer @samp{[]}.
20359 If a set contains interval forms, then it is assumed to be a set of
20360 real numbers. In this case, all set operations require the elements
20361 of the set to be only things that are allowed in intervals: Real
20362 numbers, plus and minus infinity, HMS forms, and date forms. If
20363 there are variables or other non-real objects present in a real set,
20364 all set operations on it will be left in unevaluated form.
20366 If the input to a set operation is a plain number or interval form
20367 @var{a}, it is treated like the one-element vector @samp{[@var{a}]}.
20368 The result is always a vector, except that if the set consists of a
20369 single interval, the interval itself is returned instead.
20371 @xref{Logical Operations}, for the @code{in} function which tests if
20372 a certain value is a member of a given set. To test if the set @expr{A}
20373 is a subset of the set @expr{B}, use @samp{vdiff(A, B) = []}.
20377 @pindex calc-remove-duplicates
20379 The @kbd{V +} (@code{calc-remove-duplicates}) [@code{rdup}] command
20380 converts an arbitrary vector into set notation. It works by sorting
20381 the vector as if by @kbd{V S}, then removing duplicates. (For example,
20382 @kbd{[a, 5, 4, a, 4.0]} is sorted to @samp{[4, 4.0, 5, a, a]} and then
20383 reduced to @samp{[4, 5, a]}). Overlapping intervals are merged as
20384 necessary. You rarely need to use @kbd{V +} explicitly, since all the
20385 other set-based commands apply @kbd{V +} to their inputs before using
20390 @pindex calc-set-union
20392 The @kbd{V V} (@code{calc-set-union}) [@code{vunion}] command computes
20393 the union of two sets. An object is in the union of two sets if and
20394 only if it is in either (or both) of the input sets. (You could
20395 accomplish the same thing by concatenating the sets with @kbd{|},
20396 then using @kbd{V +}.)
20400 @pindex calc-set-intersect
20402 The @kbd{V ^} (@code{calc-set-intersect}) [@code{vint}] command computes
20403 the intersection of two sets. An object is in the intersection if
20404 and only if it is in both of the input sets. Thus if the input
20405 sets are disjoint, i.e., if they share no common elements, the result
20406 will be the empty vector @samp{[]}. Note that the characters @kbd{V}
20407 and @kbd{^} were chosen to be close to the conventional mathematical
20409 @texline union@tie{}(@math{A \cup B})
20412 @texline intersection@tie{}(@math{A \cap B}).
20413 @infoline intersection.
20417 @pindex calc-set-difference
20419 The @kbd{V -} (@code{calc-set-difference}) [@code{vdiff}] command computes
20420 the difference between two sets. An object is in the difference
20421 @expr{A - B} if and only if it is in @expr{A} but not in @expr{B}.
20422 Thus subtracting @samp{[y,z]} from a set will remove the elements
20423 @samp{y} and @samp{z} if they are present. You can also think of this
20424 as a general @dfn{set complement} operator; if @expr{A} is the set of
20425 all possible values, then @expr{A - B} is the ``complement'' of @expr{B}.
20426 Obviously this is only practical if the set of all possible values in
20427 your problem is small enough to list in a Calc vector (or simple
20428 enough to express in a few intervals).
20432 @pindex calc-set-xor
20434 The @kbd{V X} (@code{calc-set-xor}) [@code{vxor}] command computes
20435 the ``exclusive-or,'' or ``symmetric difference'' of two sets.
20436 An object is in the symmetric difference of two sets if and only
20437 if it is in one, but @emph{not} both, of the sets. Objects that
20438 occur in both sets ``cancel out.''
20442 @pindex calc-set-complement
20444 The @kbd{V ~} (@code{calc-set-complement}) [@code{vcompl}] command
20445 computes the complement of a set with respect to the real numbers.
20446 Thus @samp{vcompl(x)} is equivalent to @samp{vdiff([-inf .. inf], x)}.
20447 For example, @samp{vcompl([2, (3 .. 4]])} evaluates to
20448 @samp{[[-inf .. 2), (2 .. 3], (4 .. inf]]}.
20452 @pindex calc-set-floor
20454 The @kbd{V F} (@code{calc-set-floor}) [@code{vfloor}] command
20455 reinterprets a set as a set of integers. Any non-integer values,
20456 and intervals that do not enclose any integers, are removed. Open
20457 intervals are converted to equivalent closed intervals. Successive
20458 integers are converted into intervals of integers. For example, the
20459 complement of the set @samp{[2, 6, 7, 8]} is messy, but if you wanted
20460 the complement with respect to the set of integers you could type
20461 @kbd{V ~ V F} to get @samp{[[-inf .. 1], [3 .. 5], [9 .. inf]]}.
20465 @pindex calc-set-enumerate
20467 The @kbd{V E} (@code{calc-set-enumerate}) [@code{venum}] command
20468 converts a set of integers into an explicit vector. Intervals in
20469 the set are expanded out to lists of all integers encompassed by
20470 the intervals. This only works for finite sets (i.e., sets which
20471 do not involve @samp{-inf} or @samp{inf}).
20475 @pindex calc-set-span
20477 The @kbd{V :} (@code{calc-set-span}) [@code{vspan}] command converts any
20478 set of reals into an interval form that encompasses all its elements.
20479 The lower limit will be the smallest element in the set; the upper
20480 limit will be the largest element. For an empty set, @samp{vspan([])}
20481 returns the empty interval @w{@samp{[0 .. 0)}}.
20485 @pindex calc-set-cardinality
20487 The @kbd{V #} (@code{calc-set-cardinality}) [@code{vcard}] command counts
20488 the number of integers in a set. The result is the length of the vector
20489 that would be produced by @kbd{V E}, although the computation is much
20490 more efficient than actually producing that vector.
20492 @cindex Sets, as binary numbers
20493 Another representation for sets that may be more appropriate in some
20494 cases is binary numbers. If you are dealing with sets of integers
20495 in the range 0 to 49, you can use a 50-bit binary number where a
20496 particular bit is 1 if the corresponding element is in the set.
20497 @xref{Binary Functions}, for a list of commands that operate on
20498 binary numbers. Note that many of the above set operations have
20499 direct equivalents in binary arithmetic: @kbd{b o} (@code{calc-or}),
20500 @kbd{b a} (@code{calc-and}), @kbd{b d} (@code{calc-diff}),
20501 @kbd{b x} (@code{calc-xor}), and @kbd{b n} (@code{calc-not}),
20502 respectively. You can use whatever representation for sets is most
20507 @pindex calc-pack-bits
20508 @pindex calc-unpack-bits
20511 The @kbd{b u} (@code{calc-unpack-bits}) [@code{vunpack}] command
20512 converts an integer that represents a set in binary into a set
20513 in vector/interval notation. For example, @samp{vunpack(67)}
20514 returns @samp{[[0 .. 1], 6]}. If the input is negative, the set
20515 it represents is semi-infinite: @samp{vunpack(-4) = [2 .. inf)}.
20516 Use @kbd{V E} afterwards to expand intervals to individual
20517 values if you wish. Note that this command uses the @kbd{b}
20518 (binary) prefix key.
20520 The @kbd{b p} (@code{calc-pack-bits}) [@code{vpack}] command
20521 converts the other way, from a vector or interval representing
20522 a set of nonnegative integers into a binary integer describing
20523 the same set. The set may include positive infinity, but must
20524 not include any negative numbers. The input is interpreted as a
20525 set of integers in the sense of @kbd{V F} (@code{vfloor}). Beware
20526 that a simple input like @samp{[100]} can result in a huge integer
20528 @texline (@math{2^{100}}, a 31-digit integer, in this case).
20529 @infoline (@expr{2^100}, a 31-digit integer, in this case).
20531 @node Statistical Operations, Reducing and Mapping, Set Operations, Matrix Functions
20532 @section Statistical Operations on Vectors
20535 @cindex Statistical functions
20536 The commands in this section take vectors as arguments and compute
20537 various statistical measures on the data stored in the vectors. The
20538 references used in the definitions of these functions are Bevington's
20539 @emph{Data Reduction and Error Analysis for the Physical Sciences},
20540 and @emph{Numerical Recipes} by Press, Flannery, Teukolsky and
20543 The statistical commands use the @kbd{u} prefix key followed by
20544 a shifted letter or other character.
20546 @xref{Manipulating Vectors}, for a description of @kbd{V H}
20547 (@code{calc-histogram}).
20549 @xref{Curve Fitting}, for the @kbd{a F} command for doing
20550 least-squares fits to statistical data.
20552 @xref{Probability Distribution Functions}, for several common
20553 probability distribution functions.
20556 * Single-Variable Statistics::
20557 * Paired-Sample Statistics::
20560 @node Single-Variable Statistics, Paired-Sample Statistics, Statistical Operations, Statistical Operations
20561 @subsection Single-Variable Statistics
20564 These functions do various statistical computations on single
20565 vectors. Given a numeric prefix argument, they actually pop
20566 @var{n} objects from the stack and combine them into a data
20567 vector. Each object may be either a number or a vector; if a
20568 vector, any sub-vectors inside it are ``flattened'' as if by
20569 @kbd{v a 0}; @pxref{Manipulating Vectors}. By default one object
20570 is popped, which (in order to be useful) is usually a vector.
20572 If an argument is a variable name, and the value stored in that
20573 variable is a vector, then the stored vector is used. This method
20574 has the advantage that if your data vector is large, you can avoid
20575 the slow process of manipulating it directly on the stack.
20577 These functions are left in symbolic form if any of their arguments
20578 are not numbers or vectors, e.g., if an argument is a formula, or
20579 a non-vector variable. However, formulas embedded within vector
20580 arguments are accepted; the result is a symbolic representation
20581 of the computation, based on the assumption that the formula does
20582 not itself represent a vector. All varieties of numbers such as
20583 error forms and interval forms are acceptable.
20585 Some of the functions in this section also accept a single error form
20586 or interval as an argument. They then describe a property of the
20587 normal or uniform (respectively) statistical distribution described
20588 by the argument. The arguments are interpreted in the same way as
20589 the @var{M} argument of the random number function @kbd{k r}. In
20590 particular, an interval with integer limits is considered an integer
20591 distribution, so that @samp{[2 .. 6)} is the same as @samp{[2 .. 5]}.
20592 An interval with at least one floating-point limit is a continuous
20593 distribution: @samp{[2.0 .. 6.0)} is @emph{not} the same as
20594 @samp{[2.0 .. 5.0]}!
20597 @pindex calc-vector-count
20599 The @kbd{u #} (@code{calc-vector-count}) [@code{vcount}] command
20600 computes the number of data values represented by the inputs.
20601 For example, @samp{vcount(1, [2, 3], [[4, 5], [], x, y])} returns 7.
20602 If the argument is a single vector with no sub-vectors, this
20603 simply computes the length of the vector.
20607 @pindex calc-vector-sum
20608 @pindex calc-vector-prod
20611 @cindex Summations (statistical)
20612 The @kbd{u +} (@code{calc-vector-sum}) [@code{vsum}] command
20613 computes the sum of the data values. The @kbd{u *}
20614 (@code{calc-vector-prod}) [@code{vprod}] command computes the
20615 product of the data values. If the input is a single flat vector,
20616 these are the same as @kbd{V R +} and @kbd{V R *}
20617 (@pxref{Reducing and Mapping}).
20621 @pindex calc-vector-max
20622 @pindex calc-vector-min
20625 The @kbd{u X} (@code{calc-vector-max}) [@code{vmax}] command
20626 computes the maximum of the data values, and the @kbd{u N}
20627 (@code{calc-vector-min}) [@code{vmin}] command computes the minimum.
20628 If the argument is an interval, this finds the minimum or maximum
20629 value in the interval. (Note that @samp{vmax([2..6)) = 5} as
20630 described above.) If the argument is an error form, this returns
20631 plus or minus infinity.
20634 @pindex calc-vector-mean
20636 @cindex Mean of data values
20637 The @kbd{u M} (@code{calc-vector-mean}) [@code{vmean}] command
20638 computes the average (arithmetic mean) of the data values.
20639 If the inputs are error forms
20640 @texline @math{x \pm \sigma},
20641 @infoline @samp{x +/- s},
20642 this is the weighted mean of the @expr{x} values with weights
20643 @texline @math{1 /\sigma^2}.
20644 @infoline @expr{1 / s^2}.
20646 $$ \mu = { \displaystyle \sum { x_i \over \sigma_i^2 } \over
20647 \displaystyle \sum { 1 \over \sigma_i^2 } } $$
20649 If the inputs are not error forms, this is simply the sum of the
20650 values divided by the count of the values.
20652 Note that a plain number can be considered an error form with
20654 @texline @math{\sigma = 0}.
20655 @infoline @expr{s = 0}.
20656 If the input to @kbd{u M} is a mixture of
20657 plain numbers and error forms, the result is the mean of the
20658 plain numbers, ignoring all values with non-zero errors. (By the
20659 above definitions it's clear that a plain number effectively
20660 has an infinite weight, next to which an error form with a finite
20661 weight is completely negligible.)
20663 This function also works for distributions (error forms or
20664 intervals). The mean of an error form `@var{a} @tfn{+/-} @var{b}' is simply
20665 @expr{a}. The mean of an interval is the mean of the minimum
20666 and maximum values of the interval.
20669 @pindex calc-vector-mean-error
20671 The @kbd{I u M} (@code{calc-vector-mean-error}) [@code{vmeane}]
20672 command computes the mean of the data points expressed as an
20673 error form. This includes the estimated error associated with
20674 the mean. If the inputs are error forms, the error is the square
20675 root of the reciprocal of the sum of the reciprocals of the squares
20676 of the input errors. (I.e., the variance is the reciprocal of the
20677 sum of the reciprocals of the variances.)
20679 $$ \sigma_\mu^2 = {1 \over \displaystyle \sum {1 \over \sigma_i^2}} $$
20681 If the inputs are plain
20682 numbers, the error is equal to the standard deviation of the values
20683 divided by the square root of the number of values. (This works
20684 out to be equivalent to calculating the standard deviation and
20685 then assuming each value's error is equal to this standard
20688 $$ \sigma_\mu^2 = {\sigma^2 \over N} $$
20692 @pindex calc-vector-median
20694 @cindex Median of data values
20695 The @kbd{H u M} (@code{calc-vector-median}) [@code{vmedian}]
20696 command computes the median of the data values. The values are
20697 first sorted into numerical order; the median is the middle
20698 value after sorting. (If the number of data values is even,
20699 the median is taken to be the average of the two middle values.)
20700 The median function is different from the other functions in
20701 this section in that the arguments must all be real numbers;
20702 variables are not accepted even when nested inside vectors.
20703 (Otherwise it is not possible to sort the data values.) If
20704 any of the input values are error forms, their error parts are
20707 The median function also accepts distributions. For both normal
20708 (error form) and uniform (interval) distributions, the median is
20709 the same as the mean.
20712 @pindex calc-vector-harmonic-mean
20714 @cindex Harmonic mean
20715 The @kbd{H I u M} (@code{calc-vector-harmonic-mean}) [@code{vhmean}]
20716 command computes the harmonic mean of the data values. This is
20717 defined as the reciprocal of the arithmetic mean of the reciprocals
20720 $$ { N \over \displaystyle \sum {1 \over x_i} } $$
20724 @pindex calc-vector-geometric-mean
20726 @cindex Geometric mean
20727 The @kbd{u G} (@code{calc-vector-geometric-mean}) [@code{vgmean}]
20728 command computes the geometric mean of the data values. This
20729 is the @var{n}th root of the product of the values. This is also
20730 equal to the @code{exp} of the arithmetic mean of the logarithms
20731 of the data values.
20733 $$ \exp \left ( \sum { \ln x_i } \right ) =
20734 \left ( \prod { x_i } \right)^{1 / N} $$
20739 The @kbd{H u G} [@code{agmean}] command computes the ``arithmetic-geometric
20740 mean'' of two numbers taken from the stack. This is computed by
20741 replacing the two numbers with their arithmetic mean and geometric
20742 mean, then repeating until the two values converge.
20744 $$ a_{i+1} = { a_i + b_i \over 2 } , \qquad b_{i+1} = \sqrt{a_i b_i} $$
20747 @c @cindex Root-mean-square
20748 @c Another commonly used mean, the RMS (root-mean-square), can be computed
20749 @c for a vector of numbers simply by using the @kbd{A} command.
20752 @pindex calc-vector-sdev
20754 @cindex Standard deviation
20755 @cindex Sample statistics
20756 The @kbd{u S} (@code{calc-vector-sdev}) [@code{vsdev}] command
20757 computes the standard
20758 @texline deviation@tie{}@math{\sigma}
20759 @infoline deviation
20760 of the data values. If the values are error forms, the errors are used
20761 as weights just as for @kbd{u M}. This is the @emph{sample} standard
20762 deviation, whose value is the square root of the sum of the squares of
20763 the differences between the values and the mean of the @expr{N} values,
20764 divided by @expr{N-1}.
20766 $$ \sigma^2 = {1 \over N - 1} \sum (x_i - \mu)^2 $$
20769 This function also applies to distributions. The standard deviation
20770 of a single error form is simply the error part. The standard deviation
20771 of a continuous interval happens to equal the difference between the
20773 @texline @math{\sqrt{12}}.
20774 @infoline @expr{sqrt(12)}.
20775 The standard deviation of an integer interval is the same as the
20776 standard deviation of a vector of those integers.
20779 @pindex calc-vector-pop-sdev
20781 @cindex Population statistics
20782 The @kbd{I u S} (@code{calc-vector-pop-sdev}) [@code{vpsdev}]
20783 command computes the @emph{population} standard deviation.
20784 It is defined by the same formula as above but dividing
20785 by @expr{N} instead of by @expr{N-1}. The population standard
20786 deviation is used when the input represents the entire set of
20787 data values in the distribution; the sample standard deviation
20788 is used when the input represents a sample of the set of all
20789 data values, so that the mean computed from the input is itself
20790 only an estimate of the true mean.
20792 $$ \sigma^2 = {1 \over N} \sum (x_i - \mu)^2 $$
20795 For error forms and continuous intervals, @code{vpsdev} works
20796 exactly like @code{vsdev}. For integer intervals, it computes the
20797 population standard deviation of the equivalent vector of integers.
20801 @pindex calc-vector-variance
20802 @pindex calc-vector-pop-variance
20805 @cindex Variance of data values
20806 The @kbd{H u S} (@code{calc-vector-variance}) [@code{vvar}] and
20807 @kbd{H I u S} (@code{calc-vector-pop-variance}) [@code{vpvar}]
20808 commands compute the variance of the data values. The variance
20810 @texline square@tie{}@math{\sigma^2}
20812 of the standard deviation, i.e., the sum of the
20813 squares of the deviations of the data values from the mean.
20814 (This definition also applies when the argument is a distribution.)
20820 The @code{vflat} algebraic function returns a vector of its
20821 arguments, interpreted in the same way as the other functions
20822 in this section. For example, @samp{vflat(1, [2, [3, 4]], 5)}
20823 returns @samp{[1, 2, 3, 4, 5]}.
20825 @node Paired-Sample Statistics, , Single-Variable Statistics, Statistical Operations
20826 @subsection Paired-Sample Statistics
20829 The functions in this section take two arguments, which must be
20830 vectors of equal size. The vectors are each flattened in the same
20831 way as by the single-variable statistical functions. Given a numeric
20832 prefix argument of 1, these functions instead take one object from
20833 the stack, which must be an
20834 @texline @math{N\times2}
20836 matrix of data values. Once again, variable names can be used in place
20837 of actual vectors and matrices.
20840 @pindex calc-vector-covariance
20843 The @kbd{u C} (@code{calc-vector-covariance}) [@code{vcov}] command
20844 computes the sample covariance of two vectors. The covariance
20845 of vectors @var{x} and @var{y} is the sum of the products of the
20846 differences between the elements of @var{x} and the mean of @var{x}
20847 times the differences between the corresponding elements of @var{y}
20848 and the mean of @var{y}, all divided by @expr{N-1}. Note that
20849 the variance of a vector is just the covariance of the vector
20850 with itself. Once again, if the inputs are error forms the
20851 errors are used as weight factors. If both @var{x} and @var{y}
20852 are composed of error forms, the error for a given data point
20853 is taken as the square root of the sum of the squares of the two
20856 $$ \sigma_{x\!y}^2 = {1 \over N-1} \sum (x_i - \mu_x) (y_i - \mu_y) $$
20857 $$ \sigma_{x\!y}^2 =
20858 {\displaystyle {1 \over N-1}
20859 \sum {(x_i - \mu_x) (y_i - \mu_y) \over \sigma_i^2}
20860 \over \displaystyle {1 \over N} \sum {1 \over \sigma_i^2}}
20865 @pindex calc-vector-pop-covariance
20867 The @kbd{I u C} (@code{calc-vector-pop-covariance}) [@code{vpcov}]
20868 command computes the population covariance, which is the same as the
20869 sample covariance computed by @kbd{u C} except dividing by @expr{N}
20870 instead of @expr{N-1}.
20873 @pindex calc-vector-correlation
20875 @cindex Correlation coefficient
20876 @cindex Linear correlation
20877 The @kbd{H u C} (@code{calc-vector-correlation}) [@code{vcorr}]
20878 command computes the linear correlation coefficient of two vectors.
20879 This is defined by the covariance of the vectors divided by the
20880 product of their standard deviations. (There is no difference
20881 between sample or population statistics here.)
20883 $$ r_{x\!y} = { \sigma_{x\!y}^2 \over \sigma_x^2 \sigma_y^2 } $$
20886 @node Reducing and Mapping, Vector and Matrix Formats, Statistical Operations, Matrix Functions
20887 @section Reducing and Mapping Vectors
20890 The commands in this section allow for more general operations on the
20891 elements of vectors.
20897 The simplest of these operations is @kbd{V A} (@code{calc-apply})
20898 [@code{apply}], which applies a given operator to the elements of a vector.
20899 For example, applying the hypothetical function @code{f} to the vector
20900 @w{@samp{[1, 2, 3]}} would produce the function call @samp{f(1, 2, 3)}.
20901 Applying the @code{+} function to the vector @samp{[a, b]} gives
20902 @samp{a + b}. Applying @code{+} to the vector @samp{[a, b, c]} is an
20903 error, since the @code{+} function expects exactly two arguments.
20905 While @kbd{V A} is useful in some cases, you will usually find that either
20906 @kbd{V R} or @kbd{V M}, described below, is closer to what you want.
20909 * Specifying Operators::
20912 * Nesting and Fixed Points::
20913 * Generalized Products::
20916 @node Specifying Operators, Mapping, Reducing and Mapping, Reducing and Mapping
20917 @subsection Specifying Operators
20920 Commands in this section (like @kbd{V A}) prompt you to press the key
20921 corresponding to the desired operator. Press @kbd{?} for a partial
20922 list of the available operators. Generally, an operator is any key or
20923 sequence of keys that would normally take one or more arguments from
20924 the stack and replace them with a result. For example, @kbd{V A H C}
20925 uses the hyperbolic cosine operator, @code{cosh}. (Since @code{cosh}
20926 expects one argument, @kbd{V A H C} requires a vector with a single
20927 element as its argument.)
20929 You can press @kbd{x} at the operator prompt to select any algebraic
20930 function by name to use as the operator. This includes functions you
20931 have defined yourself using the @kbd{Z F} command. (@xref{Algebraic
20932 Definitions}.) If you give a name for which no function has been
20933 defined, the result is left in symbolic form, as in @samp{f(1, 2, 3)}.
20934 Calc will prompt for the number of arguments the function takes if it
20935 can't figure it out on its own (say, because you named a function that
20936 is currently undefined). It is also possible to type a digit key before
20937 the function name to specify the number of arguments, e.g.,
20938 @kbd{V M 3 x f @key{RET}} calls @code{f} with three arguments even if it
20939 looks like it ought to have only two. This technique may be necessary
20940 if the function allows a variable number of arguments. For example,
20941 the @kbd{v e} [@code{vexp}] function accepts two or three arguments;
20942 if you want to map with the three-argument version, you will have to
20943 type @kbd{V M 3 v e}.
20945 It is also possible to apply any formula to a vector by treating that
20946 formula as a function. When prompted for the operator to use, press
20947 @kbd{'} (the apostrophe) and type your formula as an algebraic entry.
20948 You will then be prompted for the argument list, which defaults to a
20949 list of all variables that appear in the formula, sorted into alphabetic
20950 order. For example, suppose you enter the formula @w{@samp{x + 2y^x}}.
20951 The default argument list would be @samp{(x y)}, which means that if
20952 this function is applied to the arguments @samp{[3, 10]} the result will
20953 be @samp{3 + 2*10^3}. (If you plan to use a certain formula in this
20954 way often, you might consider defining it as a function with @kbd{Z F}.)
20956 Another way to specify the arguments to the formula you enter is with
20957 @kbd{$}, @kbd{$$}, and so on. For example, @kbd{V A ' $$ + 2$^$$}
20958 has the same effect as the previous example. The argument list is
20959 automatically taken to be @samp{($$ $)}. (The order of the arguments
20960 may seem backwards, but it is analogous to the way normal algebraic
20961 entry interacts with the stack.)
20963 If you press @kbd{$} at the operator prompt, the effect is similar to
20964 the apostrophe except that the relevant formula is taken from top-of-stack
20965 instead. The actual vector arguments of the @kbd{V A $} or related command
20966 then start at the second-to-top stack position. You will still be
20967 prompted for an argument list.
20969 @cindex Nameless functions
20970 @cindex Generic functions
20971 A function can be written without a name using the notation @samp{<#1 - #2>},
20972 which means ``a function of two arguments that computes the first
20973 argument minus the second argument.'' The symbols @samp{#1} and @samp{#2}
20974 are placeholders for the arguments. You can use any names for these
20975 placeholders if you wish, by including an argument list followed by a
20976 colon: @samp{<x, y : x - y>}. When you type @kbd{V A ' $$ + 2$^$$ @key{RET}},
20977 Calc builds the nameless function @samp{<#1 + 2 #2^#1>} as the function
20978 to map across the vectors. When you type @kbd{V A ' x + 2y^x @key{RET} @key{RET}},
20979 Calc builds the nameless function @w{@samp{<x, y : x + 2 y^x>}}. In both
20980 cases, Calc also writes the nameless function to the Trail so that you
20981 can get it back later if you wish.
20983 If there is only one argument, you can write @samp{#} in place of @samp{#1}.
20984 (Note that @samp{< >} notation is also used for date forms. Calc tells
20985 that @samp{<@var{stuff}>} is a nameless function by the presence of
20986 @samp{#} signs inside @var{stuff}, or by the fact that @var{stuff}
20987 begins with a list of variables followed by a colon.)
20989 You can type a nameless function directly to @kbd{V A '}, or put one on
20990 the stack and use it with @w{@kbd{V A $}}. Calc will not prompt for an
20991 argument list in this case, since the nameless function specifies the
20992 argument list as well as the function itself. In @kbd{V A '}, you can
20993 omit the @samp{< >} marks if you use @samp{#} notation for the arguments,
20994 so that @kbd{V A ' #1+#2 @key{RET}} is the same as @kbd{V A ' <#1+#2> @key{RET}},
20995 which in turn is the same as @kbd{V A ' $$+$ @key{RET}}.
20997 @cindex Lambda expressions
21002 The internal format for @samp{<x, y : x + y>} is @samp{lambda(x, y, x + y)}.
21003 (The word @code{lambda} derives from Lisp notation and the theory of
21004 functions.) The internal format for @samp{<#1 + #2>} is @samp{lambda(ArgA,
21005 ArgB, ArgA + ArgB)}. Note that there is no actual Calc function called
21006 @code{lambda}; the whole point is that the @code{lambda} expression is
21007 used in its symbolic form, not evaluated for an answer until it is applied
21008 to specific arguments by a command like @kbd{V A} or @kbd{V M}.
21010 (Actually, @code{lambda} does have one special property: Its arguments
21011 are never evaluated; for example, putting @samp{<(2/3) #>} on the stack
21012 will not simplify the @samp{2/3} until the nameless function is actually
21041 As usual, commands like @kbd{V A} have algebraic function name equivalents.
21042 For example, @kbd{V A k g} with an argument of @samp{v} is equivalent to
21043 @samp{apply(gcd, v)}. The first argument specifies the operator name,
21044 and is either a variable whose name is the same as the function name,
21045 or a nameless function like @samp{<#^3+1>}. Operators that are normally
21046 written as algebraic symbols have the names @code{add}, @code{sub},
21047 @code{mul}, @code{div}, @code{pow}, @code{neg}, @code{mod}, and
21054 The @code{call} function builds a function call out of several arguments:
21055 @samp{call(gcd, x, y)} is the same as @samp{apply(gcd, [x, y])}, which
21056 in turn is the same as @samp{gcd(x, y)}. The first argument of @code{call},
21057 like the other functions described here, may be either a variable naming a
21058 function, or a nameless function (@samp{call(<#1+2#2>, x, y)} is the same
21061 (Experts will notice that it's not quite proper to use a variable to name
21062 a function, since the name @code{gcd} corresponds to the Lisp variable
21063 @code{var-gcd} but to the Lisp function @code{calcFunc-gcd}. Calc
21064 automatically makes this translation, so you don't have to worry
21067 @node Mapping, Reducing, Specifying Operators, Reducing and Mapping
21068 @subsection Mapping
21075 The @kbd{V M} (@code{calc-map}) [@code{map}] command applies a given
21076 operator elementwise to one or more vectors. For example, mapping
21077 @code{A} [@code{abs}] produces a vector of the absolute values of the
21078 elements in the input vector. Mapping @code{+} pops two vectors from
21079 the stack, which must be of equal length, and produces a vector of the
21080 pairwise sums of the elements. If either argument is a non-vector, it
21081 is duplicated for each element of the other vector. For example,
21082 @kbd{[1,2,3] 2 V M ^} squares the elements of the specified vector.
21083 With the 2 listed first, it would have computed a vector of powers of
21084 two. Mapping a user-defined function pops as many arguments from the
21085 stack as the function requires. If you give an undefined name, you will
21086 be prompted for the number of arguments to use.
21088 If any argument to @kbd{V M} is a matrix, the operator is normally mapped
21089 across all elements of the matrix. For example, given the matrix
21090 @expr{[[1, -2, 3], [-4, 5, -6]]}, @kbd{V M A} takes six absolute values to
21092 @texline @math{3\times2}
21094 matrix, @expr{[[1, 2, 3], [4, 5, 6]]}.
21097 The command @kbd{V M _} [@code{mapr}] (i.e., type an underscore at the
21098 operator prompt) maps by rows instead. For example, @kbd{V M _ A} views
21099 the above matrix as a vector of two 3-element row vectors. It produces
21100 a new vector which contains the absolute values of those row vectors,
21101 namely @expr{[3.74, 8.77]}. (Recall, the absolute value of a vector is
21102 defined as the square root of the sum of the squares of the elements.)
21103 Some operators accept vectors and return new vectors; for example,
21104 @kbd{v v} reverses a vector, so @kbd{V M _ v v} would reverse each row
21105 of the matrix to get a new matrix, @expr{[[3, -2, 1], [-6, 5, -4]]}.
21107 Sometimes a vector of vectors (representing, say, strings, sets, or lists)
21108 happens to look like a matrix. If so, remember to use @kbd{V M _} if you
21109 want to map a function across the whole strings or sets rather than across
21110 their individual elements.
21113 The command @kbd{V M :} [@code{mapc}] maps by columns. Basically, it
21114 transposes the input matrix, maps by rows, and then, if the result is a
21115 matrix, transposes again. For example, @kbd{V M : A} takes the absolute
21116 values of the three columns of the matrix, treating each as a 2-vector,
21117 and @kbd{V M : v v} reverses the columns to get the matrix
21118 @expr{[[-4, 5, -6], [1, -2, 3]]}.
21120 (The symbols @kbd{_} and @kbd{:} were chosen because they had row-like
21121 and column-like appearances, and were not already taken by useful
21122 operators. Also, they appear shifted on most keyboards so they are easy
21123 to type after @kbd{V M}.)
21125 The @kbd{_} and @kbd{:} modifiers have no effect on arguments that are
21126 not matrices (so if none of the arguments are matrices, they have no
21127 effect at all). If some of the arguments are matrices and others are
21128 plain numbers, the plain numbers are held constant for all rows of the
21129 matrix (so that @kbd{2 V M _ ^} squares every row of a matrix; squaring
21130 a vector takes a dot product of the vector with itself).
21132 If some of the arguments are vectors with the same lengths as the
21133 rows (for @kbd{V M _}) or columns (for @kbd{V M :}) of the matrix
21134 arguments, those vectors are also held constant for every row or
21137 Sometimes it is useful to specify another mapping command as the operator
21138 to use with @kbd{V M}. For example, @kbd{V M _ V A +} applies @kbd{V A +}
21139 to each row of the input matrix, which in turn adds the two values on that
21140 row. If you give another vector-operator command as the operator for
21141 @kbd{V M}, it automatically uses map-by-rows mode if you don't specify
21142 otherwise; thus @kbd{V M V A +} is equivalent to @kbd{V M _ V A +}. (If
21143 you really want to map-by-elements another mapping command, you can use
21144 a triple-nested mapping command: @kbd{V M V M V A +} means to map
21145 @kbd{V M V A +} over the rows of the matrix; in turn, @kbd{V A +} is
21146 mapped over the elements of each row.)
21150 Previous versions of Calc had ``map across'' and ``map down'' modes
21151 that are now considered obsolete; the old ``map across'' is now simply
21152 @kbd{V M V A}, and ``map down'' is now @kbd{V M : V A}. The algebraic
21153 functions @code{mapa} and @code{mapd} are still supported, though.
21154 Note also that, while the old mapping modes were persistent (once you
21155 set the mode, it would apply to later mapping commands until you reset
21156 it), the new @kbd{:} and @kbd{_} modifiers apply only to the current
21157 mapping command. The default @kbd{V M} always means map-by-elements.
21159 @xref{Algebraic Manipulation}, for the @kbd{a M} command, which is like
21160 @kbd{V M} but for equations and inequalities instead of vectors.
21161 @xref{Storing Variables}, for the @kbd{s m} command which modifies a
21162 variable's stored value using a @kbd{V M}-like operator.
21164 @node Reducing, Nesting and Fixed Points, Mapping, Reducing and Mapping
21165 @subsection Reducing
21170 @pindex calc-reduce
21172 The @kbd{V R} (@code{calc-reduce}) [@code{reduce}] command applies a given
21173 binary operator across all the elements of a vector. A binary operator is
21174 a function such as @code{+} or @code{max} which takes two arguments. For
21175 example, reducing @code{+} over a vector computes the sum of the elements
21176 of the vector. Reducing @code{-} computes the first element minus each of
21177 the remaining elements. Reducing @code{max} computes the maximum element
21178 and so on. In general, reducing @code{f} over the vector @samp{[a, b, c, d]}
21179 produces @samp{f(f(f(a, b), c), d)}.
21184 The @kbd{I V R} [@code{rreduce}] command is similar to @kbd{V R} except
21185 that works from right to left through the vector. For example, plain
21186 @kbd{V R -} on the vector @samp{[a, b, c, d]} produces @samp{a - b - c - d}
21187 but @kbd{I V R -} on the same vector produces @samp{a - (b - (c - d))},
21188 or @samp{a - b + c - d}. This ``alternating sum'' occurs frequently
21189 in power series expansions.
21194 The @kbd{V U} (@code{calc-accumulate}) [@code{accum}] command does an
21195 accumulation operation. Here Calc does the corresponding reduction
21196 operation, but instead of producing only the final result, it produces
21197 a vector of all the intermediate results. Accumulating @code{+} over
21198 the vector @samp{[a, b, c, d]} produces the vector
21199 @samp{[a, a + b, a + b + c, a + b + c + d]}.
21204 The @kbd{I V U} [@code{raccum}] command does a right-to-left accumulation.
21205 For example, @kbd{I V U -} on the vector @samp{[a, b, c, d]} produces the
21206 vector @samp{[a - b + c - d, b - c + d, c - d, d]}.
21212 As for @kbd{V M}, @kbd{V R} normally reduces a matrix elementwise. For
21213 example, given the matrix @expr{[[a, b, c], [d, e, f]]}, @kbd{V R +} will
21214 compute @expr{a + b + c + d + e + f}. You can type @kbd{V R _} or
21215 @kbd{V R :} to modify this behavior. The @kbd{V R _} [@code{reducea}]
21216 command reduces ``across'' the matrix; it reduces each row of the matrix
21217 as a vector, then collects the results. Thus @kbd{V R _ +} of this
21218 matrix would produce @expr{[a + b + c, d + e + f]}. Similarly, @kbd{V R :}
21219 [@code{reduced}] reduces down; @kbd{V R : +} would produce @expr{[a + d,
21224 There is a third ``by rows'' mode for reduction that is occasionally
21225 useful; @kbd{V R =} [@code{reducer}] simply reduces the operator over
21226 the rows of the matrix themselves. Thus @kbd{V R = +} on the above
21227 matrix would get the same result as @kbd{V R : +}, since adding two
21228 row vectors is equivalent to adding their elements. But @kbd{V R = *}
21229 would multiply the two rows (to get a single number, their dot product),
21230 while @kbd{V R : *} would produce a vector of the products of the columns.
21232 These three matrix reduction modes work with @kbd{V R} and @kbd{I V R},
21233 but they are not currently supported with @kbd{V U} or @kbd{I V U}.
21237 The obsolete reduce-by-columns function, @code{reducec}, is still
21238 supported but there is no way to get it through the @kbd{V R} command.
21240 The commands @kbd{C-x * :} and @kbd{C-x * _} are equivalent to typing
21241 @kbd{C-x * r} to grab a rectangle of data into Calc, and then typing
21242 @kbd{V R : +} or @kbd{V R _ +}, respectively, to sum the columns or
21243 rows of the matrix. @xref{Grabbing From Buffers}.
21245 @node Nesting and Fixed Points, Generalized Products, Reducing, Reducing and Mapping
21246 @subsection Nesting and Fixed Points
21252 The @kbd{H V R} [@code{nest}] command applies a function to a given
21253 argument repeatedly. It takes two values, @samp{a} and @samp{n}, from
21254 the stack, where @samp{n} must be an integer. It then applies the
21255 function nested @samp{n} times; if the function is @samp{f} and @samp{n}
21256 is 3, the result is @samp{f(f(f(a)))}. The number @samp{n} may be
21257 negative if Calc knows an inverse for the function @samp{f}; for
21258 example, @samp{nest(sin, a, -2)} returns @samp{arcsin(arcsin(a))}.
21263 The @kbd{H V U} [@code{anest}] command is an accumulating version of
21264 @code{nest}: It returns a vector of @samp{n+1} values, e.g.,
21265 @samp{[a, f(a), f(f(a)), f(f(f(a)))]}. If @samp{n} is negative and
21266 @samp{F} is the inverse of @samp{f}, then the result is of the
21267 form @samp{[a, F(a), F(F(a)), F(F(F(a)))]}.
21272 @cindex Fixed points
21273 The @kbd{H I V R} [@code{fixp}] command is like @kbd{H V R}, except
21274 that it takes only an @samp{a} value from the stack; the function is
21275 applied until it reaches a ``fixed point,'' i.e., until the result
21281 The @kbd{H I V U} [@code{afixp}] command is an accumulating @code{fixp}.
21282 The first element of the return vector will be the initial value @samp{a};
21283 the last element will be the final result that would have been returned
21286 For example, 0.739085 is a fixed point of the cosine function (in radians):
21287 @samp{cos(0.739085) = 0.739085}. You can find this value by putting, say,
21288 1.0 on the stack and typing @kbd{H I V U C}. (We use the accumulating
21289 version so we can see the intermediate results: @samp{[1, 0.540302, 0.857553,
21290 0.65329, ...]}. With a precision of six, this command will take 36 steps
21291 to converge to 0.739085.)
21293 Newton's method for finding roots is a classic example of iteration
21294 to a fixed point. To find the square root of five starting with an
21295 initial guess, Newton's method would look for a fixed point of the
21296 function @samp{(x + 5/x) / 2}. Putting a guess of 1 on the stack
21297 and typing @kbd{H I V R ' ($ + 5/$)/2 @key{RET}} quickly yields the result
21298 2.23607. This is equivalent to using the @kbd{a R} (@code{calc-find-root})
21299 command to find a root of the equation @samp{x^2 = 5}.
21301 These examples used numbers for @samp{a} values. Calc keeps applying
21302 the function until two successive results are equal to within the
21303 current precision. For complex numbers, both the real parts and the
21304 imaginary parts must be equal to within the current precision. If
21305 @samp{a} is a formula (say, a variable name), then the function is
21306 applied until two successive results are exactly the same formula.
21307 It is up to you to ensure that the function will eventually converge;
21308 if it doesn't, you may have to press @kbd{C-g} to stop the Calculator.
21310 The algebraic @code{fixp} function takes two optional arguments, @samp{n}
21311 and @samp{tol}. The first is the maximum number of steps to be allowed,
21312 and must be either an integer or the symbol @samp{inf} (infinity, the
21313 default). The second is a convergence tolerance. If a tolerance is
21314 specified, all results during the calculation must be numbers, not
21315 formulas, and the iteration stops when the magnitude of the difference
21316 between two successive results is less than or equal to the tolerance.
21317 (This implies that a tolerance of zero iterates until the results are
21320 Putting it all together, @samp{fixp(<(# + A/#)/2>, B, 20, 1e-10)}
21321 computes the square root of @samp{A} given the initial guess @samp{B},
21322 stopping when the result is correct within the specified tolerance, or
21323 when 20 steps have been taken, whichever is sooner.
21325 @node Generalized Products, , Nesting and Fixed Points, Reducing and Mapping
21326 @subsection Generalized Products
21330 @pindex calc-outer-product
21332 The @kbd{V O} (@code{calc-outer-product}) [@code{outer}] command applies
21333 a given binary operator to all possible pairs of elements from two
21334 vectors, to produce a matrix. For example, @kbd{V O *} with @samp{[a, b]}
21335 and @samp{[x, y, z]} on the stack produces a multiplication table:
21336 @samp{[[a x, a y, a z], [b x, b y, b z]]}. Element @var{r},@var{c} of
21337 the result matrix is obtained by applying the operator to element @var{r}
21338 of the lefthand vector and element @var{c} of the righthand vector.
21342 @pindex calc-inner-product
21344 The @kbd{V I} (@code{calc-inner-product}) [@code{inner}] command computes
21345 the generalized inner product of two vectors or matrices, given a
21346 ``multiplicative'' operator and an ``additive'' operator. These can each
21347 actually be any binary operators; if they are @samp{*} and @samp{+},
21348 respectively, the result is a standard matrix multiplication. Element
21349 @var{r},@var{c} of the result matrix is obtained by mapping the
21350 multiplicative operator across row @var{r} of the lefthand matrix and
21351 column @var{c} of the righthand matrix, and then reducing with the additive
21352 operator. Just as for the standard @kbd{*} command, this can also do a
21353 vector-matrix or matrix-vector inner product, or a vector-vector
21354 generalized dot product.
21356 Since @kbd{V I} requires two operators, it prompts twice. In each case,
21357 you can use any of the usual methods for entering the operator. If you
21358 use @kbd{$} twice to take both operator formulas from the stack, the
21359 first (multiplicative) operator is taken from the top of the stack
21360 and the second (additive) operator is taken from second-to-top.
21362 @node Vector and Matrix Formats, , Reducing and Mapping, Matrix Functions
21363 @section Vector and Matrix Display Formats
21366 Commands for controlling vector and matrix display use the @kbd{v} prefix
21367 instead of the usual @kbd{d} prefix. But they are display modes; in
21368 particular, they are influenced by the @kbd{I} and @kbd{H} prefix keys
21369 in the same way (@pxref{Display Modes}). Matrix display is also
21370 influenced by the @kbd{d O} (@code{calc-flat-language}) mode;
21371 @pxref{Normal Language Modes}.
21375 @pindex calc-matrix-left-justify
21378 @pindex calc-matrix-center-justify
21381 @pindex calc-matrix-right-justify
21382 The commands @kbd{v <} (@code{calc-matrix-left-justify}), @kbd{v >}
21383 (@code{calc-matrix-right-justify}), and @w{@kbd{v =}}
21384 (@code{calc-matrix-center-justify}) control whether matrix elements
21385 are justified to the left, right, or center of their columns.
21389 @pindex calc-vector-brackets
21392 @pindex calc-vector-braces
21395 @pindex calc-vector-parens
21396 The @kbd{v [} (@code{calc-vector-brackets}) command turns the square
21397 brackets that surround vectors and matrices displayed in the stack on
21398 and off. The @kbd{v @{} (@code{calc-vector-braces}) and @kbd{v (}
21399 (@code{calc-vector-parens}) commands use curly braces or parentheses,
21400 respectively, instead of square brackets. For example, @kbd{v @{} might
21401 be used in preparation for yanking a matrix into a buffer running
21402 Mathematica. (In fact, the Mathematica language mode uses this mode;
21403 @pxref{Mathematica Language Mode}.) Note that, regardless of the
21404 display mode, either brackets or braces may be used to enter vectors,
21405 and parentheses may never be used for this purpose.
21413 @pindex calc-matrix-brackets
21414 The @kbd{v ]} (@code{calc-matrix-brackets}) command controls the
21415 ``big'' style display of matrices, for matrices which have more than
21416 one row. It prompts for a string of code letters; currently
21417 implemented letters are @code{R}, which enables brackets on each row
21418 of the matrix; @code{O}, which enables outer brackets in opposite
21419 corners of the matrix; and @code{C}, which enables commas or
21420 semicolons at the ends of all rows but the last. The default format
21421 is @samp{RO}. (Before Calc 2.00, the format was fixed at @samp{ROC}.)
21422 Here are some example matrices:
21426 [ [ 123, 0, 0 ] [ [ 123, 0, 0 ],
21427 [ 0, 123, 0 ] [ 0, 123, 0 ],
21428 [ 0, 0, 123 ] ] [ 0, 0, 123 ] ]
21437 [ 123, 0, 0 [ 123, 0, 0 ;
21438 0, 123, 0 0, 123, 0 ;
21439 0, 0, 123 ] 0, 0, 123 ]
21448 [ 123, 0, 0 ] 123, 0, 0
21449 [ 0, 123, 0 ] 0, 123, 0
21450 [ 0, 0, 123 ] 0, 0, 123
21457 Note that of the formats shown here, @samp{RO}, @samp{ROC}, and
21458 @samp{OC} are all recognized as matrices during reading, while
21459 the others are useful for display only.
21463 @pindex calc-vector-commas
21464 The @kbd{v ,} (@code{calc-vector-commas}) command turns commas on and
21465 off in vector and matrix display.
21467 In vectors of length one, and in all vectors when commas have been
21468 turned off, Calc adds extra parentheses around formulas that might
21469 otherwise be ambiguous. For example, @samp{[a b]} could be a vector
21470 of the one formula @samp{a b}, or it could be a vector of two
21471 variables with commas turned off. Calc will display the former
21472 case as @samp{[(a b)]}. You can disable these extra parentheses
21473 (to make the output less cluttered at the expense of allowing some
21474 ambiguity) by adding the letter @code{P} to the control string you
21475 give to @kbd{v ]} (as described above).
21479 @pindex calc-full-vectors
21480 The @kbd{v .} (@code{calc-full-vectors}) command turns abbreviated
21481 display of long vectors on and off. In this mode, vectors of six
21482 or more elements, or matrices of six or more rows or columns, will
21483 be displayed in an abbreviated form that displays only the first
21484 three elements and the last element: @samp{[a, b, c, ..., z]}.
21485 When very large vectors are involved this will substantially
21486 improve Calc's display speed.
21489 @pindex calc-full-trail-vectors
21490 The @kbd{t .} (@code{calc-full-trail-vectors}) command controls a
21491 similar mode for recording vectors in the Trail. If you turn on
21492 this mode, vectors of six or more elements and matrices of six or
21493 more rows or columns will be abbreviated when they are put in the
21494 Trail. The @kbd{t y} (@code{calc-trail-yank}) command will be
21495 unable to recover those vectors. If you are working with very
21496 large vectors, this mode will improve the speed of all operations
21497 that involve the trail.
21501 @pindex calc-break-vectors
21502 The @kbd{v /} (@code{calc-break-vectors}) command turns multi-line
21503 vector display on and off. Normally, matrices are displayed with one
21504 row per line but all other types of vectors are displayed in a single
21505 line. This mode causes all vectors, whether matrices or not, to be
21506 displayed with a single element per line. Sub-vectors within the
21507 vectors will still use the normal linear form.
21509 @node Algebra, Units, Matrix Functions, Top
21513 This section covers the Calc features that help you work with
21514 algebraic formulas. First, the general sub-formula selection
21515 mechanism is described; this works in conjunction with any Calc
21516 commands. Then, commands for specific algebraic operations are
21517 described. Finally, the flexible @dfn{rewrite rule} mechanism
21520 The algebraic commands use the @kbd{a} key prefix; selection
21521 commands use the @kbd{j} (for ``just a letter that wasn't used
21522 for anything else'') prefix.
21524 @xref{Editing Stack Entries}, to see how to manipulate formulas
21525 using regular Emacs editing commands.
21527 When doing algebraic work, you may find several of the Calculator's
21528 modes to be helpful, including Algebraic Simplification mode (@kbd{m A})
21529 or No-Simplification mode (@kbd{m O}),
21530 Algebraic entry mode (@kbd{m a}), Fraction mode (@kbd{m f}), and
21531 Symbolic mode (@kbd{m s}). @xref{Mode Settings}, for discussions
21532 of these modes. You may also wish to select Big display mode (@kbd{d B}).
21533 @xref{Normal Language Modes}.
21536 * Selecting Subformulas::
21537 * Algebraic Manipulation::
21538 * Simplifying Formulas::
21541 * Solving Equations::
21542 * Numerical Solutions::
21545 * Logical Operations::
21549 @node Selecting Subformulas, Algebraic Manipulation, Algebra, Algebra
21550 @section Selecting Sub-Formulas
21554 @cindex Sub-formulas
21555 @cindex Parts of formulas
21556 When working with an algebraic formula it is often necessary to
21557 manipulate a portion of the formula rather than the formula as a
21558 whole. Calc allows you to ``select'' a portion of any formula on
21559 the stack. Commands which would normally operate on that stack
21560 entry will now operate only on the sub-formula, leaving the
21561 surrounding part of the stack entry alone.
21563 One common non-algebraic use for selection involves vectors. To work
21564 on one element of a vector in-place, simply select that element as a
21565 ``sub-formula'' of the vector.
21568 * Making Selections::
21569 * Changing Selections::
21570 * Displaying Selections::
21571 * Operating on Selections::
21572 * Rearranging with Selections::
21575 @node Making Selections, Changing Selections, Selecting Subformulas, Selecting Subformulas
21576 @subsection Making Selections
21580 @pindex calc-select-here
21581 To select a sub-formula, move the Emacs cursor to any character in that
21582 sub-formula, and press @w{@kbd{j s}} (@code{calc-select-here}). Calc will
21583 highlight the smallest portion of the formula that contains that
21584 character. By default the sub-formula is highlighted by blanking out
21585 all of the rest of the formula with dots. Selection works in any
21586 display mode but is perhaps easiest in Big mode (@kbd{d B}).
21587 Suppose you enter the following formula:
21599 (by typing @kbd{' ((a+b)^3 + sqrt(c)) / (2x+1)}). If you move the
21600 cursor to the letter @samp{b} and press @w{@kbd{j s}}, the display changes
21613 Every character not part of the sub-formula @samp{b} has been changed
21614 to a dot. (If the customizable variable
21615 @code{calc-highlight-selections-with-faces} is non-@code{nil}, then the characters
21616 not part of the sub-formula are de-emphasized by using a less
21617 noticeable face instead of using dots. @pxref{Displaying Selections}.)
21618 The @samp{*} next to the line number is to remind you that
21619 the formula has a portion of it selected. (In this case, it's very
21620 obvious, but it might not always be. If Embedded mode is enabled,
21621 the word @samp{Sel} also appears in the mode line because the stack
21622 may not be visible. @pxref{Embedded Mode}.)
21624 If you had instead placed the cursor on the parenthesis immediately to
21625 the right of the @samp{b}, the selection would have been:
21637 The portion selected is always large enough to be considered a complete
21638 formula all by itself, so selecting the parenthesis selects the whole
21639 formula that it encloses. Putting the cursor on the @samp{+} sign
21640 would have had the same effect.
21642 (Strictly speaking, the Emacs cursor is really the manifestation of
21643 the Emacs ``point,'' which is a position @emph{between} two characters
21644 in the buffer. So purists would say that Calc selects the smallest
21645 sub-formula which contains the character to the right of ``point.'')
21647 If you supply a numeric prefix argument @var{n}, the selection is
21648 expanded to the @var{n}th enclosing sub-formula. Thus, positioning
21649 the cursor on the @samp{b} and typing @kbd{C-u 1 j s} will select
21650 @samp{a + b}; typing @kbd{C-u 2 j s} will select @samp{(a + b)^3},
21653 If the cursor is not on any part of the formula, or if you give a
21654 numeric prefix that is too large, the entire formula is selected.
21656 If the cursor is on the @samp{.} line that marks the top of the stack
21657 (i.e., its normal ``rest position''), this command selects the entire
21658 formula at stack level 1. Most selection commands similarly operate
21659 on the formula at the top of the stack if you haven't positioned the
21660 cursor on any stack entry.
21663 @pindex calc-select-additional
21664 The @kbd{j a} (@code{calc-select-additional}) command enlarges the
21665 current selection to encompass the cursor. To select the smallest
21666 sub-formula defined by two different points, move to the first and
21667 press @kbd{j s}, then move to the other and press @kbd{j a}. This
21668 is roughly analogous to using @kbd{C-@@} (@code{set-mark-command}) to
21669 select the two ends of a region of text during normal Emacs editing.
21672 @pindex calc-select-once
21673 The @kbd{j o} (@code{calc-select-once}) command selects a formula in
21674 exactly the same way as @kbd{j s}, except that the selection will
21675 last only as long as the next command that uses it. For example,
21676 @kbd{j o 1 +} is a handy way to add one to the sub-formula indicated
21679 (A somewhat more precise definition: The @kbd{j o} command sets a flag
21680 such that the next command involving selected stack entries will clear
21681 the selections on those stack entries afterwards. All other selection
21682 commands except @kbd{j a} and @kbd{j O} clear this flag.)
21686 @pindex calc-select-here-maybe
21687 @pindex calc-select-once-maybe
21688 The @kbd{j S} (@code{calc-select-here-maybe}) and @kbd{j O}
21689 (@code{calc-select-once-maybe}) commands are equivalent to @kbd{j s}
21690 and @kbd{j o}, respectively, except that if the formula already
21691 has a selection they have no effect. This is analogous to the
21692 behavior of some commands such as @kbd{j r} (@code{calc-rewrite-selection};
21693 @pxref{Selections with Rewrite Rules}) and is mainly intended to be
21694 used in keyboard macros that implement your own selection-oriented
21697 Selection of sub-formulas normally treats associative terms like
21698 @samp{a + b - c + d} and @samp{x * y * z} as single levels of the formula.
21699 If you place the cursor anywhere inside @samp{a + b - c + d} except
21700 on one of the variable names and use @kbd{j s}, you will select the
21701 entire four-term sum.
21704 @pindex calc-break-selections
21705 The @kbd{j b} (@code{calc-break-selections}) command controls a mode
21706 in which the ``deep structure'' of these associative formulas shows
21707 through. Calc actually stores the above formulas as
21708 @samp{((a + b) - c) + d} and @samp{x * (y * z)}. (Note that for certain
21709 obscure reasons, by default Calc treats multiplication as
21710 right-associative.) Once you have enabled @kbd{j b} mode, selecting
21711 with the cursor on the @samp{-} sign would only select the @samp{a + b -
21712 c} portion, which makes sense when the deep structure of the sum is
21713 considered. There is no way to select the @samp{b - c + d} portion;
21714 although this might initially look like just as legitimate a sub-formula
21715 as @samp{a + b - c}, the deep structure shows that it isn't. The @kbd{d
21716 U} command can be used to view the deep structure of any formula
21717 (@pxref{Normal Language Modes}).
21719 When @kbd{j b} mode has not been enabled, the deep structure is
21720 generally hidden by the selection commands---what you see is what
21724 @pindex calc-unselect
21725 The @kbd{j u} (@code{calc-unselect}) command unselects the formula
21726 that the cursor is on. If there was no selection in the formula,
21727 this command has no effect. With a numeric prefix argument, it
21728 unselects the @var{n}th stack element rather than using the cursor
21732 @pindex calc-clear-selections
21733 The @kbd{j c} (@code{calc-clear-selections}) command unselects all
21736 @node Changing Selections, Displaying Selections, Making Selections, Selecting Subformulas
21737 @subsection Changing Selections
21741 @pindex calc-select-more
21742 Once you have selected a sub-formula, you can expand it using the
21743 @w{@kbd{j m}} (@code{calc-select-more}) command. If @samp{a + b} is
21744 selected, pressing @w{@kbd{j m}} repeatedly works as follows:
21749 (a + b) . . . (a + b) + V c (a + b) + V c
21750 1* ............... 1* ............... 1* ---------------
21751 . . . . . . . . 2 x + 1
21756 In the last example, the entire formula is selected. This is roughly
21757 the same as having no selection at all, but because there are subtle
21758 differences the @samp{*} character is still there on the line number.
21760 With a numeric prefix argument @var{n}, @kbd{j m} expands @var{n}
21761 times (or until the entire formula is selected). Note that @kbd{j s}
21762 with argument @var{n} is equivalent to plain @kbd{j s} followed by
21763 @kbd{j m} with argument @var{n}. If @w{@kbd{j m}} is used when there
21764 is no current selection, it is equivalent to @w{@kbd{j s}}.
21766 Even though @kbd{j m} does not explicitly use the location of the
21767 cursor within the formula, it nevertheless uses the cursor to determine
21768 which stack element to operate on. As usual, @kbd{j m} when the cursor
21769 is not on any stack element operates on the top stack element.
21772 @pindex calc-select-less
21773 The @kbd{j l} (@code{calc-select-less}) command reduces the current
21774 selection around the cursor position. That is, it selects the
21775 immediate sub-formula of the current selection which contains the
21776 cursor, the opposite of @kbd{j m}. If the cursor is not inside the
21777 current selection, the command de-selects the formula.
21780 @pindex calc-select-part
21781 The @kbd{j 1} through @kbd{j 9} (@code{calc-select-part}) commands
21782 select the @var{n}th sub-formula of the current selection. They are
21783 like @kbd{j l} (@code{calc-select-less}) except they use counting
21784 rather than the cursor position to decide which sub-formula to select.
21785 For example, if the current selection is @kbd{a + b + c} or
21786 @kbd{f(a, b, c)} or @kbd{[a, b, c]}, then @kbd{j 1} selects @samp{a},
21787 @kbd{j 2} selects @samp{b}, and @kbd{j 3} selects @samp{c}; in each of
21788 these cases, @kbd{j 4} through @kbd{j 9} would be errors.
21790 If there is no current selection, @kbd{j 1} through @kbd{j 9} select
21791 the @var{n}th top-level sub-formula. (In other words, they act as if
21792 the entire stack entry were selected first.) To select the @var{n}th
21793 sub-formula where @var{n} is greater than nine, you must instead invoke
21794 @w{@kbd{j 1}} with @var{n} as a numeric prefix argument.
21798 @pindex calc-select-next
21799 @pindex calc-select-previous
21800 The @kbd{j n} (@code{calc-select-next}) and @kbd{j p}
21801 (@code{calc-select-previous}) commands change the current selection
21802 to the next or previous sub-formula at the same level. For example,
21803 if @samp{b} is selected in @w{@samp{2 + a*b*c + x}}, then @kbd{j n}
21804 selects @samp{c}. Further @kbd{j n} commands would be in error because,
21805 even though there is something to the right of @samp{c} (namely, @samp{x}),
21806 it is not at the same level; in this case, it is not a term of the
21807 same product as @samp{b} and @samp{c}. However, @kbd{j m} (to select
21808 the whole product @samp{a*b*c} as a term of the sum) followed by
21809 @w{@kbd{j n}} would successfully select the @samp{x}.
21811 Similarly, @kbd{j p} moves the selection from the @samp{b} in this
21812 sample formula to the @samp{a}. Both commands accept numeric prefix
21813 arguments to move several steps at a time.
21815 It is interesting to compare Calc's selection commands with the
21816 Emacs Info system's commands for navigating through hierarchically
21817 organized documentation. Calc's @kbd{j n} command is completely
21818 analogous to Info's @kbd{n} command. Likewise, @kbd{j p} maps to
21819 @kbd{p}, @kbd{j 2} maps to @kbd{2}, and Info's @kbd{u} is like @kbd{j m}.
21820 (Note that @kbd{j u} stands for @code{calc-unselect}, not ``up''.)
21821 The Info @kbd{m} command is somewhat similar to Calc's @kbd{j s} and
21822 @kbd{j l}; in each case, you can jump directly to a sub-component
21823 of the hierarchy simply by pointing to it with the cursor.
21825 @node Displaying Selections, Operating on Selections, Changing Selections, Selecting Subformulas
21826 @subsection Displaying Selections
21830 @pindex calc-show-selections
21831 @vindex calc-highlight-selections-with-faces
21832 @vindex calc-selected-face
21833 @vindex calc-nonselected-face
21834 The @kbd{j d} (@code{calc-show-selections}) command controls how
21835 selected sub-formulas are displayed. One of the alternatives is
21836 illustrated in the above examples; if we press @kbd{j d} we switch
21837 to the other style in which the selected portion itself is obscured
21843 (a + b) . . . ## # ## + V c
21844 1* ............... 1* ---------------
21848 If the customizable variable
21849 @code{calc-highlight-selections-with-faces} is non-@code{nil}, then the
21850 non-selected portion of the formula will be de-emphasized by using a
21851 less noticeable face (@code{calc-nonselected-face}) instead of dots
21852 and the selected sub-formula will be highlighted by using a more
21853 noticeable face (@code{calc-selected-face}) instead of @samp{#}
21854 signs. (@pxref{Customizing Calc}.)
21856 @node Operating on Selections, Rearranging with Selections, Displaying Selections, Selecting Subformulas
21857 @subsection Operating on Selections
21860 Once a selection is made, all Calc commands that manipulate items
21861 on the stack will operate on the selected portions of the items
21862 instead. (Note that several stack elements may have selections
21863 at once, though there can be only one selection at a time in any
21864 given stack element.)
21867 @pindex calc-enable-selections
21868 The @kbd{j e} (@code{calc-enable-selections}) command disables the
21869 effect that selections have on Calc commands. The current selections
21870 still exist, but Calc commands operate on whole stack elements anyway.
21871 This mode can be identified by the fact that the @samp{*} markers on
21872 the line numbers are gone, even though selections are visible. To
21873 reactivate the selections, press @kbd{j e} again.
21875 To extract a sub-formula as a new formula, simply select the
21876 sub-formula and press @key{RET}. This normally duplicates the top
21877 stack element; here it duplicates only the selected portion of that
21880 To replace a sub-formula with something different, you can enter the
21881 new value onto the stack and press @key{TAB}. This normally exchanges
21882 the top two stack elements; here it swaps the value you entered into
21883 the selected portion of the formula, returning the old selected
21884 portion to the top of the stack.
21889 (a + b) . . . 17 x y . . . 17 x y + V c
21890 2* ............... 2* ............. 2: -------------
21891 . . . . . . . . 2 x + 1
21894 1: 17 x y 1: (a + b) 1: (a + b)
21898 In this example we select a sub-formula of our original example,
21899 enter a new formula, @key{TAB} it into place, then deselect to see
21900 the complete, edited formula.
21902 If you want to swap whole formulas around even though they contain
21903 selections, just use @kbd{j e} before and after.
21906 @pindex calc-enter-selection
21907 The @kbd{j '} (@code{calc-enter-selection}) command is another way
21908 to replace a selected sub-formula. This command does an algebraic
21909 entry just like the regular @kbd{'} key. When you press @key{RET},
21910 the formula you type replaces the original selection. You can use
21911 the @samp{$} symbol in the formula to refer to the original
21912 selection. If there is no selection in the formula under the cursor,
21913 the cursor is used to make a temporary selection for the purposes of
21914 the command. Thus, to change a term of a formula, all you have to
21915 do is move the Emacs cursor to that term and press @kbd{j '}.
21918 @pindex calc-edit-selection
21919 The @kbd{j `} (@code{calc-edit-selection}) command is a similar
21920 analogue of the @kbd{`} (@code{calc-edit}) command. It edits the
21921 selected sub-formula in a separate buffer. If there is no
21922 selection, it edits the sub-formula indicated by the cursor.
21924 To delete a sub-formula, press @key{DEL}. This generally replaces
21925 the sub-formula with the constant zero, but in a few suitable contexts
21926 it uses the constant one instead. The @key{DEL} key automatically
21927 deselects and re-simplifies the entire formula afterwards. Thus:
21932 17 x y + # # 17 x y 17 # y 17 y
21933 1* ------------- 1: ------- 1* ------- 1: -------
21934 2 x + 1 2 x + 1 2 x + 1 2 x + 1
21938 In this example, we first delete the @samp{sqrt(c)} term; Calc
21939 accomplishes this by replacing @samp{sqrt(c)} with zero and
21940 resimplifying. We then delete the @kbd{x} in the numerator;
21941 since this is part of a product, Calc replaces it with @samp{1}
21944 If you select an element of a vector and press @key{DEL}, that
21945 element is deleted from the vector. If you delete one side of
21946 an equation or inequality, only the opposite side remains.
21948 @kindex j @key{DEL}
21949 @pindex calc-del-selection
21950 The @kbd{j @key{DEL}} (@code{calc-del-selection}) command is like
21951 @key{DEL} but with the auto-selecting behavior of @kbd{j '} and
21952 @kbd{j `}. It deletes the selected portion of the formula
21953 indicated by the cursor, or, in the absence of a selection, it
21954 deletes the sub-formula indicated by the cursor position.
21956 @kindex j @key{RET}
21957 @pindex calc-grab-selection
21958 (There is also an auto-selecting @kbd{j @key{RET}} (@code{calc-copy-selection})
21961 Normal arithmetic operations also apply to sub-formulas. Here we
21962 select the denominator, press @kbd{5 -} to subtract five from the
21963 denominator, press @kbd{n} to negate the denominator, then
21964 press @kbd{Q} to take the square root.
21968 .. . .. . .. . .. .
21969 1* ....... 1* ....... 1* ....... 1* ..........
21970 2 x + 1 2 x - 4 4 - 2 x _________
21975 Certain types of operations on selections are not allowed. For
21976 example, for an arithmetic function like @kbd{-} no more than one of
21977 the arguments may be a selected sub-formula. (As the above example
21978 shows, the result of the subtraction is spliced back into the argument
21979 which had the selection; if there were more than one selection involved,
21980 this would not be well-defined.) If you try to subtract two selections,
21981 the command will abort with an error message.
21983 Operations on sub-formulas sometimes leave the formula as a whole
21984 in an ``un-natural'' state. Consider negating the @samp{2 x} term
21985 of our sample formula by selecting it and pressing @kbd{n}
21986 (@code{calc-change-sign}).
21991 1* .......... 1* ...........
21992 ......... ..........
21993 . . . 2 x . . . -2 x
21997 Unselecting the sub-formula reveals that the minus sign, which would
21998 normally have canceled out with the subtraction automatically, has
21999 not been able to do so because the subtraction was not part of the
22000 selected portion. Pressing @kbd{=} (@code{calc-evaluate}) or doing
22001 any other mathematical operation on the whole formula will cause it
22007 1: ----------- 1: ----------
22008 __________ _________
22009 V 4 - -2 x V 4 + 2 x
22013 @node Rearranging with Selections, , Operating on Selections, Selecting Subformulas
22014 @subsection Rearranging Formulas using Selections
22018 @pindex calc-commute-right
22019 The @kbd{j R} (@code{calc-commute-right}) command moves the selected
22020 sub-formula to the right in its surrounding formula. Generally the
22021 selection is one term of a sum or product; the sum or product is
22022 rearranged according to the commutative laws of algebra.
22024 As with @kbd{j '} and @kbd{j @key{DEL}}, the term under the cursor is used
22025 if there is no selection in the current formula. All commands described
22026 in this section share this property. In this example, we place the
22027 cursor on the @samp{a} and type @kbd{j R}, then repeat.
22030 1: a + b - c 1: b + a - c 1: b - c + a
22034 Note that in the final step above, the @samp{a} is switched with
22035 the @samp{c} but the signs are adjusted accordingly. When moving
22036 terms of sums and products, @kbd{j R} will never change the
22037 mathematical meaning of the formula.
22039 The selected term may also be an element of a vector or an argument
22040 of a function. The term is exchanged with the one to its right.
22041 In this case, the ``meaning'' of the vector or function may of
22042 course be drastically changed.
22045 1: [a, b, c] 1: [b, a, c] 1: [b, c, a]
22047 1: f(a, b, c) 1: f(b, a, c) 1: f(b, c, a)
22051 @pindex calc-commute-left
22052 The @kbd{j L} (@code{calc-commute-left}) command is like @kbd{j R}
22053 except that it swaps the selected term with the one to its left.
22055 With numeric prefix arguments, these commands move the selected
22056 term several steps at a time. It is an error to try to move a
22057 term left or right past the end of its enclosing formula.
22058 With numeric prefix arguments of zero, these commands move the
22059 selected term as far as possible in the given direction.
22062 @pindex calc-sel-distribute
22063 The @kbd{j D} (@code{calc-sel-distribute}) command mixes the selected
22064 sum or product into the surrounding formula using the distributive
22065 law. For example, in @samp{a * (b - c)} with the @samp{b - c}
22066 selected, the result is @samp{a b - a c}. This also distributes
22067 products or quotients into surrounding powers, and can also do
22068 transformations like @samp{exp(a + b)} to @samp{exp(a) exp(b)},
22069 where @samp{a + b} is the selected term, and @samp{ln(a ^ b)}
22070 to @samp{ln(a) b}, where @samp{a ^ b} is the selected term.
22072 For multiple-term sums or products, @kbd{j D} takes off one term
22073 at a time: @samp{a * (b + c - d)} goes to @samp{a * (c - d) + a b}
22074 with the @samp{c - d} selected so that you can type @kbd{j D}
22075 repeatedly to expand completely. The @kbd{j D} command allows a
22076 numeric prefix argument which specifies the maximum number of
22077 times to expand at once; the default is one time only.
22079 @vindex DistribRules
22080 The @kbd{j D} command is implemented using rewrite rules.
22081 @xref{Selections with Rewrite Rules}. The rules are stored in
22082 the Calc variable @code{DistribRules}. A convenient way to view
22083 these rules is to use @kbd{s e} (@code{calc-edit-variable}) which
22084 displays and edits the stored value of a variable. Press @kbd{C-c C-c}
22085 to return from editing mode; be careful not to make any actual changes
22086 or else you will affect the behavior of future @kbd{j D} commands!
22088 To extend @kbd{j D} to handle new cases, just edit @code{DistribRules}
22089 as described above. You can then use the @kbd{s p} command to save
22090 this variable's value permanently for future Calc sessions.
22091 @xref{Operations on Variables}.
22094 @pindex calc-sel-merge
22096 The @kbd{j M} (@code{calc-sel-merge}) command is the complement
22097 of @kbd{j D}; given @samp{a b - a c} with either @samp{a b} or
22098 @samp{a c} selected, the result is @samp{a * (b - c)}. Once
22099 again, @kbd{j M} can also merge calls to functions like @code{exp}
22100 and @code{ln}; examine the variable @code{MergeRules} to see all
22101 the relevant rules.
22104 @pindex calc-sel-commute
22105 @vindex CommuteRules
22106 The @kbd{j C} (@code{calc-sel-commute}) command swaps the arguments
22107 of the selected sum, product, or equation. It always behaves as
22108 if @kbd{j b} mode were in effect, i.e., the sum @samp{a + b + c} is
22109 treated as the nested sums @samp{(a + b) + c} by this command.
22110 If you put the cursor on the first @samp{+}, the result is
22111 @samp{(b + a) + c}; if you put the cursor on the second @samp{+}, the
22112 result is @samp{c + (a + b)} (which the default simplifications
22113 will rearrange to @samp{(c + a) + b}). The relevant rules are stored
22114 in the variable @code{CommuteRules}.
22116 You may need to turn default simplifications off (with the @kbd{m O}
22117 command) in order to get the full benefit of @kbd{j C}. For example,
22118 commuting @samp{a - b} produces @samp{-b + a}, but the default
22119 simplifications will ``simplify'' this right back to @samp{a - b} if
22120 you don't turn them off. The same is true of some of the other
22121 manipulations described in this section.
22124 @pindex calc-sel-negate
22125 @vindex NegateRules
22126 The @kbd{j N} (@code{calc-sel-negate}) command replaces the selected
22127 term with the negative of that term, then adjusts the surrounding
22128 formula in order to preserve the meaning. For example, given
22129 @samp{exp(a - b)} where @samp{a - b} is selected, the result is
22130 @samp{1 / exp(b - a)}. By contrast, selecting a term and using the
22131 regular @kbd{n} (@code{calc-change-sign}) command negates the
22132 term without adjusting the surroundings, thus changing the meaning
22133 of the formula as a whole. The rules variable is @code{NegateRules}.
22136 @pindex calc-sel-invert
22137 @vindex InvertRules
22138 The @kbd{j &} (@code{calc-sel-invert}) command is similar to @kbd{j N}
22139 except it takes the reciprocal of the selected term. For example,
22140 given @samp{a - ln(b)} with @samp{b} selected, the result is
22141 @samp{a + ln(1/b)}. The rules variable is @code{InvertRules}.
22144 @pindex calc-sel-jump-equals
22146 The @kbd{j E} (@code{calc-sel-jump-equals}) command moves the
22147 selected term from one side of an equation to the other. Given
22148 @samp{a + b = c + d} with @samp{c} selected, the result is
22149 @samp{a + b - c = d}. This command also works if the selected
22150 term is part of a @samp{*}, @samp{/}, or @samp{^} formula. The
22151 relevant rules variable is @code{JumpRules}.
22155 @pindex calc-sel-isolate
22156 The @kbd{j I} (@code{calc-sel-isolate}) command isolates the
22157 selected term on its side of an equation. It uses the @kbd{a S}
22158 (@code{calc-solve-for}) command to solve the equation, and the
22159 Hyperbolic flag affects it in the same way. @xref{Solving Equations}.
22160 When it applies, @kbd{j I} is often easier to use than @kbd{j E}.
22161 It understands more rules of algebra, and works for inequalities
22162 as well as equations.
22166 @pindex calc-sel-mult-both-sides
22167 @pindex calc-sel-div-both-sides
22168 The @kbd{j *} (@code{calc-sel-mult-both-sides}) command prompts for a
22169 formula using algebraic entry, then multiplies both sides of the
22170 selected quotient or equation by that formula. It performs the
22171 default algebraic simplifications before re-forming the
22172 quotient or equation. You can suppress this simplification by
22173 providing a prefix argument: @kbd{C-u j *}. There is also a @kbd{j /}
22174 (@code{calc-sel-div-both-sides}) which is similar to @kbd{j *} but
22175 dividing instead of multiplying by the factor you enter.
22177 If the selection is a quotient with numerator 1, then Calc's default
22178 simplifications would normally cancel the new factors. To prevent
22179 this, when the @kbd{j *} command is used on a selection whose numerator is
22180 1 or -1, the denominator is expanded at the top level using the
22181 distributive law (as if using the @kbd{C-u 1 a x} command). Suppose the
22182 formula on the stack is @samp{1 / (a + 1)} and you wish to multiplying the
22183 top and bottom by @samp{a - 1}. Calc's default simplifications would
22184 normally change the result @samp{(a - 1) /(a + 1) (a - 1)} back
22185 to the original form by cancellation; when @kbd{j *} is used, Calc
22186 expands the denominator to @samp{a (a - 1) + a - 1} to prevent this.
22188 If you wish the @kbd{j *} command to completely expand the denominator
22189 of a quotient you can call it with a zero prefix: @kbd{C-u 0 j *}. For
22190 example, if the formula on the stack is @samp{1 / (sqrt(a) + 1)}, you may
22191 wish to eliminate the square root in the denominator by multiplying
22192 the top and bottom by @samp{sqrt(a) - 1}. If you did this simply by using
22193 a simple @kbd{j *} command, you would get
22194 @samp{(sqrt(a)-1)/ (sqrt(a) (sqrt(a) - 1) + sqrt(a) - 1)}. Instead,
22195 you would probably want to use @kbd{C-u 0 j *}, which would expand the
22196 bottom and give you the desired result @samp{(sqrt(a)-1)/(a-1)}. More
22197 generally, if @kbd{j *} is called with an argument of a positive
22198 integer @var{n}, then the denominator of the expression will be
22199 expanded @var{n} times (as if with the @kbd{C-u @var{n} a x} command).
22201 If the selection is an inequality, @kbd{j *} and @kbd{j /} will
22202 accept any factor, but will warn unless they can prove the factor
22203 is either positive or negative. (In the latter case the direction
22204 of the inequality will be switched appropriately.) @xref{Declarations},
22205 for ways to inform Calc that a given variable is positive or
22206 negative. If Calc can't tell for sure what the sign of the factor
22207 will be, it will assume it is positive and display a warning
22210 For selections that are not quotients, equations, or inequalities,
22211 these commands pull out a multiplicative factor: They divide (or
22212 multiply) by the entered formula, simplify, then multiply (or divide)
22213 back by the formula.
22217 @pindex calc-sel-add-both-sides
22218 @pindex calc-sel-sub-both-sides
22219 The @kbd{j +} (@code{calc-sel-add-both-sides}) and @kbd{j -}
22220 (@code{calc-sel-sub-both-sides}) commands analogously add to or
22221 subtract from both sides of an equation or inequality. For other
22222 types of selections, they extract an additive factor. A numeric
22223 prefix argument suppresses simplification of the intermediate
22227 @pindex calc-sel-unpack
22228 The @kbd{j U} (@code{calc-sel-unpack}) command replaces the
22229 selected function call with its argument. For example, given
22230 @samp{a + sin(x^2)} with @samp{sin(x^2)} selected, the result
22231 is @samp{a + x^2}. (The @samp{x^2} will remain selected; if you
22232 wanted to change the @code{sin} to @code{cos}, just press @kbd{C}
22233 now to take the cosine of the selected part.)
22236 @pindex calc-sel-evaluate
22237 The @kbd{j v} (@code{calc-sel-evaluate}) command performs the
22238 basic simplifications on the selected sub-formula.
22239 These simplifications would normally be done automatically
22240 on all results, but may have been partially inhibited by
22241 previous selection-related operations, or turned off altogether
22242 by the @kbd{m O} command. This command is just an auto-selecting
22243 version of the @w{@kbd{a v}} command (@pxref{Algebraic Manipulation}).
22245 With a numeric prefix argument of 2, @kbd{C-u 2 j v} applies
22246 the default algebraic simplifications to the selected
22247 sub-formula. With a prefix argument of 3 or more, e.g., @kbd{C-u j v}
22248 applies the @kbd{a e} (@code{calc-simplify-extended}) command.
22249 @xref{Simplifying Formulas}. With a negative prefix argument
22250 it simplifies at the top level only, just as with @kbd{a v}.
22251 Here the ``top'' level refers to the top level of the selected
22255 @pindex calc-sel-expand-formula
22256 The @kbd{j "} (@code{calc-sel-expand-formula}) command is to @kbd{a "}
22257 (@pxref{Algebraic Manipulation}) what @kbd{j v} is to @kbd{a v}.
22259 You can use the @kbd{j r} (@code{calc-rewrite-selection}) command
22260 to define other algebraic operations on sub-formulas. @xref{Rewrite Rules}.
22262 @node Algebraic Manipulation, Simplifying Formulas, Selecting Subformulas, Algebra
22263 @section Algebraic Manipulation
22266 The commands in this section perform general-purpose algebraic
22267 manipulations. They work on the whole formula at the top of the
22268 stack (unless, of course, you have made a selection in that
22271 Many algebra commands prompt for a variable name or formula. If you
22272 answer the prompt with a blank line, the variable or formula is taken
22273 from top-of-stack, and the normal argument for the command is taken
22274 from the second-to-top stack level.
22277 @pindex calc-alg-evaluate
22278 The @kbd{a v} (@code{calc-alg-evaluate}) command performs the normal
22279 default simplifications on a formula; for example, @samp{a - -b} is
22280 changed to @samp{a + b}. These simplifications are normally done
22281 automatically on all Calc results, so this command is useful only if
22282 you have turned default simplifications off with an @kbd{m O}
22283 command. @xref{Simplification Modes}.
22285 It is often more convenient to type @kbd{=}, which is like @kbd{a v}
22286 but which also substitutes stored values for variables in the formula.
22287 Use @kbd{a v} if you want the variables to ignore their stored values.
22289 If you give a numeric prefix argument of 2 to @kbd{a v}, it simplifies
22290 using Calc's algebraic simplifications; @pxref{Simplifying Formulas}.
22291 If you give a numeric prefix of 3 or more, it uses Extended
22292 Simplification mode (@kbd{a e}).
22294 If you give a negative prefix argument @mathit{-1}, @mathit{-2}, or @mathit{-3},
22295 it simplifies in the corresponding mode but only works on the top-level
22296 function call of the formula. For example, @samp{(2 + 3) * (2 + 3)} will
22297 simplify to @samp{(2 + 3)^2}, without simplifying the sub-formulas
22298 @samp{2 + 3}. As another example, typing @kbd{V R +} to sum the vector
22299 @samp{[1, 2, 3, 4]} produces the formula @samp{reduce(add, [1, 2, 3, 4])}
22300 in No-Simplify mode. Using @kbd{a v} will evaluate this all the way to
22301 10; using @kbd{C-u - a v} will evaluate it only to @samp{1 + 2 + 3 + 4}.
22302 (@xref{Reducing and Mapping}.)
22306 The @kbd{=} command corresponds to the @code{evalv} function, and
22307 the related @kbd{N} command, which is like @kbd{=} but temporarily
22308 disables Symbolic mode (@kbd{m s}) during the evaluation, corresponds
22309 to the @code{evalvn} function. (These commands interpret their prefix
22310 arguments differently than @kbd{a v}; @kbd{=} treats the prefix as
22311 the number of stack elements to evaluate at once, and @kbd{N} treats
22312 it as a temporary different working precision.)
22314 The @code{evalvn} function can take an alternate working precision
22315 as an optional second argument. This argument can be either an
22316 integer, to set the precision absolutely, or a vector containing
22317 a single integer, to adjust the precision relative to the current
22318 precision. Note that @code{evalvn} with a larger than current
22319 precision will do the calculation at this higher precision, but the
22320 result will as usual be rounded back down to the current precision
22321 afterward. For example, @samp{evalvn(pi - 3.1415)} at a precision
22322 of 12 will return @samp{9.265359e-5}; @samp{evalvn(pi - 3.1415, 30)}
22323 will return @samp{9.26535897932e-5} (computing a 25-digit result which
22324 is then rounded down to 12); and @samp{evalvn(pi - 3.1415, [-2])}
22325 will return @samp{9.2654e-5}.
22328 @pindex calc-expand-formula
22329 The @kbd{a "} (@code{calc-expand-formula}) command expands functions
22330 into their defining formulas wherever possible. For example,
22331 @samp{deg(x^2)} is changed to @samp{180 x^2 / pi}. Most functions,
22332 like @code{sin} and @code{gcd}, are not defined by simple formulas
22333 and so are unaffected by this command. One important class of
22334 functions which @emph{can} be expanded is the user-defined functions
22335 created by the @kbd{Z F} command. @xref{Algebraic Definitions}.
22336 Other functions which @kbd{a "} can expand include the probability
22337 distribution functions, most of the financial functions, and the
22338 hyperbolic and inverse hyperbolic functions. A numeric prefix argument
22339 affects @kbd{a "} in the same way as it does @kbd{a v}: A positive
22340 argument expands all functions in the formula and then simplifies in
22341 various ways; a negative argument expands and simplifies only the
22342 top-level function call.
22345 @pindex calc-map-equation
22347 The @kbd{a M} (@code{calc-map-equation}) [@code{mapeq}] command applies
22348 a given function or operator to one or more equations. It is analogous
22349 to @kbd{V M}, which operates on vectors instead of equations.
22350 @pxref{Reducing and Mapping}. For example, @kbd{a M S} changes
22351 @samp{x = y+1} to @samp{sin(x) = sin(y+1)}, and @kbd{a M +} with
22352 @samp{x = y+1} and @expr{6} on the stack produces @samp{x+6 = y+7}.
22353 With two equations on the stack, @kbd{a M +} would add the lefthand
22354 sides together and the righthand sides together to get the two
22355 respective sides of a new equation.
22357 Mapping also works on inequalities. Mapping two similar inequalities
22358 produces another inequality of the same type. Mapping an inequality
22359 with an equation produces an inequality of the same type. Mapping a
22360 @samp{<=} with a @samp{<} or @samp{!=} (not-equal) produces a @samp{<}.
22361 If inequalities with opposite direction (e.g., @samp{<} and @samp{>})
22362 are mapped, the direction of the second inequality is reversed to
22363 match the first: Using @kbd{a M +} on @samp{a < b} and @samp{a > 2}
22364 reverses the latter to get @samp{2 < a}, which then allows the
22365 combination @samp{a + 2 < b + a}, which the algebraic simplifications
22366 can reduce to @samp{2 < b}.
22368 Using @kbd{a M *}, @kbd{a M /}, @kbd{a M n}, or @kbd{a M &} to negate
22369 or invert an inequality will reverse the direction of the inequality.
22370 Other adjustments to inequalities are @emph{not} done automatically;
22371 @kbd{a M S} will change @w{@samp{x < y}} to @samp{sin(x) < sin(y)} even
22372 though this is not true for all values of the variables.
22376 With the Hyperbolic flag, @kbd{H a M} [@code{mapeqp}] does a plain
22377 mapping operation without reversing the direction of any inequalities.
22378 Thus, @kbd{H a M &} would change @kbd{x > 2} to @kbd{1/x > 0.5}.
22379 (This change is mathematically incorrect, but perhaps you were
22380 fixing an inequality which was already incorrect.)
22384 With the Inverse flag, @kbd{I a M} [@code{mapeqr}] always reverses
22385 the direction of the inequality. You might use @kbd{I a M C} to
22386 change @samp{x < y} to @samp{cos(x) > cos(y)} if you know you are
22387 working with small positive angles.
22390 @pindex calc-substitute
22392 The @kbd{a b} (@code{calc-substitute}) [@code{subst}] command substitutes
22394 of some variable or sub-expression of an expression with a new
22395 sub-expression. For example, substituting @samp{sin(x)} with @samp{cos(y)}
22396 in @samp{2 sin(x)^2 + x sin(x) + sin(2 x)} produces
22397 @samp{2 cos(y)^2 + x cos(y) + @w{sin(2 x)}}.
22398 Note that this is a purely structural substitution; the lone @samp{x} and
22399 the @samp{sin(2 x)} stayed the same because they did not look like
22400 @samp{sin(x)}. @xref{Rewrite Rules}, for a more general method for
22401 doing substitutions.
22403 The @kbd{a b} command normally prompts for two formulas, the old
22404 one and the new one. If you enter a blank line for the first
22405 prompt, all three arguments are taken from the stack (new, then old,
22406 then target expression). If you type an old formula but then enter a
22407 blank line for the new one, the new formula is taken from top-of-stack
22408 and the target from second-to-top. If you answer both prompts, the
22409 target is taken from top-of-stack as usual.
22411 Note that @kbd{a b} has no understanding of commutativity or
22412 associativity. The pattern @samp{x+y} will not match the formula
22413 @samp{y+x}. Also, @samp{y+z} will not match inside the formula @samp{x+y+z}
22414 because the @samp{+} operator is left-associative, so the ``deep
22415 structure'' of that formula is @samp{(x+y) + z}. Use @kbd{d U}
22416 (@code{calc-unformatted-language}) mode to see the true structure of
22417 a formula. The rewrite rule mechanism, discussed later, does not have
22420 As an algebraic function, @code{subst} takes three arguments:
22421 Target expression, old, new. Note that @code{subst} is always
22422 evaluated immediately, even if its arguments are variables, so if
22423 you wish to put a call to @code{subst} onto the stack you must
22424 turn the default simplifications off first (with @kbd{m O}).
22426 @node Simplifying Formulas, Polynomials, Algebraic Manipulation, Algebra
22427 @section Simplifying Formulas
22433 @pindex calc-simplify
22436 The sections below describe all the various kinds of
22437 simplifications Calc provides in full detail. None of Calc's
22438 simplification commands are designed to pull rabbits out of hats;
22439 they simply apply certain specific rules to put formulas into
22440 less redundant or more pleasing forms. Serious algebra in Calc
22441 must be done manually, usually with a combination of selections
22442 and rewrite rules. @xref{Rearranging with Selections}.
22443 @xref{Rewrite Rules}.
22445 @xref{Simplification Modes}, for commands to control what level of
22446 simplification occurs automatically. Normally the algebraic
22447 simplifications described below occur. If you have turned on a
22448 simplification mode which does not do these algebraic simplifications,
22449 you can still apply them to a formula with the @kbd{a s}
22450 (@code{calc-simplify}) [@code{simplify}] command.
22452 There are some simplifications that, while sometimes useful, are never
22453 done automatically. For example, the @kbd{I} prefix can be given to
22454 @kbd{a s}; the @kbd{I a s} command will change any trigonometric
22455 function to the appropriate combination of @samp{sin}s and @samp{cos}s
22456 before simplifying. This can be useful in simplifying even mildly
22457 complicated trigonometric expressions. For example, while the algebraic
22458 simplifications can reduce @samp{sin(x) csc(x)} to @samp{1}, they will not
22459 simplify @samp{sin(x)^2 csc(x)}. The command @kbd{I a s} can be used to
22460 simplify this latter expression; it will transform @samp{sin(x)^2
22461 csc(x)} into @samp{sin(x)}. However, @kbd{I a s} will also perform
22462 some ``simplifications'' which may not be desired; for example, it
22463 will transform @samp{tan(x)^2} into @samp{sin(x)^2 / cos(x)^2}. The
22464 Hyperbolic prefix @kbd{H} can be used similarly; the @kbd{H a s} will
22465 replace any hyperbolic functions in the formula with the appropriate
22466 combinations of @samp{sinh}s and @samp{cosh}s before simplifying.
22470 * Basic Simplifications::
22471 * Algebraic Simplifications::
22472 * Unsafe Simplifications::
22473 * Simplification of Units::
22476 @node Basic Simplifications, Algebraic Simplifications, Simplifying Formulas, Simplifying Formulas
22477 @subsection Basic Simplifications
22480 @cindex Basic simplifications
22481 This section describes basic simplifications which Calc performs in many
22482 situations. For example, both binary simplifications and algebraic
22483 simplifications begin by performing these basic simplifications. You
22484 can type @kbd{m I} to restrict the simplifications done on the stack to
22485 these simplifications.
22487 The most basic simplification is the evaluation of functions.
22488 For example, @expr{2 + 3} is evaluated to @expr{5}, and @expr{@tfn{sqrt}(9)}
22489 is evaluated to @expr{3}. Evaluation does not occur if the arguments
22490 to a function are somehow of the wrong type @expr{@tfn{tan}([2,3,4])}),
22491 range (@expr{@tfn{tan}(90)}), or number (@expr{@tfn{tan}(3,5)}),
22492 or if the function name is not recognized (@expr{@tfn{f}(5)}), or if
22493 Symbolic mode (@pxref{Symbolic Mode}) prevents evaluation
22494 (@expr{@tfn{sqrt}(2)}).
22496 Calc simplifies (evaluates) the arguments to a function before it
22497 simplifies the function itself. Thus @expr{@tfn{sqrt}(5+4)} is
22498 simplified to @expr{@tfn{sqrt}(9)} before the @code{sqrt} function
22499 itself is applied. There are very few exceptions to this rule:
22500 @code{quote}, @code{lambda}, and @code{condition} (the @code{::}
22501 operator) do not evaluate their arguments, @code{if} (the @code{? :}
22502 operator) does not evaluate all of its arguments, and @code{evalto}
22503 does not evaluate its lefthand argument.
22505 Most commands apply at least these basic simplifications to all
22506 arguments they take from the stack, perform a particular operation,
22507 then simplify the result before pushing it back on the stack. In the
22508 common special case of regular arithmetic commands like @kbd{+} and
22509 @kbd{Q} [@code{sqrt}], the arguments are simply popped from the stack
22510 and collected into a suitable function call, which is then simplified
22511 (the arguments being simplified first as part of the process, as
22514 Even the basic set of simplifications are too numerous to describe
22515 completely here, but this section will describe the ones that apply to the
22516 major arithmetic operators. This list will be rather technical in
22517 nature, and will probably be interesting to you only if you are
22518 a serious user of Calc's algebra facilities.
22524 As well as the simplifications described here, if you have stored
22525 any rewrite rules in the variable @code{EvalRules} then these rules
22526 will also be applied before any of the basic simplifications.
22527 @xref{Automatic Rewrites}, for details.
22533 And now, on with the basic simplifications:
22535 Arithmetic operators like @kbd{+} and @kbd{*} always take two
22536 arguments in Calc's internal form. Sums and products of three or
22537 more terms are arranged by the associative law of algebra into
22538 a left-associative form for sums, @expr{((a + b) + c) + d}, and
22539 (by default) a right-associative form for products,
22540 @expr{a * (b * (c * d))}. Formulas like @expr{(a + b) + (c + d)} are
22541 rearranged to left-associative form, though this rarely matters since
22542 Calc's algebra commands are designed to hide the inner structure of sums
22543 and products as much as possible. Sums and products in their proper
22544 associative form will be written without parentheses in the examples
22547 Sums and products are @emph{not} rearranged according to the
22548 commutative law (@expr{a + b} to @expr{b + a}) except in a few
22549 special cases described below. Some algebra programs always
22550 rearrange terms into a canonical order, which enables them to
22551 see that @expr{a b + b a} can be simplified to @expr{2 a b}.
22552 If you are using Basic Simplification mode, Calc assumes you have put
22553 the terms into the order you want and generally leaves that order alone,
22554 with the consequence that formulas like the above will only be
22555 simplified if you explicitly give the @kbd{a s} command.
22556 @xref{Algebraic Simplifications}.
22558 Differences @expr{a - b} are treated like sums @expr{a + (-b)}
22559 for purposes of simplification; one of the default simplifications
22560 is to rewrite @expr{a + (-b)} or @expr{(-b) + a}, where @expr{-b}
22561 represents a ``negative-looking'' term, into @expr{a - b} form.
22562 ``Negative-looking'' means negative numbers, negated formulas like
22563 @expr{-x}, and products or quotients in which either term is
22566 Other simplifications involving negation are @expr{-(-x)} to @expr{x};
22567 @expr{-(a b)} or @expr{-(a/b)} where either @expr{a} or @expr{b} is
22568 negative-looking, simplified by negating that term, or else where
22569 @expr{a} or @expr{b} is any number, by negating that number;
22570 @expr{-(a + b)} to @expr{-a - b}, and @expr{-(b - a)} to @expr{a - b}.
22571 (This, and rewriting @expr{(-b) + a} to @expr{a - b}, are the only
22572 cases where the order of terms in a sum is changed by the default
22575 The distributive law is used to simplify sums in some cases:
22576 @expr{a x + b x} to @expr{(a + b) x}, where @expr{a} represents
22577 a number or an implicit 1 or @mathit{-1} (as in @expr{x} or @expr{-x})
22578 and similarly for @expr{b}. Use the @kbd{a c}, @w{@kbd{a f}}, or
22579 @kbd{j M} commands to merge sums with non-numeric coefficients
22580 using the distributive law.
22582 The distributive law is only used for sums of two terms, or
22583 for adjacent terms in a larger sum. Thus @expr{a + b + b + c}
22584 is simplified to @expr{a + 2 b + c}, but @expr{a + b + c + b}
22585 is not simplified. The reason is that comparing all terms of a
22586 sum with one another would require time proportional to the
22587 square of the number of terms; Calc omits potentially slow
22588 operations like this in basic simplification mode.
22590 Finally, @expr{a + 0} and @expr{0 + a} are simplified to @expr{a}.
22591 A consequence of the above rules is that @expr{0 - a} is simplified
22598 The products @expr{1 a} and @expr{a 1} are simplified to @expr{a};
22599 @expr{(-1) a} and @expr{a (-1)} are simplified to @expr{-a};
22600 @expr{0 a} and @expr{a 0} are simplified to @expr{0}, except that
22601 in Matrix mode where @expr{a} is not provably scalar the result
22602 is the generic zero matrix @samp{idn(0)}, and that if @expr{a} is
22603 infinite the result is @samp{nan}.
22605 Also, @expr{(-a) b} and @expr{a (-b)} are simplified to @expr{-(a b)},
22606 where this occurs for negated formulas but not for regular negative
22609 Products are commuted only to move numbers to the front:
22610 @expr{a b 2} is commuted to @expr{2 a b}.
22612 The product @expr{a (b + c)} is distributed over the sum only if
22613 @expr{a} and at least one of @expr{b} and @expr{c} are numbers:
22614 @expr{2 (x + 3)} goes to @expr{2 x + 6}. The formula
22615 @expr{(-a) (b - c)}, where @expr{-a} is a negative number, is
22616 rewritten to @expr{a (c - b)}.
22618 The distributive law of products and powers is used for adjacent
22619 terms of the product: @expr{x^a x^b} goes to
22620 @texline @math{x^{a+b}}
22621 @infoline @expr{x^(a+b)}
22622 where @expr{a} is a number, or an implicit 1 (as in @expr{x}),
22623 or the implicit one-half of @expr{@tfn{sqrt}(x)}, and similarly for
22624 @expr{b}. The result is written using @samp{sqrt} or @samp{1/sqrt}
22625 if the sum of the powers is @expr{1/2} or @expr{-1/2}, respectively.
22626 If the sum of the powers is zero, the product is simplified to
22627 @expr{1} or to @samp{idn(1)} if Matrix mode is enabled.
22629 The product of a negative power times anything but another negative
22630 power is changed to use division:
22631 @texline @math{x^{-2} y}
22632 @infoline @expr{x^(-2) y}
22633 goes to @expr{y / x^2} unless Matrix mode is
22634 in effect and neither @expr{x} nor @expr{y} are scalar (in which
22635 case it is considered unsafe to rearrange the order of the terms).
22637 Finally, @expr{a (b/c)} is rewritten to @expr{(a b)/c}, and also
22638 @expr{(a/b) c} is changed to @expr{(a c)/b} unless in Matrix mode.
22644 Simplifications for quotients are analogous to those for products.
22645 The quotient @expr{0 / x} is simplified to @expr{0}, with the same
22646 exceptions that were noted for @expr{0 x}. Likewise, @expr{x / 1}
22647 and @expr{x / (-1)} are simplified to @expr{x} and @expr{-x},
22650 The quotient @expr{x / 0} is left unsimplified or changed to an
22651 infinite quantity, as directed by the current infinite mode.
22652 @xref{Infinite Mode}.
22655 @texline @math{a / b^{-c}}
22656 @infoline @expr{a / b^(-c)}
22657 is changed to @expr{a b^c}, where @expr{-c} is any negative-looking
22658 power. Also, @expr{1 / b^c} is changed to
22659 @texline @math{b^{-c}}
22660 @infoline @expr{b^(-c)}
22661 for any power @expr{c}.
22663 Also, @expr{(-a) / b} and @expr{a / (-b)} go to @expr{-(a/b)};
22664 @expr{(a/b) / c} goes to @expr{a / (b c)}; and @expr{a / (b/c)}
22665 goes to @expr{(a c) / b} unless Matrix mode prevents this
22666 rearrangement. Similarly, @expr{a / (b:c)} is simplified to
22667 @expr{(c:b) a} for any fraction @expr{b:c}.
22669 The distributive law is applied to @expr{(a + b) / c} only if
22670 @expr{c} and at least one of @expr{a} and @expr{b} are numbers.
22671 Quotients of powers and square roots are distributed just as
22672 described for multiplication.
22674 Quotients of products cancel only in the leading terms of the
22675 numerator and denominator. In other words, @expr{a x b / a y b}
22676 is canceled to @expr{x b / y b} but not to @expr{x / y}. Once
22677 again this is because full cancellation can be slow; use @kbd{a s}
22678 to cancel all terms of the quotient.
22680 Quotients of negative-looking values are simplified according
22681 to @expr{(-a) / (-b)} to @expr{a / b}, @expr{(-a) / (b - c)}
22682 to @expr{a / (c - b)}, and @expr{(a - b) / (-c)} to @expr{(b - a) / c}.
22688 The formula @expr{x^0} is simplified to @expr{1}, or to @samp{idn(1)}
22689 in Matrix mode. The formula @expr{0^x} is simplified to @expr{0}
22690 unless @expr{x} is a negative number, complex number or zero.
22691 If @expr{x} is negative, complex or @expr{0.0}, @expr{0^x} is an
22692 infinity or an unsimplified formula according to the current infinite
22693 mode. The expression @expr{0^0} is simplified to @expr{1}.
22695 Powers of products or quotients @expr{(a b)^c}, @expr{(a/b)^c}
22696 are distributed to @expr{a^c b^c}, @expr{a^c / b^c} only if @expr{c}
22697 is an integer, or if either @expr{a} or @expr{b} are nonnegative
22698 real numbers. Powers of powers @expr{(a^b)^c} are simplified to
22699 @texline @math{a^{b c}}
22700 @infoline @expr{a^(b c)}
22701 only when @expr{c} is an integer and @expr{b c} also
22702 evaluates to an integer. Without these restrictions these simplifications
22703 would not be safe because of problems with principal values.
22705 @texline @math{((-3)^{1/2})^2}
22706 @infoline @expr{((-3)^1:2)^2}
22707 is safe to simplify, but
22708 @texline @math{((-3)^2)^{1/2}}
22709 @infoline @expr{((-3)^2)^1:2}
22710 is not.) @xref{Declarations}, for ways to inform Calc that your
22711 variables satisfy these requirements.
22713 As a special case of this rule, @expr{@tfn{sqrt}(x)^n} is simplified to
22714 @texline @math{x^{n/2}}
22715 @infoline @expr{x^(n/2)}
22716 only for even integers @expr{n}.
22718 If @expr{a} is known to be real, @expr{b} is an even integer, and
22719 @expr{c} is a half- or quarter-integer, then @expr{(a^b)^c} is
22720 simplified to @expr{@tfn{abs}(a^(b c))}.
22722 Also, @expr{(-a)^b} is simplified to @expr{a^b} if @expr{b} is an
22723 even integer, or to @expr{-(a^b)} if @expr{b} is an odd integer,
22724 for any negative-looking expression @expr{-a}.
22726 Square roots @expr{@tfn{sqrt}(x)} generally act like one-half powers
22727 @texline @math{x^{1:2}}
22728 @infoline @expr{x^1:2}
22729 for the purposes of the above-listed simplifications.
22732 @texline @math{1 / x^{1:2}}
22733 @infoline @expr{1 / x^1:2}
22735 @texline @math{x^{-1:2}},
22736 @infoline @expr{x^(-1:2)},
22737 but @expr{1 / @tfn{sqrt}(x)} is left alone.
22743 Generic identity matrices (@pxref{Matrix Mode}) are simplified by the
22744 following rules: @expr{@tfn{idn}(a) + b} to @expr{a + b} if @expr{b}
22745 is provably scalar, or expanded out if @expr{b} is a matrix;
22746 @expr{@tfn{idn}(a) + @tfn{idn}(b)} to @expr{@tfn{idn}(a + b)};
22747 @expr{-@tfn{idn}(a)} to @expr{@tfn{idn}(-a)}; @expr{a @tfn{idn}(b)} to
22748 @expr{@tfn{idn}(a b)} if @expr{a} is provably scalar, or to @expr{a b}
22749 if @expr{a} is provably non-scalar; @expr{@tfn{idn}(a) @tfn{idn}(b)} to
22750 @expr{@tfn{idn}(a b)}; analogous simplifications for quotients involving
22751 @code{idn}; and @expr{@tfn{idn}(a)^n} to @expr{@tfn{idn}(a^n)} where
22752 @expr{n} is an integer.
22758 The @code{floor} function and other integer truncation functions
22759 vanish if the argument is provably integer-valued, so that
22760 @expr{@tfn{floor}(@tfn{round}(x))} simplifies to @expr{@tfn{round}(x)}.
22761 Also, combinations of @code{float}, @code{floor} and its friends,
22762 and @code{ffloor} and its friends, are simplified in appropriate
22763 ways. @xref{Integer Truncation}.
22765 The expression @expr{@tfn{abs}(-x)} changes to @expr{@tfn{abs}(x)}.
22766 The expression @expr{@tfn{abs}(@tfn{abs}(x))} changes to
22767 @expr{@tfn{abs}(x)}; in fact, @expr{@tfn{abs}(x)} changes to @expr{x} or
22768 @expr{-x} if @expr{x} is provably nonnegative or nonpositive
22769 (@pxref{Declarations}).
22771 While most functions do not recognize the variable @code{i} as an
22772 imaginary number, the @code{arg} function does handle the two cases
22773 @expr{@tfn{arg}(@tfn{i})} and @expr{@tfn{arg}(-@tfn{i})} just for convenience.
22775 The expression @expr{@tfn{conj}(@tfn{conj}(x))} simplifies to @expr{x}.
22776 Various other expressions involving @code{conj}, @code{re}, and
22777 @code{im} are simplified, especially if some of the arguments are
22778 provably real or involve the constant @code{i}. For example,
22779 @expr{@tfn{conj}(a + b i)} is changed to
22780 @expr{@tfn{conj}(a) - @tfn{conj}(b) i}, or to @expr{a - b i} if @expr{a}
22781 and @expr{b} are known to be real.
22783 Functions like @code{sin} and @code{arctan} generally don't have
22784 any default simplifications beyond simply evaluating the functions
22785 for suitable numeric arguments and infinity. The algebraic
22786 simplifications described in the next section do provide some
22787 simplifications for these functions, though.
22789 One important simplification that does occur is that
22790 @expr{@tfn{ln}(@tfn{e})} is simplified to 1, and @expr{@tfn{ln}(@tfn{e}^x)} is
22791 simplified to @expr{x} for any @expr{x}. This occurs even if you have
22792 stored a different value in the Calc variable @samp{e}; but this would
22793 be a bad idea in any case if you were also using natural logarithms!
22795 Among the logical functions, @tfn{!(@var{a} <= @var{b})} changes to
22796 @tfn{@var{a} > @var{b}} and so on. Equations and inequalities where both sides
22797 are either negative-looking or zero are simplified by negating both sides
22798 and reversing the inequality. While it might seem reasonable to simplify
22799 @expr{!!x} to @expr{x}, this would not be valid in general because
22800 @expr{!!2} is 1, not 2.
22802 Most other Calc functions have few if any basic simplifications
22803 defined, aside of course from evaluation when the arguments are
22806 @node Algebraic Simplifications, Unsafe Simplifications, Basic Simplifications, Simplifying Formulas
22807 @subsection Algebraic Simplifications
22810 @cindex Algebraic simplifications
22813 This section describes all simplifications that are performed by
22814 the algebraic simplification mode, which is the default simplification
22815 mode. If you have switched to a different simplification mode, you can
22816 switch back with the @kbd{m A} command. Even in other simplification
22817 modes, the @kbd{a s} command will use these algebraic simplifications to
22818 simplify the formula.
22820 There is a variable, @code{AlgSimpRules}, in which you can put rewrites
22821 to be applied. Its use is analogous to @code{EvalRules},
22822 but without the special restrictions. Basically, the simplifier does
22823 @samp{@w{a r} AlgSimpRules} with an infinite repeat count on the whole
22824 expression being simplified, then it traverses the expression applying
22825 the built-in rules described below. If the result is different from
22826 the original expression, the process repeats with the basic
22827 simplifications (including @code{EvalRules}), then @code{AlgSimpRules},
22828 then the built-in simplifications, and so on.
22834 Sums are simplified in two ways. Constant terms are commuted to the
22835 end of the sum, so that @expr{a + 2 + b} changes to @expr{a + b + 2}.
22836 The only exception is that a constant will not be commuted away
22837 from the first position of a difference, i.e., @expr{2 - x} is not
22838 commuted to @expr{-x + 2}.
22840 Also, terms of sums are combined by the distributive law, as in
22841 @expr{x + y + 2 x} to @expr{y + 3 x}. This always occurs for
22842 adjacent terms, but Calc's algebraic simplifications compare all pairs
22843 of terms including non-adjacent ones.
22849 Products are sorted into a canonical order using the commutative
22850 law. For example, @expr{b c a} is commuted to @expr{a b c}.
22851 This allows easier comparison of products; for example, the basic
22852 simplifications will not change @expr{x y + y x} to @expr{2 x y},
22853 but the algebraic simplifications; it first rewrites the sum to
22854 @expr{x y + x y} which can then be recognized as a sum of identical
22857 The canonical ordering used to sort terms of products has the
22858 property that real-valued numbers, interval forms and infinities
22859 come first, and are sorted into increasing order. The @kbd{V S}
22860 command uses the same ordering when sorting a vector.
22862 Sorting of terms of products is inhibited when Matrix mode is
22863 turned on; in this case, Calc will never exchange the order of
22864 two terms unless it knows at least one of the terms is a scalar.
22866 Products of powers are distributed by comparing all pairs of
22867 terms, using the same method that the default simplifications
22868 use for adjacent terms of products.
22870 Even though sums are not sorted, the commutative law is still
22871 taken into account when terms of a product are being compared.
22872 Thus @expr{(x + y) (y + x)} will be simplified to @expr{(x + y)^2}.
22873 A subtle point is that @expr{(x - y) (y - x)} will @emph{not}
22874 be simplified to @expr{-(x - y)^2}; Calc does not notice that
22875 one term can be written as a constant times the other, even if
22876 that constant is @mathit{-1}.
22878 A fraction times any expression, @expr{(a:b) x}, is changed to
22879 a quotient involving integers: @expr{a x / b}. This is not
22880 done for floating-point numbers like @expr{0.5}, however. This
22881 is one reason why you may find it convenient to turn Fraction mode
22882 on while doing algebra; @pxref{Fraction Mode}.
22888 Quotients are simplified by comparing all terms in the numerator
22889 with all terms in the denominator for possible cancellation using
22890 the distributive law. For example, @expr{a x^2 b / c x^3 d} will
22891 cancel @expr{x^2} from the top and bottom to get @expr{a b / c x d}.
22892 (The terms in the denominator will then be rearranged to @expr{c d x}
22893 as described above.) If there is any common integer or fractional
22894 factor in the numerator and denominator, it is canceled out;
22895 for example, @expr{(4 x + 6) / 8 x} simplifies to @expr{(2 x + 3) / 4 x}.
22897 Non-constant common factors are not found even by algebraic
22898 simplifications. To cancel the factor @expr{a} in
22899 @expr{(a x + a) / a^2} you could first use @kbd{j M} on the product
22900 @expr{a x} to Merge the numerator to @expr{a (1+x)}, which can then be
22901 simplified successfully.
22907 Integer powers of the variable @code{i} are simplified according
22908 to the identity @expr{i^2 = -1}. If you store a new value other
22909 than the complex number @expr{(0,1)} in @code{i}, this simplification
22910 will no longer occur. This is not done by the basic
22911 simplifications; in case someone (unwisely) wants to use the name
22912 @code{i} for a variable unrelated to complex numbers, they can use
22913 basic simplification mode.
22915 Square roots of integer or rational arguments are simplified in
22916 several ways. (Note that these will be left unevaluated only in
22917 Symbolic mode.) First, square integer or rational factors are
22918 pulled out so that @expr{@tfn{sqrt}(8)} is rewritten as
22919 @texline @math{2\,@tfn{sqrt}(2)}.
22920 @infoline @expr{2 sqrt(2)}.
22921 Conceptually speaking this implies factoring the argument into primes
22922 and moving pairs of primes out of the square root, but for reasons of
22923 efficiency Calc only looks for primes up to 29.
22925 Square roots in the denominator of a quotient are moved to the
22926 numerator: @expr{1 / @tfn{sqrt}(3)} changes to @expr{@tfn{sqrt}(3) / 3}.
22927 The same effect occurs for the square root of a fraction:
22928 @expr{@tfn{sqrt}(2:3)} changes to @expr{@tfn{sqrt}(6) / 3}.
22934 The @code{%} (modulo) operator is simplified in several ways
22935 when the modulus @expr{M} is a positive real number. First, if
22936 the argument is of the form @expr{x + n} for some real number
22937 @expr{n}, then @expr{n} is itself reduced modulo @expr{M}. For
22938 example, @samp{(x - 23) % 10} is simplified to @samp{(x + 7) % 10}.
22940 If the argument is multiplied by a constant, and this constant
22941 has a common integer divisor with the modulus, then this factor is
22942 canceled out. For example, @samp{12 x % 15} is changed to
22943 @samp{3 (4 x % 5)} by factoring out 3. Also, @samp{(12 x + 1) % 15}
22944 is changed to @samp{3 ((4 x + 1:3) % 5)}. While these forms may
22945 not seem ``simpler,'' they allow Calc to discover useful information
22946 about modulo forms in the presence of declarations.
22948 If the modulus is 1, then Calc can use @code{int} declarations to
22949 evaluate the expression. For example, the idiom @samp{x % 2} is
22950 often used to check whether a number is odd or even. As described
22951 above, @w{@samp{2 n % 2}} and @samp{(2 n + 1) % 2} are simplified to
22952 @samp{2 (n % 1)} and @samp{2 ((n + 1:2) % 1)}, respectively; Calc
22953 can simplify these to 0 and 1 (respectively) if @code{n} has been
22954 declared to be an integer.
22960 Trigonometric functions are simplified in several ways. Whenever a
22961 products of two trigonometric functions can be replaced by a single
22962 function, the replacement is made; for example,
22963 @expr{@tfn{tan}(x) @tfn{cos}(x)} is simplified to @expr{@tfn{sin}(x)}.
22964 Reciprocals of trigonometric functions are replaced by their reciprocal
22965 function; for example, @expr{1/@tfn{sec}(x)} is simplified to
22966 @expr{@tfn{cos}(x)}. The corresponding simplifications for the
22967 hyperbolic functions are also handled.
22969 Trigonometric functions of their inverse functions are
22970 simplified. The expression @expr{@tfn{sin}(@tfn{arcsin}(x))} is
22971 simplified to @expr{x}, and similarly for @code{cos} and @code{tan}.
22972 Trigonometric functions of inverses of different trigonometric
22973 functions can also be simplified, as in @expr{@tfn{sin}(@tfn{arccos}(x))}
22974 to @expr{@tfn{sqrt}(1 - x^2)}.
22976 If the argument to @code{sin} is negative-looking, it is simplified to
22977 @expr{-@tfn{sin}(x)}, and similarly for @code{cos} and @code{tan}.
22978 Finally, certain special values of the argument are recognized;
22979 @pxref{Trigonometric and Hyperbolic Functions}.
22981 Hyperbolic functions of their inverses and of negative-looking
22982 arguments are also handled, as are exponentials of inverse
22983 hyperbolic functions.
22985 No simplifications for inverse trigonometric and hyperbolic
22986 functions are known, except for negative arguments of @code{arcsin},
22987 @code{arctan}, @code{arcsinh}, and @code{arctanh}. Note that
22988 @expr{@tfn{arcsin}(@tfn{sin}(x))} can @emph{not} safely change to
22989 @expr{x}, since this only correct within an integer multiple of
22990 @texline @math{2 \pi}
22991 @infoline @expr{2 pi}
22992 radians or 360 degrees. However, @expr{@tfn{arcsinh}(@tfn{sinh}(x))} is
22993 simplified to @expr{x} if @expr{x} is known to be real.
22995 Several simplifications that apply to logarithms and exponentials
22996 are that @expr{@tfn{exp}(@tfn{ln}(x))},
22997 @texline @tfn{e}@math{^{\ln(x)}},
22998 @infoline @expr{e^@tfn{ln}(x)},
23000 @texline @math{10^{{\rm log10}(x)}}
23001 @infoline @expr{10^@tfn{log10}(x)}
23002 all reduce to @expr{x}. Also, @expr{@tfn{ln}(@tfn{exp}(x))}, etc., can
23003 reduce to @expr{x} if @expr{x} is provably real. The form
23004 @expr{@tfn{exp}(x)^y} is simplified to @expr{@tfn{exp}(x y)}. If @expr{x}
23005 is a suitable multiple of
23006 @texline @math{\pi i}
23007 @infoline @expr{pi i}
23008 (as described above for the trigonometric functions), then
23009 @expr{@tfn{exp}(x)} or @expr{e^x} will be expanded. Finally,
23010 @expr{@tfn{ln}(x)} is simplified to a form involving @code{pi} and
23011 @code{i} where @expr{x} is provably negative, positive imaginary, or
23012 negative imaginary.
23014 The error functions @code{erf} and @code{erfc} are simplified when
23015 their arguments are negative-looking or are calls to the @code{conj}
23022 Equations and inequalities are simplified by canceling factors
23023 of products, quotients, or sums on both sides. Inequalities
23024 change sign if a negative multiplicative factor is canceled.
23025 Non-constant multiplicative factors as in @expr{a b = a c} are
23026 canceled from equations only if they are provably nonzero (generally
23027 because they were declared so; @pxref{Declarations}). Factors
23028 are canceled from inequalities only if they are nonzero and their
23031 Simplification also replaces an equation or inequality with
23032 1 or 0 (``true'' or ``false'') if it can through the use of
23033 declarations. If @expr{x} is declared to be an integer greater
23034 than 5, then @expr{x < 3}, @expr{x = 3}, and @expr{x = 7.5} are
23035 all simplified to 0, but @expr{x > 3} is simplified to 1.
23036 By a similar analysis, @expr{abs(x) >= 0} is simplified to 1,
23037 as is @expr{x^2 >= 0} if @expr{x} is known to be real.
23039 @node Unsafe Simplifications, Simplification of Units, Algebraic Simplifications, Simplifying Formulas
23040 @subsection ``Unsafe'' Simplifications
23043 @cindex Unsafe simplifications
23044 @cindex Extended simplification
23047 @pindex calc-simplify-extended
23049 @mindex esimpl@idots
23052 Calc is capable of performing some simplifications which may sometimes
23053 be desired but which are not ``safe'' in all cases. The @kbd{a e}
23054 (@code{calc-simplify-extended}) [@code{esimplify}] command
23055 applies the algebraic simplifications as well as these extended, or
23056 ``unsafe'', simplifications. Use this only if you know the values in
23057 your formula lie in the restricted ranges for which these
23058 simplifications are valid. You can use Extended Simplification mode
23059 (@kbd{m E}) to have these simplifications done automatically.
23061 The symbolic integrator uses these extended simplifications; one effect
23062 of this is that the integrator's results must be used with caution.
23063 Where an integral table will often attach conditions like ``for positive
23064 @expr{a} only,'' Calc (like most other symbolic integration programs)
23065 will simply produce an unqualified result.
23067 Because @kbd{a e}'s simplifications are unsafe, it is sometimes better
23068 to type @kbd{C-u -3 a v}, which does extended simplification only
23069 on the top level of the formula without affecting the sub-formulas.
23070 In fact, @kbd{C-u -3 j v} allows you to target extended simplification
23071 to any specific part of a formula.
23073 The variable @code{ExtSimpRules} contains rewrites to be applied when
23074 the extended simplifications are used. These are applied in addition to
23075 @code{EvalRules} and @code{AlgSimpRules}. (The @kbd{a r AlgSimpRules}
23076 step described above is simply followed by an @kbd{a r ExtSimpRules} step.)
23078 Following is a complete list of the ``unsafe'' simplifications.
23084 Inverse trigonometric or hyperbolic functions, called with their
23085 corresponding non-inverse functions as arguments, are simplified.
23086 For example, @expr{@tfn{arcsin}(@tfn{sin}(x))} changes
23087 to @expr{x}. Also, @expr{@tfn{arcsin}(@tfn{cos}(x))} and
23088 @expr{@tfn{arccos}(@tfn{sin}(x))} both change to @expr{@tfn{pi}/2 - x}.
23089 These simplifications are unsafe because they are valid only for
23090 values of @expr{x} in a certain range; outside that range, values
23091 are folded down to the 360-degree range that the inverse trigonometric
23092 functions always produce.
23094 Powers of powers @expr{(x^a)^b} are simplified to
23095 @texline @math{x^{a b}}
23096 @infoline @expr{x^(a b)}
23097 for all @expr{a} and @expr{b}. These results will be valid only
23098 in a restricted range of @expr{x}; for example, in
23099 @texline @math{(x^2)^{1:2}}
23100 @infoline @expr{(x^2)^1:2}
23101 the powers cancel to get @expr{x}, which is valid for positive values
23102 of @expr{x} but not for negative or complex values.
23104 Similarly, @expr{@tfn{sqrt}(x^a)} and @expr{@tfn{sqrt}(x)^a} are both
23105 simplified (possibly unsafely) to
23106 @texline @math{x^{a/2}}.
23107 @infoline @expr{x^(a/2)}.
23109 Forms like @expr{@tfn{sqrt}(1 - sin(x)^2)} are simplified to, e.g.,
23110 @expr{@tfn{cos}(x)}. Calc has identities of this sort for @code{sin},
23111 @code{cos}, @code{tan}, @code{sinh}, and @code{cosh}.
23113 Arguments of square roots are partially factored to look for
23114 squared terms that can be extracted. For example,
23115 @expr{@tfn{sqrt}(a^2 b^3 + a^3 b^2)} simplifies to
23116 @expr{a b @tfn{sqrt}(a+b)}.
23118 The simplifications of @expr{@tfn{ln}(@tfn{exp}(x))},
23119 @expr{@tfn{ln}(@tfn{e}^x)}, and @expr{@tfn{log10}(10^x)} to @expr{x} are also
23120 unsafe because of problems with principal values (although these
23121 simplifications are safe if @expr{x} is known to be real).
23123 Common factors are canceled from products on both sides of an
23124 equation, even if those factors may be zero: @expr{a x / b x}
23125 to @expr{a / b}. Such factors are never canceled from
23126 inequalities: Even the extended simplifications are not bold enough to
23127 reduce @expr{a x < b x} to @expr{a < b} (or @expr{a > b}, depending
23128 on whether you believe @expr{x} is positive or negative).
23129 The @kbd{a M /} command can be used to divide a factor out of
23130 both sides of an inequality.
23132 @node Simplification of Units, , Unsafe Simplifications, Simplifying Formulas
23133 @subsection Simplification of Units
23136 The simplifications described in this section (as well as the algebraic
23137 simplifications) are applied when units need to be simplified. They can
23138 be applied using the @kbd{u s} (@code{calc-simplify-units}) command, or
23139 will be done automatically in Units Simplification mode (@kbd{m U}).
23140 @xref{Basic Operations on Units}.
23142 The variable @code{UnitSimpRules} contains rewrites to be applied by
23143 units simplifications. These are applied in addition to @code{EvalRules}
23144 and @code{AlgSimpRules}.
23146 Scalar mode is automatically put into effect when simplifying units.
23147 @xref{Matrix Mode}.
23149 Sums @expr{a + b} involving units are simplified by extracting the
23150 units of @expr{a} as if by the @kbd{u x} command (call the result
23151 @expr{u_a}), then simplifying the expression @expr{b / u_a}
23152 using @kbd{u b} and @kbd{u s}. If the result has units then the sum
23153 is inconsistent and is left alone. Otherwise, it is rewritten
23154 in terms of the units @expr{u_a}.
23156 If units auto-ranging mode is enabled, products or quotients in
23157 which the first argument is a number which is out of range for the
23158 leading unit are modified accordingly.
23160 When canceling and combining units in products and quotients,
23161 Calc accounts for unit names that differ only in the prefix letter.
23162 For example, @samp{2 km m} is simplified to @samp{2000 m^2}.
23163 However, compatible but different units like @code{ft} and @code{in}
23164 are not combined in this way.
23166 Quotients @expr{a / b} are simplified in three additional ways. First,
23167 if @expr{b} is a number or a product beginning with a number, Calc
23168 computes the reciprocal of this number and moves it to the numerator.
23170 Second, for each pair of unit names from the numerator and denominator
23171 of a quotient, if the units are compatible (e.g., they are both
23172 units of area) then they are replaced by the ratio between those
23173 units. For example, in @samp{3 s in N / kg cm} the units
23174 @samp{in / cm} will be replaced by @expr{2.54}.
23176 Third, if the units in the quotient exactly cancel out, so that
23177 a @kbd{u b} command on the quotient would produce a dimensionless
23178 number for an answer, then the quotient simplifies to that number.
23180 For powers and square roots, the ``unsafe'' simplifications
23181 @expr{(a b)^c} to @expr{a^c b^c}, @expr{(a/b)^c} to @expr{a^c / b^c},
23182 and @expr{(a^b)^c} to
23183 @texline @math{a^{b c}}
23184 @infoline @expr{a^(b c)}
23185 are done if the powers are real numbers. (These are safe in the context
23186 of units because all numbers involved can reasonably be assumed to be
23189 Also, if a unit name is raised to a fractional power, and the
23190 base units in that unit name all occur to powers which are a
23191 multiple of the denominator of the power, then the unit name
23192 is expanded out into its base units, which can then be simplified
23193 according to the previous paragraph. For example, @samp{acre^1.5}
23194 is simplified by noting that @expr{1.5 = 3:2}, that @samp{acre}
23195 is defined in terms of @samp{m^2}, and that the 2 in the power of
23196 @code{m} is a multiple of 2 in @expr{3:2}. Thus, @code{acre^1.5} is
23197 replaced by approximately
23198 @texline @math{(4046 m^2)^{1.5}}
23199 @infoline @expr{(4046 m^2)^1.5},
23200 which is then changed to
23201 @texline @math{4046^{1.5} \, (m^2)^{1.5}},
23202 @infoline @expr{4046^1.5 (m^2)^1.5},
23203 then to @expr{257440 m^3}.
23205 The functions @code{float}, @code{frac}, @code{clean}, @code{abs},
23206 as well as @code{floor} and the other integer truncation functions,
23207 applied to unit names or products or quotients involving units, are
23208 simplified. For example, @samp{round(1.6 in)} is changed to
23209 @samp{round(1.6) round(in)}; the lefthand term evaluates to 2,
23210 and the righthand term simplifies to @code{in}.
23212 The functions @code{sin}, @code{cos}, and @code{tan} with arguments
23213 that have angular units like @code{rad} or @code{arcmin} are
23214 simplified by converting to base units (radians), then evaluating
23215 with the angular mode temporarily set to radians.
23217 @node Polynomials, Calculus, Simplifying Formulas, Algebra
23218 @section Polynomials
23220 A @dfn{polynomial} is a sum of terms which are coefficients times
23221 various powers of a ``base'' variable. For example, @expr{2 x^2 + 3 x - 4}
23222 is a polynomial in @expr{x}. Some formulas can be considered
23223 polynomials in several different variables: @expr{1 + 2 x + 3 y + 4 x y^2}
23224 is a polynomial in both @expr{x} and @expr{y}. Polynomial coefficients
23225 are often numbers, but they may in general be any formulas not
23226 involving the base variable.
23229 @pindex calc-factor
23231 The @kbd{a f} (@code{calc-factor}) [@code{factor}] command factors a
23232 polynomial into a product of terms. For example, the polynomial
23233 @expr{x^3 + 2 x^2 + x} is factored into @samp{x*(x+1)^2}. As another
23234 example, @expr{a c + b d + b c + a d} is factored into the product
23235 @expr{(a + b) (c + d)}.
23237 Calc currently has three algorithms for factoring. Formulas which are
23238 linear in several variables, such as the second example above, are
23239 merged according to the distributive law. Formulas which are
23240 polynomials in a single variable, with constant integer or fractional
23241 coefficients, are factored into irreducible linear and/or quadratic
23242 terms. The first example above factors into three linear terms
23243 (@expr{x}, @expr{x+1}, and @expr{x+1} again). Finally, formulas
23244 which do not fit the above criteria are handled by the algebraic
23247 Calc's polynomial factorization algorithm works by using the general
23248 root-finding command (@w{@kbd{a P}}) to solve for the roots of the
23249 polynomial. It then looks for roots which are rational numbers
23250 or complex-conjugate pairs, and converts these into linear and
23251 quadratic terms, respectively. Because it uses floating-point
23252 arithmetic, it may be unable to find terms that involve large
23253 integers (whose number of digits approaches the current precision).
23254 Also, irreducible factors of degree higher than quadratic are not
23255 found, and polynomials in more than one variable are not treated.
23256 (A more robust factorization algorithm may be included in a future
23259 @vindex FactorRules
23271 The rewrite-based factorization method uses rules stored in the variable
23272 @code{FactorRules}. @xref{Rewrite Rules}, for a discussion of the
23273 operation of rewrite rules. The default @code{FactorRules} are able
23274 to factor quadratic forms symbolically into two linear terms,
23275 @expr{(a x + b) (c x + d)}. You can edit these rules to include other
23276 cases if you wish. To use the rules, Calc builds the formula
23277 @samp{thecoefs(x, [a, b, c, ...])} where @code{x} is the polynomial
23278 base variable and @code{a}, @code{b}, etc., are polynomial coefficients
23279 (which may be numbers or formulas). The constant term is written first,
23280 i.e., in the @code{a} position. When the rules complete, they should have
23281 changed the formula into the form @samp{thefactors(x, [f1, f2, f3, ...])}
23282 where each @code{fi} should be a factored term, e.g., @samp{x - ai}.
23283 Calc then multiplies these terms together to get the complete
23284 factored form of the polynomial. If the rules do not change the
23285 @code{thecoefs} call to a @code{thefactors} call, @kbd{a f} leaves the
23286 polynomial alone on the assumption that it is unfactorable. (Note that
23287 the function names @code{thecoefs} and @code{thefactors} are used only
23288 as placeholders; there are no actual Calc functions by those names.)
23292 The @kbd{H a f} [@code{factors}] command also factors a polynomial,
23293 but it returns a list of factors instead of an expression which is the
23294 product of the factors. Each factor is represented by a sub-vector
23295 of the factor, and the power with which it appears. For example,
23296 @expr{x^5 + x^4 - 33 x^3 + 63 x^2} factors to @expr{(x + 7) x^2 (x - 3)^2}
23297 in @kbd{a f}, or to @expr{[ [x, 2], [x+7, 1], [x-3, 2] ]} in @kbd{H a f}.
23298 If there is an overall numeric factor, it always comes first in the list.
23299 The functions @code{factor} and @code{factors} allow a second argument
23300 when written in algebraic form; @samp{factor(x,v)} factors @expr{x} with
23301 respect to the specific variable @expr{v}. The default is to factor with
23302 respect to all the variables that appear in @expr{x}.
23305 @pindex calc-collect
23307 The @kbd{a c} (@code{calc-collect}) [@code{collect}] command rearranges a
23309 polynomial in a given variable, ordered in decreasing powers of that
23310 variable. For example, given @expr{1 + 2 x + 3 y + 4 x y^2} on
23311 the stack, @kbd{a c x} would produce @expr{(2 + 4 y^2) x + (1 + 3 y)},
23312 and @kbd{a c y} would produce @expr{(4 x) y^2 + 3 y + (1 + 2 x)}.
23313 The polynomial will be expanded out using the distributive law as
23314 necessary: Collecting @expr{x} in @expr{(x - 1)^3} produces
23315 @expr{x^3 - 3 x^2 + 3 x - 1}. Terms not involving @expr{x} will
23318 The ``variable'' you specify at the prompt can actually be any
23319 expression: @kbd{a c ln(x+1)} will collect together all terms multiplied
23320 by @samp{ln(x+1)} or integer powers thereof. If @samp{x} also appears
23321 in the formula in a context other than @samp{ln(x+1)}, @kbd{a c} will
23322 treat those occurrences as unrelated to @samp{ln(x+1)}, i.e., as constants.
23325 @pindex calc-expand
23327 The @kbd{a x} (@code{calc-expand}) [@code{expand}] command expands an
23328 expression by applying the distributive law everywhere. It applies to
23329 products, quotients, and powers involving sums. By default, it fully
23330 distributes all parts of the expression. With a numeric prefix argument,
23331 the distributive law is applied only the specified number of times, then
23332 the partially expanded expression is left on the stack.
23334 The @kbd{a x} and @kbd{j D} commands are somewhat redundant. Use
23335 @kbd{a x} if you want to expand all products of sums in your formula.
23336 Use @kbd{j D} if you want to expand a particular specified term of
23337 the formula. There is an exactly analogous correspondence between
23338 @kbd{a f} and @kbd{j M}. (The @kbd{j D} and @kbd{j M} commands
23339 also know many other kinds of expansions, such as
23340 @samp{exp(a + b) = exp(a) exp(b)}, which @kbd{a x} and @kbd{a f}
23343 Calc's automatic simplifications will sometimes reverse a partial
23344 expansion. For example, the first step in expanding @expr{(x+1)^3} is
23345 to write @expr{(x+1) (x+1)^2}. If @kbd{a x} stops there and tries
23346 to put this formula onto the stack, though, Calc will automatically
23347 simplify it back to @expr{(x+1)^3} form. The solution is to turn
23348 simplification off first (@pxref{Simplification Modes}), or to run
23349 @kbd{a x} without a numeric prefix argument so that it expands all
23350 the way in one step.
23355 The @kbd{a a} (@code{calc-apart}) [@code{apart}] command expands a
23356 rational function by partial fractions. A rational function is the
23357 quotient of two polynomials; @code{apart} pulls this apart into a
23358 sum of rational functions with simple denominators. In algebraic
23359 notation, the @code{apart} function allows a second argument that
23360 specifies which variable to use as the ``base''; by default, Calc
23361 chooses the base variable automatically.
23364 @pindex calc-normalize-rat
23366 The @kbd{a n} (@code{calc-normalize-rat}) [@code{nrat}] command
23367 attempts to arrange a formula into a quotient of two polynomials.
23368 For example, given @expr{1 + (a + b/c) / d}, the result would be
23369 @expr{(b + a c + c d) / c d}. The quotient is reduced, so that
23370 @kbd{a n} will simplify @expr{(x^2 + 2x + 1) / (x^2 - 1)} by dividing
23371 out the common factor @expr{x + 1}, yielding @expr{(x + 1) / (x - 1)}.
23374 @pindex calc-poly-div
23376 The @kbd{a \} (@code{calc-poly-div}) [@code{pdiv}] command divides
23377 two polynomials @expr{u} and @expr{v}, yielding a new polynomial
23378 @expr{q}. If several variables occur in the inputs, the inputs are
23379 considered multivariate polynomials. (Calc divides by the variable
23380 with the largest power in @expr{u} first, or, in the case of equal
23381 powers, chooses the variables in alphabetical order.) For example,
23382 dividing @expr{x^2 + 3 x + 2} by @expr{x + 2} yields @expr{x + 1}.
23383 The remainder from the division, if any, is reported at the bottom
23384 of the screen and is also placed in the Trail along with the quotient.
23386 Using @code{pdiv} in algebraic notation, you can specify the particular
23387 variable to be used as the base: @code{pdiv(@var{a},@var{b},@var{x})}.
23388 If @code{pdiv} is given only two arguments (as is always the case with
23389 the @kbd{a \} command), then it does a multivariate division as outlined
23393 @pindex calc-poly-rem
23395 The @kbd{a %} (@code{calc-poly-rem}) [@code{prem}] command divides
23396 two polynomials and keeps the remainder @expr{r}. The quotient
23397 @expr{q} is discarded. For any formulas @expr{a} and @expr{b}, the
23398 results of @kbd{a \} and @kbd{a %} satisfy @expr{a = q b + r}.
23399 (This is analogous to plain @kbd{\} and @kbd{%}, which compute the
23400 integer quotient and remainder from dividing two numbers.)
23404 @pindex calc-poly-div-rem
23407 The @kbd{a /} (@code{calc-poly-div-rem}) [@code{pdivrem}] command
23408 divides two polynomials and reports both the quotient and the
23409 remainder as a vector @expr{[q, r]}. The @kbd{H a /} [@code{pdivide}]
23410 command divides two polynomials and constructs the formula
23411 @expr{q + r/b} on the stack. (Naturally if the remainder is zero,
23412 this will immediately simplify to @expr{q}.)
23415 @pindex calc-poly-gcd
23417 The @kbd{a g} (@code{calc-poly-gcd}) [@code{pgcd}] command computes
23418 the greatest common divisor of two polynomials. (The GCD actually
23419 is unique only to within a constant multiplier; Calc attempts to
23420 choose a GCD which will be unsurprising.) For example, the @kbd{a n}
23421 command uses @kbd{a g} to take the GCD of the numerator and denominator
23422 of a quotient, then divides each by the result using @kbd{a \}. (The
23423 definition of GCD ensures that this division can take place without
23424 leaving a remainder.)
23426 While the polynomials used in operations like @kbd{a /} and @kbd{a g}
23427 often have integer coefficients, this is not required. Calc can also
23428 deal with polynomials over the rationals or floating-point reals.
23429 Polynomials with modulo-form coefficients are also useful in many
23430 applications; if you enter @samp{(x^2 + 3 x - 1) mod 5}, Calc
23431 automatically transforms this into a polynomial over the field of
23432 integers mod 5: @samp{(1 mod 5) x^2 + (3 mod 5) x + (4 mod 5)}.
23434 Congratulations and thanks go to Ove Ewerlid
23435 (@code{ewerlid@@mizar.DoCS.UU.SE}), who contributed many of the
23436 polynomial routines used in the above commands.
23438 @xref{Decomposing Polynomials}, for several useful functions for
23439 extracting the individual coefficients of a polynomial.
23441 @node Calculus, Solving Equations, Polynomials, Algebra
23445 The following calculus commands do not automatically simplify their
23446 inputs or outputs using @code{calc-simplify}. You may find it helps
23447 to do this by hand by typing @kbd{a s} or @kbd{a e}. It may also help
23448 to use @kbd{a x} and/or @kbd{a c} to arrange a result in the most
23452 * Differentiation::
23454 * Customizing the Integrator::
23455 * Numerical Integration::
23459 @node Differentiation, Integration, Calculus, Calculus
23460 @subsection Differentiation
23465 @pindex calc-derivative
23468 The @kbd{a d} (@code{calc-derivative}) [@code{deriv}] command computes
23469 the derivative of the expression on the top of the stack with respect to
23470 some variable, which it will prompt you to enter. Normally, variables
23471 in the formula other than the specified differentiation variable are
23472 considered constant, i.e., @samp{deriv(y,x)} is reduced to zero. With
23473 the Hyperbolic flag, the @code{tderiv} (total derivative) operation is used
23474 instead, in which derivatives of variables are not reduced to zero
23475 unless those variables are known to be ``constant,'' i.e., independent
23476 of any other variables. (The built-in special variables like @code{pi}
23477 are considered constant, as are variables that have been declared
23478 @code{const}; @pxref{Declarations}.)
23480 With a numeric prefix argument @var{n}, this command computes the
23481 @var{n}th derivative.
23483 When working with trigonometric functions, it is best to switch to
23484 Radians mode first (with @w{@kbd{m r}}). The derivative of @samp{sin(x)}
23485 in degrees is @samp{(pi/180) cos(x)}, probably not the expected
23488 If you use the @code{deriv} function directly in an algebraic formula,
23489 you can write @samp{deriv(f,x,x0)} which represents the derivative
23490 of @expr{f} with respect to @expr{x}, evaluated at the point
23491 @texline @math{x=x_0}.
23492 @infoline @expr{x=x0}.
23494 If the formula being differentiated contains functions which Calc does
23495 not know, the derivatives of those functions are produced by adding
23496 primes (apostrophe characters). For example, @samp{deriv(f(2x), x)}
23497 produces @samp{2 f'(2 x)}, where the function @code{f'} represents the
23498 derivative of @code{f}.
23500 For functions you have defined with the @kbd{Z F} command, Calc expands
23501 the functions according to their defining formulas unless you have
23502 also defined @code{f'} suitably. For example, suppose we define
23503 @samp{sinc(x) = sin(x)/x} using @kbd{Z F}. If we then differentiate
23504 the formula @samp{sinc(2 x)}, the formula will be expanded to
23505 @samp{sin(2 x) / (2 x)} and differentiated. However, if we also
23506 define @samp{sinc'(x) = dsinc(x)}, say, then Calc will write the
23507 result as @samp{2 dsinc(2 x)}. @xref{Algebraic Definitions}.
23509 For multi-argument functions @samp{f(x,y,z)}, the derivative with respect
23510 to the first argument is written @samp{f'(x,y,z)}; derivatives with
23511 respect to the other arguments are @samp{f'2(x,y,z)} and @samp{f'3(x,y,z)}.
23512 Various higher-order derivatives can be formed in the obvious way, e.g.,
23513 @samp{f'@var{}'(x)} (the second derivative of @code{f}) or
23514 @samp{f'@var{}'2'3(x,y,z)} (@code{f} differentiated with respect to each
23517 @node Integration, Customizing the Integrator, Differentiation, Calculus
23518 @subsection Integration
23522 @pindex calc-integral
23524 The @kbd{a i} (@code{calc-integral}) [@code{integ}] command computes the
23525 indefinite integral of the expression on the top of the stack with
23526 respect to a prompted-for variable. The integrator is not guaranteed to
23527 work for all integrable functions, but it is able to integrate several
23528 large classes of formulas. In particular, any polynomial or rational
23529 function (a polynomial divided by a polynomial) is acceptable.
23530 (Rational functions don't have to be in explicit quotient form, however;
23531 @texline @math{x/(1+x^{-2})}
23532 @infoline @expr{x/(1+x^-2)}
23533 is not strictly a quotient of polynomials, but it is equivalent to
23534 @expr{x^3/(x^2+1)}, which is.) Also, square roots of terms involving
23535 @expr{x} and @expr{x^2} may appear in rational functions being
23536 integrated. Finally, rational functions involving trigonometric or
23537 hyperbolic functions can be integrated.
23539 With an argument (@kbd{C-u a i}), this command will compute the definite
23540 integral of the expression on top of the stack. In this case, the
23541 command will again prompt for an integration variable, then prompt for a
23542 lower limit and an upper limit.
23545 If you use the @code{integ} function directly in an algebraic formula,
23546 you can also write @samp{integ(f,x,v)} which expresses the resulting
23547 indefinite integral in terms of variable @code{v} instead of @code{x}.
23548 With four arguments, @samp{integ(f(x),x,a,b)} represents a definite
23549 integral from @code{a} to @code{b}.
23552 If you use the @code{integ} function directly in an algebraic formula,
23553 you can also write @samp{integ(f,x,v)} which expresses the resulting
23554 indefinite integral in terms of variable @code{v} instead of @code{x}.
23555 With four arguments, @samp{integ(f(x),x,a,b)} represents a definite
23556 integral $\int_a^b f(x) \, dx$.
23559 Please note that the current implementation of Calc's integrator sometimes
23560 produces results that are significantly more complex than they need to
23561 be. For example, the integral Calc finds for
23562 @texline @math{1/(x+\sqrt{x^2+1})}
23563 @infoline @expr{1/(x+sqrt(x^2+1))}
23564 is several times more complicated than the answer Mathematica
23565 returns for the same input, although the two forms are numerically
23566 equivalent. Also, any indefinite integral should be considered to have
23567 an arbitrary constant of integration added to it, although Calc does not
23568 write an explicit constant of integration in its result. For example,
23569 Calc's solution for
23570 @texline @math{1/(1+\tan x)}
23571 @infoline @expr{1/(1+tan(x))}
23572 differs from the solution given in the @emph{CRC Math Tables} by a
23574 @texline @math{\pi i / 2}
23575 @infoline @expr{pi i / 2},
23576 due to a different choice of constant of integration.
23578 The Calculator remembers all the integrals it has done. If conditions
23579 change in a way that would invalidate the old integrals, say, a switch
23580 from Degrees to Radians mode, then they will be thrown out. If you
23581 suspect this is not happening when it should, use the
23582 @code{calc-flush-caches} command; @pxref{Caches}.
23585 Calc normally will pursue integration by substitution or integration by
23586 parts up to 3 nested times before abandoning an approach as fruitless.
23587 If the integrator is taking too long, you can lower this limit by storing
23588 a number (like 2) in the variable @code{IntegLimit}. (The @kbd{s I}
23589 command is a convenient way to edit @code{IntegLimit}.) If this variable
23590 has no stored value or does not contain a nonnegative integer, a limit
23591 of 3 is used. The lower this limit is, the greater the chance that Calc
23592 will be unable to integrate a function it could otherwise handle. Raising
23593 this limit allows the Calculator to solve more integrals, though the time
23594 it takes may grow exponentially. You can monitor the integrator's actions
23595 by creating an Emacs buffer called @file{*Trace*}. If such a buffer
23596 exists, the @kbd{a i} command will write a log of its actions there.
23598 If you want to manipulate integrals in a purely symbolic way, you can
23599 set the integration nesting limit to 0 to prevent all but fast
23600 table-lookup solutions of integrals. You might then wish to define
23601 rewrite rules for integration by parts, various kinds of substitutions,
23602 and so on. @xref{Rewrite Rules}.
23604 @node Customizing the Integrator, Numerical Integration, Integration, Calculus
23605 @subsection Customizing the Integrator
23609 Calc has two built-in rewrite rules called @code{IntegRules} and
23610 @code{IntegAfterRules} which you can edit to define new integration
23611 methods. @xref{Rewrite Rules}. At each step of the integration process,
23612 Calc wraps the current integrand in a call to the fictitious function
23613 @samp{integtry(@var{expr},@var{var})}, where @var{expr} is the
23614 integrand and @var{var} is the integration variable. If your rules
23615 rewrite this to be a plain formula (not a call to @code{integtry}), then
23616 Calc will use this formula as the integral of @var{expr}. For example,
23617 the rule @samp{integtry(mysin(x),x) := -mycos(x)} would define a rule to
23618 integrate a function @code{mysin} that acts like the sine function.
23619 Then, putting @samp{4 mysin(2y+1)} on the stack and typing @kbd{a i y}
23620 will produce the integral @samp{-2 mycos(2y+1)}. Note that Calc has
23621 automatically made various transformations on the integral to allow it
23622 to use your rule; integral tables generally give rules for
23623 @samp{mysin(a x + b)}, but you don't need to use this much generality
23624 in your @code{IntegRules}.
23626 @cindex Exponential integral Ei(x)
23631 As a more serious example, the expression @samp{exp(x)/x} cannot be
23632 integrated in terms of the standard functions, so the ``exponential
23633 integral'' function
23634 @texline @math{{\rm Ei}(x)}
23635 @infoline @expr{Ei(x)}
23636 was invented to describe it.
23637 We can get Calc to do this integral in terms of a made-up @code{Ei}
23638 function by adding the rule @samp{[integtry(exp(x)/x, x) := Ei(x)]}
23639 to @code{IntegRules}. Now entering @samp{exp(2x)/x} on the stack
23640 and typing @kbd{a i x} yields @samp{Ei(2 x)}. This new rule will
23641 work with Calc's various built-in integration methods (such as
23642 integration by substitution) to solve a variety of other problems
23643 involving @code{Ei}: For example, now Calc will also be able to
23644 integrate @samp{exp(exp(x))} and @samp{ln(ln(x))} (to get @samp{Ei(exp(x))}
23645 and @samp{x ln(ln(x)) - Ei(ln(x))}, respectively).
23647 Your rule may do further integration by calling @code{integ}. For
23648 example, @samp{integtry(twice(u),x) := twice(integ(u))} allows Calc
23649 to integrate @samp{twice(sin(x))} to get @samp{twice(-cos(x))}.
23650 Note that @code{integ} was called with only one argument. This notation
23651 is allowed only within @code{IntegRules}; it means ``integrate this
23652 with respect to the same integration variable.'' If Calc is unable
23653 to integrate @code{u}, the integration that invoked @code{IntegRules}
23654 also fails. Thus integrating @samp{twice(f(x))} fails, returning the
23655 unevaluated integral @samp{integ(twice(f(x)), x)}. It is still valid
23656 to call @code{integ} with two or more arguments, however; in this case,
23657 if @code{u} is not integrable, @code{twice} itself will still be
23658 integrated: If the above rule is changed to @samp{... := twice(integ(u,x))},
23659 then integrating @samp{twice(f(x))} will yield @samp{twice(integ(f(x),x))}.
23661 If a rule instead produces the formula @samp{integsubst(@var{sexpr},
23662 @var{svar})}, either replacing the top-level @code{integtry} call or
23663 nested anywhere inside the expression, then Calc will apply the
23664 substitution @samp{@var{u} = @var{sexpr}(@var{svar})} to try to
23665 integrate the original @var{expr}. For example, the rule
23666 @samp{sqrt(a) := integsubst(sqrt(x),x)} says that if Calc ever finds
23667 a square root in the integrand, it should attempt the substitution
23668 @samp{u = sqrt(x)}. (This particular rule is unnecessary because
23669 Calc always tries ``obvious'' substitutions where @var{sexpr} actually
23670 appears in the integrand.) The variable @var{svar} may be the same
23671 as the @var{var} that appeared in the call to @code{integtry}, but
23674 When integrating according to an @code{integsubst}, Calc uses the
23675 equation solver to find the inverse of @var{sexpr} (if the integrand
23676 refers to @var{var} anywhere except in subexpressions that exactly
23677 match @var{sexpr}). It uses the differentiator to find the derivative
23678 of @var{sexpr} and/or its inverse (it has two methods that use one
23679 derivative or the other). You can also specify these items by adding
23680 extra arguments to the @code{integsubst} your rules construct; the
23681 general form is @samp{integsubst(@var{sexpr}, @var{svar}, @var{sinv},
23682 @var{sprime})}, where @var{sinv} is the inverse of @var{sexpr} (still
23683 written as a function of @var{svar}), and @var{sprime} is the
23684 derivative of @var{sexpr} with respect to @var{svar}. If you don't
23685 specify these things, and Calc is not able to work them out on its
23686 own with the information it knows, then your substitution rule will
23687 work only in very specific, simple cases.
23689 Calc applies @code{IntegRules} as if by @kbd{C-u 1 a r IntegRules};
23690 in other words, Calc stops rewriting as soon as any rule in your rule
23691 set succeeds. (If it weren't for this, the @samp{integsubst(sqrt(x),x)}
23692 example above would keep on adding layers of @code{integsubst} calls
23695 @vindex IntegSimpRules
23696 Another set of rules, stored in @code{IntegSimpRules}, are applied
23697 every time the integrator uses algebraic simplifications to simplify an
23698 intermediate result. For example, putting the rule
23699 @samp{twice(x) := 2 x} into @code{IntegSimpRules} would tell Calc to
23700 convert the @code{twice} function into a form it knows whenever
23701 integration is attempted.
23703 One more way to influence the integrator is to define a function with
23704 the @kbd{Z F} command (@pxref{Algebraic Definitions}). Calc's
23705 integrator automatically expands such functions according to their
23706 defining formulas, even if you originally asked for the function to
23707 be left unevaluated for symbolic arguments. (Certain other Calc
23708 systems, such as the differentiator and the equation solver, also
23711 @vindex IntegAfterRules
23712 Sometimes Calc is able to find a solution to your integral, but it
23713 expresses the result in a way that is unnecessarily complicated. If
23714 this happens, you can either use @code{integsubst} as described
23715 above to try to hint at a more direct path to the desired result, or
23716 you can use @code{IntegAfterRules}. This is an extra rule set that
23717 runs after the main integrator returns its result; basically, Calc does
23718 an @kbd{a r IntegAfterRules} on the result before showing it to you.
23719 (It also does algebraic simplifications, without @code{IntegSimpRules},
23720 after that to further simplify the result.) For example, Calc's integrator
23721 sometimes produces expressions of the form @samp{ln(1+x) - ln(1-x)};
23722 the default @code{IntegAfterRules} rewrite this into the more readable
23723 form @samp{2 arctanh(x)}. Note that, unlike @code{IntegRules},
23724 @code{IntegSimpRules} and @code{IntegAfterRules} are applied any number
23725 of times until no further changes are possible. Rewriting by
23726 @code{IntegAfterRules} occurs only after the main integrator has
23727 finished, not at every step as for @code{IntegRules} and
23728 @code{IntegSimpRules}.
23730 @node Numerical Integration, Taylor Series, Customizing the Integrator, Calculus
23731 @subsection Numerical Integration
23735 @pindex calc-num-integral
23737 If you want a purely numerical answer to an integration problem, you can
23738 use the @kbd{a I} (@code{calc-num-integral}) [@code{ninteg}] command. This
23739 command prompts for an integration variable, a lower limit, and an
23740 upper limit. Except for the integration variable, all other variables
23741 that appear in the integrand formula must have stored values. (A stored
23742 value, if any, for the integration variable itself is ignored.)
23744 Numerical integration works by evaluating your formula at many points in
23745 the specified interval. Calc uses an ``open Romberg'' method; this means
23746 that it does not evaluate the formula actually at the endpoints (so that
23747 it is safe to integrate @samp{sin(x)/x} from zero, for example). Also,
23748 the Romberg method works especially well when the function being
23749 integrated is fairly smooth. If the function is not smooth, Calc will
23750 have to evaluate it at quite a few points before it can accurately
23751 determine the value of the integral.
23753 Integration is much faster when the current precision is small. It is
23754 best to set the precision to the smallest acceptable number of digits
23755 before you use @kbd{a I}. If Calc appears to be taking too long, press
23756 @kbd{C-g} to halt it and try a lower precision. If Calc still appears
23757 to need hundreds of evaluations, check to make sure your function is
23758 well-behaved in the specified interval.
23760 It is possible for the lower integration limit to be @samp{-inf} (minus
23761 infinity). Likewise, the upper limit may be plus infinity. Calc
23762 internally transforms the integral into an equivalent one with finite
23763 limits. However, integration to or across singularities is not supported:
23764 The integral of @samp{1/sqrt(x)} from 0 to 1 exists (it can be found
23765 by Calc's symbolic integrator, for example), but @kbd{a I} will fail
23766 because the integrand goes to infinity at one of the endpoints.
23768 @node Taylor Series, , Numerical Integration, Calculus
23769 @subsection Taylor Series
23773 @pindex calc-taylor
23775 The @kbd{a t} (@code{calc-taylor}) [@code{taylor}] command computes a
23776 power series expansion or Taylor series of a function. You specify the
23777 variable and the desired number of terms. You may give an expression of
23778 the form @samp{@var{var} = @var{a}} or @samp{@var{var} - @var{a}} instead
23779 of just a variable to produce a Taylor expansion about the point @var{a}.
23780 You may specify the number of terms with a numeric prefix argument;
23781 otherwise the command will prompt you for the number of terms. Note that
23782 many series expansions have coefficients of zero for some terms, so you
23783 may appear to get fewer terms than you asked for.
23785 If the @kbd{a i} command is unable to find a symbolic integral for a
23786 function, you can get an approximation by integrating the function's
23789 @node Solving Equations, Numerical Solutions, Calculus, Algebra
23790 @section Solving Equations
23794 @pindex calc-solve-for
23796 @cindex Equations, solving
23797 @cindex Solving equations
23798 The @kbd{a S} (@code{calc-solve-for}) [@code{solve}] command rearranges
23799 an equation to solve for a specific variable. An equation is an
23800 expression of the form @expr{L = R}. For example, the command @kbd{a S x}
23801 will rearrange @expr{y = 3x + 6} to the form, @expr{x = y/3 - 2}. If the
23802 input is not an equation, it is treated like an equation of the
23805 This command also works for inequalities, as in @expr{y < 3x + 6}.
23806 Some inequalities cannot be solved where the analogous equation could
23807 be; for example, solving
23808 @texline @math{a < b \, c}
23809 @infoline @expr{a < b c}
23810 for @expr{b} is impossible
23811 without knowing the sign of @expr{c}. In this case, @kbd{a S} will
23813 @texline @math{b \mathbin{\hbox{\code{!=}}} a/c}
23814 @infoline @expr{b != a/c}
23815 (using the not-equal-to operator) to signify that the direction of the
23816 inequality is now unknown. The inequality
23817 @texline @math{a \le b \, c}
23818 @infoline @expr{a <= b c}
23819 is not even partially solved. @xref{Declarations}, for a way to tell
23820 Calc that the signs of the variables in a formula are in fact known.
23822 Two useful commands for working with the result of @kbd{a S} are
23823 @kbd{a .} (@pxref{Logical Operations}), which converts @expr{x = y/3 - 2}
23824 to @expr{y/3 - 2}, and @kbd{s l} (@pxref{Let Command}) which evaluates
23825 another formula with @expr{x} set equal to @expr{y/3 - 2}.
23828 * Multiple Solutions::
23829 * Solving Systems of Equations::
23830 * Decomposing Polynomials::
23833 @node Multiple Solutions, Solving Systems of Equations, Solving Equations, Solving Equations
23834 @subsection Multiple Solutions
23839 Some equations have more than one solution. The Hyperbolic flag
23840 (@code{H a S}) [@code{fsolve}] tells the solver to report the fully
23841 general family of solutions. It will invent variables @code{n1},
23842 @code{n2}, @dots{}, which represent independent arbitrary integers, and
23843 @code{s1}, @code{s2}, @dots{}, which represent independent arbitrary
23844 signs (either @mathit{+1} or @mathit{-1}). If you don't use the Hyperbolic
23845 flag, Calc will use zero in place of all arbitrary integers, and plus
23846 one in place of all arbitrary signs. Note that variables like @code{n1}
23847 and @code{s1} are not given any special interpretation in Calc except by
23848 the equation solver itself. As usual, you can use the @w{@kbd{s l}}
23849 (@code{calc-let}) command to obtain solutions for various actual values
23850 of these variables.
23852 For example, @kbd{' x^2 = y @key{RET} H a S x @key{RET}} solves to
23853 get @samp{x = s1 sqrt(y)}, indicating that the two solutions to the
23854 equation are @samp{sqrt(y)} and @samp{-sqrt(y)}. Another way to
23855 think about it is that the square-root operation is really a
23856 two-valued function; since every Calc function must return a
23857 single result, @code{sqrt} chooses to return the positive result.
23858 Then @kbd{H a S} doctors this result using @code{s1} to indicate
23859 the full set of possible values of the mathematical square-root.
23861 There is a similar phenomenon going the other direction: Suppose
23862 we solve @samp{sqrt(y) = x} for @code{y}. Calc squares both sides
23863 to get @samp{y = x^2}. This is correct, except that it introduces
23864 some dubious solutions. Consider solving @samp{sqrt(y) = -3}:
23865 Calc will report @expr{y = 9} as a valid solution, which is true
23866 in the mathematical sense of square-root, but false (there is no
23867 solution) for the actual Calc positive-valued @code{sqrt}. This
23868 happens for both @kbd{a S} and @kbd{H a S}.
23870 @cindex @code{GenCount} variable
23880 If you store a positive integer in the Calc variable @code{GenCount},
23881 then Calc will generate formulas of the form @samp{as(@var{n})} for
23882 arbitrary signs, and @samp{an(@var{n})} for arbitrary integers,
23883 where @var{n} represents successive values taken by incrementing
23884 @code{GenCount} by one. While the normal arbitrary sign and
23885 integer symbols start over at @code{s1} and @code{n1} with each
23886 new Calc command, the @code{GenCount} approach will give each
23887 arbitrary value a name that is unique throughout the entire Calc
23888 session. Also, the arbitrary values are function calls instead
23889 of variables, which is advantageous in some cases. For example,
23890 you can make a rewrite rule that recognizes all arbitrary signs
23891 using a pattern like @samp{as(n)}. The @kbd{s l} command only works
23892 on variables, but you can use the @kbd{a b} (@code{calc-substitute})
23893 command to substitute actual values for function calls like @samp{as(3)}.
23895 The @kbd{s G} (@code{calc-edit-GenCount}) command is a convenient
23896 way to create or edit this variable. Press @kbd{C-c C-c} to finish.
23898 If you have not stored a value in @code{GenCount}, or if the value
23899 in that variable is not a positive integer, the regular
23900 @code{s1}/@code{n1} notation is used.
23906 With the Inverse flag, @kbd{I a S} [@code{finv}] treats the expression
23907 on top of the stack as a function of the specified variable and solves
23908 to find the inverse function, written in terms of the same variable.
23909 For example, @kbd{I a S x} inverts @expr{2x + 6} to @expr{x/2 - 3}.
23910 You can use both Inverse and Hyperbolic [@code{ffinv}] to obtain a
23911 fully general inverse, as described above.
23914 @pindex calc-poly-roots
23916 Some equations, specifically polynomials, have a known, finite number
23917 of solutions. The @kbd{a P} (@code{calc-poly-roots}) [@code{roots}]
23918 command uses @kbd{H a S} to solve an equation in general form, then, for
23919 all arbitrary-sign variables like @code{s1}, and all arbitrary-integer
23920 variables like @code{n1} for which @code{n1} only usefully varies over
23921 a finite range, it expands these variables out to all their possible
23922 values. The results are collected into a vector, which is returned.
23923 For example, @samp{roots(x^4 = 1, x)} returns the four solutions
23924 @samp{[1, -1, (0, 1), (0, -1)]}. Generally an @var{n}th degree
23925 polynomial will always have @var{n} roots on the complex plane.
23926 (If you have given a @code{real} declaration for the solution
23927 variable, then only the real-valued solutions, if any, will be
23928 reported; @pxref{Declarations}.)
23930 Note that because @kbd{a P} uses @kbd{H a S}, it is able to deliver
23931 symbolic solutions if the polynomial has symbolic coefficients. Also
23932 note that Calc's solver is not able to get exact symbolic solutions
23933 to all polynomials. Polynomials containing powers up to @expr{x^4}
23934 can always be solved exactly; polynomials of higher degree sometimes
23935 can be: @expr{x^6 + x^3 + 1} is converted to @expr{(x^3)^2 + (x^3) + 1},
23936 which can be solved for @expr{x^3} using the quadratic equation, and then
23937 for @expr{x} by taking cube roots. But in many cases, like
23938 @expr{x^6 + x + 1}, Calc does not know how to rewrite the polynomial
23939 into a form it can solve. The @kbd{a P} command can still deliver a
23940 list of numerical roots, however, provided that Symbolic mode (@kbd{m s})
23941 is not turned on. (If you work with Symbolic mode on, recall that the
23942 @kbd{N} (@code{calc-eval-num}) key is a handy way to reevaluate the
23943 formula on the stack with Symbolic mode temporarily off.) Naturally,
23944 @kbd{a P} can only provide numerical roots if the polynomial coefficients
23945 are all numbers (real or complex).
23947 @node Solving Systems of Equations, Decomposing Polynomials, Multiple Solutions, Solving Equations
23948 @subsection Solving Systems of Equations
23951 @cindex Systems of equations, symbolic
23952 You can also use the commands described above to solve systems of
23953 simultaneous equations. Just create a vector of equations, then
23954 specify a vector of variables for which to solve. (You can omit
23955 the surrounding brackets when entering the vector of variables
23958 For example, putting @samp{[x + y = a, x - y = b]} on the stack
23959 and typing @kbd{a S x,y @key{RET}} produces the vector of solutions
23960 @samp{[x = a - (a-b)/2, y = (a-b)/2]}. The result vector will
23961 have the same length as the variables vector, and the variables
23962 will be listed in the same order there. Note that the solutions
23963 are not always simplified as far as possible; the solution for
23964 @expr{x} here could be improved by an application of the @kbd{a n}
23967 Calc's algorithm works by trying to eliminate one variable at a
23968 time by solving one of the equations for that variable and then
23969 substituting into the other equations. Calc will try all the
23970 possibilities, but you can speed things up by noting that Calc
23971 first tries to eliminate the first variable with the first
23972 equation, then the second variable with the second equation,
23973 and so on. It also helps to put the simpler (e.g., more linear)
23974 equations toward the front of the list. Calc's algorithm will
23975 solve any system of linear equations, and also many kinds of
23982 Normally there will be as many variables as equations. If you
23983 give fewer variables than equations (an ``over-determined'' system
23984 of equations), Calc will find a partial solution. For example,
23985 typing @kbd{a S y @key{RET}} with the above system of equations
23986 would produce @samp{[y = a - x]}. There are now several ways to
23987 express this solution in terms of the original variables; Calc uses
23988 the first one that it finds. You can control the choice by adding
23989 variable specifiers of the form @samp{elim(@var{v})} to the
23990 variables list. This says that @var{v} should be eliminated from
23991 the equations; the variable will not appear at all in the solution.
23992 For example, typing @kbd{a S y,elim(x)} would yield
23993 @samp{[y = a - (b+a)/2]}.
23995 If the variables list contains only @code{elim} specifiers,
23996 Calc simply eliminates those variables from the equations
23997 and then returns the resulting set of equations. For example,
23998 @kbd{a S elim(x)} produces @samp{[a - 2 y = b]}. Every variable
23999 eliminated will reduce the number of equations in the system
24002 Again, @kbd{a S} gives you one solution to the system of
24003 equations. If there are several solutions, you can use @kbd{H a S}
24004 to get a general family of solutions, or, if there is a finite
24005 number of solutions, you can use @kbd{a P} to get a list. (In
24006 the latter case, the result will take the form of a matrix where
24007 the rows are different solutions and the columns correspond to the
24008 variables you requested.)
24010 Another way to deal with certain kinds of overdetermined systems of
24011 equations is the @kbd{a F} command, which does least-squares fitting
24012 to satisfy the equations. @xref{Curve Fitting}.
24014 @node Decomposing Polynomials, , Solving Systems of Equations, Solving Equations
24015 @subsection Decomposing Polynomials
24022 The @code{poly} function takes a polynomial and a variable as
24023 arguments, and returns a vector of polynomial coefficients (constant
24024 coefficient first). For example, @samp{poly(x^3 + 2 x, x)} returns
24025 @expr{[0, 2, 0, 1]}. If the input is not a polynomial in @expr{x},
24026 the call to @code{poly} is left in symbolic form. If the input does
24027 not involve the variable @expr{x}, the input is returned in a list
24028 of length one, representing a polynomial with only a constant
24029 coefficient. The call @samp{poly(x, x)} returns the vector @expr{[0, 1]}.
24030 The last element of the returned vector is guaranteed to be nonzero;
24031 note that @samp{poly(0, x)} returns the empty vector @expr{[]}.
24032 Note also that @expr{x} may actually be any formula; for example,
24033 @samp{poly(sin(x)^2 - sin(x) + 3, sin(x))} returns @expr{[3, -1, 1]}.
24035 @cindex Coefficients of polynomial
24036 @cindex Degree of polynomial
24037 To get the @expr{x^k} coefficient of polynomial @expr{p}, use
24038 @samp{poly(p, x)_(k+1)}. To get the degree of polynomial @expr{p},
24039 use @samp{vlen(poly(p, x)) - 1}. For example, @samp{poly((x+1)^4, x)}
24040 returns @samp{[1, 4, 6, 4, 1]}, so @samp{poly((x+1)^4, x)_(2+1)}
24041 gives the @expr{x^2} coefficient of this polynomial, 6.
24047 One important feature of the solver is its ability to recognize
24048 formulas which are ``essentially'' polynomials. This ability is
24049 made available to the user through the @code{gpoly} function, which
24050 is used just like @code{poly}: @samp{gpoly(@var{expr}, @var{var})}.
24051 If @var{expr} is a polynomial in some term which includes @var{var}, then
24052 this function will return a vector @samp{[@var{x}, @var{c}, @var{a}]}
24053 where @var{x} is the term that depends on @var{var}, @var{c} is a
24054 vector of polynomial coefficients (like the one returned by @code{poly}),
24055 and @var{a} is a multiplier which is usually 1. Basically,
24056 @samp{@var{expr} = @var{a}*(@var{c}_1 + @var{c}_2 @var{x} +
24057 @var{c}_3 @var{x}^2 + ...)}. The last element of @var{c} is
24058 guaranteed to be non-zero, and @var{c} will not equal @samp{[1]}
24059 (i.e., the trivial decomposition @var{expr} = @var{x} is not
24060 considered a polynomial). One side effect is that @samp{gpoly(x, x)}
24061 and @samp{gpoly(6, x)}, both of which might be expected to recognize
24062 their arguments as polynomials, will not because the decomposition
24063 is considered trivial.
24065 For example, @samp{gpoly((x-2)^2, x)} returns @samp{[x, [4, -4, 1], 1]},
24066 since the expanded form of this polynomial is @expr{4 - 4 x + x^2}.
24068 The term @var{x} may itself be a polynomial in @var{var}. This is
24069 done to reduce the size of the @var{c} vector. For example,
24070 @samp{gpoly(x^4 + x^2 - 1, x)} returns @samp{[x^2, [-1, 1, 1], 1]},
24071 since a quadratic polynomial in @expr{x^2} is easier to solve than
24072 a quartic polynomial in @expr{x}.
24074 A few more examples of the kinds of polynomials @code{gpoly} can
24078 sin(x) - 1 [sin(x), [-1, 1], 1]
24079 x + 1/x - 1 [x, [1, -1, 1], 1/x]
24080 x + 1/x [x^2, [1, 1], 1/x]
24081 x^3 + 2 x [x^2, [2, 1], x]
24082 x + x^2:3 + sqrt(x) [x^1:6, [1, 1, 0, 1], x^1:2]
24083 x^(2a) + 2 x^a + 5 [x^a, [5, 2, 1], 1]
24084 (exp(-x) + exp(x)) / 2 [e^(2 x), [0.5, 0.5], e^-x]
24087 The @code{poly} and @code{gpoly} functions accept a third integer argument
24088 which specifies the largest degree of polynomial that is acceptable.
24089 If this is @expr{n}, then only @var{c} vectors of length @expr{n+1}
24090 or less will be returned. Otherwise, the @code{poly} or @code{gpoly}
24091 call will remain in symbolic form. For example, the equation solver
24092 can handle quartics and smaller polynomials, so it calls
24093 @samp{gpoly(@var{expr}, @var{var}, 4)} to discover whether @var{expr}
24094 can be treated by its linear, quadratic, cubic, or quartic formulas.
24100 The @code{pdeg} function computes the degree of a polynomial;
24101 @samp{pdeg(p,x)} is the highest power of @code{x} that appears in
24102 @code{p}. This is the same as @samp{vlen(poly(p,x))-1}, but is
24103 much more efficient. If @code{p} is constant with respect to @code{x},
24104 then @samp{pdeg(p,x) = 0}. If @code{p} is not a polynomial in @code{x}
24105 (e.g., @samp{pdeg(2 cos(x), x)}, the function remains unevaluated.
24106 It is possible to omit the second argument @code{x}, in which case
24107 @samp{pdeg(p)} returns the highest total degree of any term of the
24108 polynomial, counting all variables that appear in @code{p}. Note
24109 that @code{pdeg(c) = pdeg(c,x) = 0} for any nonzero constant @code{c};
24110 the degree of the constant zero is considered to be @code{-inf}
24117 The @code{plead} function finds the leading term of a polynomial.
24118 Thus @samp{plead(p,x)} is equivalent to @samp{poly(p,x)_vlen(poly(p,x))},
24119 though again more efficient. In particular, @samp{plead((2x+1)^10, x)}
24120 returns 1024 without expanding out the list of coefficients. The
24121 value of @code{plead(p,x)} will be zero only if @expr{p = 0}.
24127 The @code{pcont} function finds the @dfn{content} of a polynomial. This
24128 is the greatest common divisor of all the coefficients of the polynomial.
24129 With two arguments, @code{pcont(p,x)} effectively uses @samp{poly(p,x)}
24130 to get a list of coefficients, then uses @code{pgcd} (the polynomial
24131 GCD function) to combine these into an answer. For example,
24132 @samp{pcont(4 x y^2 + 6 x^2 y, x)} is @samp{2 y}. The content is
24133 basically the ``biggest'' polynomial that can be divided into @code{p}
24134 exactly. The sign of the content is the same as the sign of the leading
24137 With only one argument, @samp{pcont(p)} computes the numerical
24138 content of the polynomial, i.e., the @code{gcd} of the numerical
24139 coefficients of all the terms in the formula. Note that @code{gcd}
24140 is defined on rational numbers as well as integers; it computes
24141 the @code{gcd} of the numerators and the @code{lcm} of the
24142 denominators. Thus @samp{pcont(4:3 x y^2 + 6 x^2 y)} returns 2:3.
24143 Dividing the polynomial by this number will clear all the
24144 denominators, as well as dividing by any common content in the
24145 numerators. The numerical content of a polynomial is negative only
24146 if all the coefficients in the polynomial are negative.
24152 The @code{pprim} function finds the @dfn{primitive part} of a
24153 polynomial, which is simply the polynomial divided (using @code{pdiv}
24154 if necessary) by its content. If the input polynomial has rational
24155 coefficients, the result will have integer coefficients in simplest
24158 @node Numerical Solutions, Curve Fitting, Solving Equations, Algebra
24159 @section Numerical Solutions
24162 Not all equations can be solved symbolically. The commands in this
24163 section use numerical algorithms that can find a solution to a specific
24164 instance of an equation to any desired accuracy. Note that the
24165 numerical commands are slower than their algebraic cousins; it is a
24166 good idea to try @kbd{a S} before resorting to these commands.
24168 (@xref{Curve Fitting}, for some other, more specialized, operations
24169 on numerical data.)
24174 * Numerical Systems of Equations::
24177 @node Root Finding, Minimization, Numerical Solutions, Numerical Solutions
24178 @subsection Root Finding
24182 @pindex calc-find-root
24184 @cindex Newton's method
24185 @cindex Roots of equations
24186 @cindex Numerical root-finding
24187 The @kbd{a R} (@code{calc-find-root}) [@code{root}] command finds a
24188 numerical solution (or @dfn{root}) of an equation. (This command treats
24189 inequalities the same as equations. If the input is any other kind
24190 of formula, it is interpreted as an equation of the form @expr{X = 0}.)
24192 The @kbd{a R} command requires an initial guess on the top of the
24193 stack, and a formula in the second-to-top position. It prompts for a
24194 solution variable, which must appear in the formula. All other variables
24195 that appear in the formula must have assigned values, i.e., when
24196 a value is assigned to the solution variable and the formula is
24197 evaluated with @kbd{=}, it should evaluate to a number. Any assigned
24198 value for the solution variable itself is ignored and unaffected by
24201 When the command completes, the initial guess is replaced on the stack
24202 by a vector of two numbers: The value of the solution variable that
24203 solves the equation, and the difference between the lefthand and
24204 righthand sides of the equation at that value. Ordinarily, the second
24205 number will be zero or very nearly zero. (Note that Calc uses a
24206 slightly higher precision while finding the root, and thus the second
24207 number may be slightly different from the value you would compute from
24208 the equation yourself.)
24210 The @kbd{v h} (@code{calc-head}) command is a handy way to extract
24211 the first element of the result vector, discarding the error term.
24213 The initial guess can be a real number, in which case Calc searches
24214 for a real solution near that number, or a complex number, in which
24215 case Calc searches the whole complex plane near that number for a
24216 solution, or it can be an interval form which restricts the search
24217 to real numbers inside that interval.
24219 Calc tries to use @kbd{a d} to take the derivative of the equation.
24220 If this succeeds, it uses Newton's method. If the equation is not
24221 differentiable Calc uses a bisection method. (If Newton's method
24222 appears to be going astray, Calc switches over to bisection if it
24223 can, or otherwise gives up. In this case it may help to try again
24224 with a slightly different initial guess.) If the initial guess is a
24225 complex number, the function must be differentiable.
24227 If the formula (or the difference between the sides of an equation)
24228 is negative at one end of the interval you specify and positive at
24229 the other end, the root finder is guaranteed to find a root.
24230 Otherwise, Calc subdivides the interval into small parts looking for
24231 positive and negative values to bracket the root. When your guess is
24232 an interval, Calc will not look outside that interval for a root.
24236 The @kbd{H a R} [@code{wroot}] command is similar to @kbd{a R}, except
24237 that if the initial guess is an interval for which the function has
24238 the same sign at both ends, then rather than subdividing the interval
24239 Calc attempts to widen it to enclose a root. Use this mode if
24240 you are not sure if the function has a root in your interval.
24242 If the function is not differentiable, and you give a simple number
24243 instead of an interval as your initial guess, Calc uses this widening
24244 process even if you did not type the Hyperbolic flag. (If the function
24245 @emph{is} differentiable, Calc uses Newton's method which does not
24246 require a bounding interval in order to work.)
24248 If Calc leaves the @code{root} or @code{wroot} function in symbolic
24249 form on the stack, it will normally display an explanation for why
24250 no root was found. If you miss this explanation, press @kbd{w}
24251 (@code{calc-why}) to get it back.
24253 @node Minimization, Numerical Systems of Equations, Root Finding, Numerical Solutions
24254 @subsection Minimization
24261 @pindex calc-find-minimum
24262 @pindex calc-find-maximum
24265 @cindex Minimization, numerical
24266 The @kbd{a N} (@code{calc-find-minimum}) [@code{minimize}] command
24267 finds a minimum value for a formula. It is very similar in operation
24268 to @kbd{a R} (@code{calc-find-root}): You give the formula and an initial
24269 guess on the stack, and are prompted for the name of a variable. The guess
24270 may be either a number near the desired minimum, or an interval enclosing
24271 the desired minimum. The function returns a vector containing the
24272 value of the variable which minimizes the formula's value, along
24273 with the minimum value itself.
24275 Note that this command looks for a @emph{local} minimum. Many functions
24276 have more than one minimum; some, like
24277 @texline @math{x \sin x},
24278 @infoline @expr{x sin(x)},
24279 have infinitely many. In fact, there is no easy way to define the
24280 ``global'' minimum of
24281 @texline @math{x \sin x}
24282 @infoline @expr{x sin(x)}
24283 but Calc can still locate any particular local minimum
24284 for you. Calc basically goes downhill from the initial guess until it
24285 finds a point at which the function's value is greater both to the left
24286 and to the right. Calc does not use derivatives when minimizing a function.
24288 If your initial guess is an interval and it looks like the minimum
24289 occurs at one or the other endpoint of the interval, Calc will return
24290 that endpoint only if that endpoint is closed; thus, minimizing @expr{17 x}
24291 over @expr{[2..3]} will return @expr{[2, 38]}, but minimizing over
24292 @expr{(2..3]} would report no minimum found. In general, you should
24293 use closed intervals to find literally the minimum value in that
24294 range of @expr{x}, or open intervals to find the local minimum, if
24295 any, that happens to lie in that range.
24297 Most functions are smooth and flat near their minimum values. Because
24298 of this flatness, if the current precision is, say, 12 digits, the
24299 variable can only be determined meaningfully to about six digits. Thus
24300 you should set the precision to twice as many digits as you need in your
24311 The @kbd{H a N} [@code{wminimize}] command, analogously to @kbd{H a R},
24312 expands the guess interval to enclose a minimum rather than requiring
24313 that the minimum lie inside the interval you supply.
24315 The @kbd{a X} (@code{calc-find-maximum}) [@code{maximize}] and
24316 @kbd{H a X} [@code{wmaximize}] commands effectively minimize the
24317 negative of the formula you supply.
24319 The formula must evaluate to a real number at all points inside the
24320 interval (or near the initial guess if the guess is a number). If
24321 the initial guess is a complex number the variable will be minimized
24322 over the complex numbers; if it is real or an interval it will
24323 be minimized over the reals.
24325 @node Numerical Systems of Equations, , Minimization, Numerical Solutions
24326 @subsection Systems of Equations
24329 @cindex Systems of equations, numerical
24330 The @kbd{a R} command can also solve systems of equations. In this
24331 case, the equation should instead be a vector of equations, the
24332 guess should instead be a vector of numbers (intervals are not
24333 supported), and the variable should be a vector of variables. You
24334 can omit the brackets while entering the list of variables. Each
24335 equation must be differentiable by each variable for this mode to
24336 work. The result will be a vector of two vectors: The variable
24337 values that solved the system of equations, and the differences
24338 between the sides of the equations with those variable values.
24339 There must be the same number of equations as variables. Since
24340 only plain numbers are allowed as guesses, the Hyperbolic flag has
24341 no effect when solving a system of equations.
24343 It is also possible to minimize over many variables with @kbd{a N}
24344 (or maximize with @kbd{a X}). Once again the variable name should
24345 be replaced by a vector of variables, and the initial guess should
24346 be an equal-sized vector of initial guesses. But, unlike the case of
24347 multidimensional @kbd{a R}, the formula being minimized should
24348 still be a single formula, @emph{not} a vector. Beware that
24349 multidimensional minimization is currently @emph{very} slow.
24351 @node Curve Fitting, Summations, Numerical Solutions, Algebra
24352 @section Curve Fitting
24355 The @kbd{a F} command fits a set of data to a @dfn{model formula},
24356 such as @expr{y = m x + b} where @expr{m} and @expr{b} are parameters
24357 to be determined. For a typical set of measured data there will be
24358 no single @expr{m} and @expr{b} that exactly fit the data; in this
24359 case, Calc chooses values of the parameters that provide the closest
24360 possible fit. The model formula can be entered in various ways after
24361 the key sequence @kbd{a F} is pressed.
24363 If the letter @kbd{P} is pressed after @kbd{a F} but before the model
24364 description is entered, the data as well as the model formula will be
24365 plotted after the formula is determined. This will be indicated by a
24366 ``P'' in the minibuffer after the help message.
24370 * Polynomial and Multilinear Fits::
24371 * Error Estimates for Fits::
24372 * Standard Nonlinear Models::
24373 * Curve Fitting Details::
24377 @node Linear Fits, Polynomial and Multilinear Fits, Curve Fitting, Curve Fitting
24378 @subsection Linear Fits
24382 @pindex calc-curve-fit
24384 @cindex Linear regression
24385 @cindex Least-squares fits
24386 The @kbd{a F} (@code{calc-curve-fit}) [@code{fit}] command attempts
24387 to fit a set of data (@expr{x} and @expr{y} vectors of numbers) to a
24388 straight line, polynomial, or other function of @expr{x}. For the
24389 moment we will consider only the case of fitting to a line, and we
24390 will ignore the issue of whether or not the model was in fact a good
24393 In a standard linear least-squares fit, we have a set of @expr{(x,y)}
24394 data points that we wish to fit to the model @expr{y = m x + b}
24395 by adjusting the parameters @expr{m} and @expr{b} to make the @expr{y}
24396 values calculated from the formula be as close as possible to the actual
24397 @expr{y} values in the data set. (In a polynomial fit, the model is
24398 instead, say, @expr{y = a x^3 + b x^2 + c x + d}. In a multilinear fit,
24399 we have data points of the form @expr{(x_1,x_2,x_3,y)} and our model is
24400 @expr{y = a x_1 + b x_2 + c x_3 + d}. These will be discussed later.)
24402 In the model formula, variables like @expr{x} and @expr{x_2} are called
24403 the @dfn{independent variables}, and @expr{y} is the @dfn{dependent
24404 variable}. Variables like @expr{m}, @expr{a}, and @expr{b} are called
24405 the @dfn{parameters} of the model.
24407 The @kbd{a F} command takes the data set to be fitted from the stack.
24408 By default, it expects the data in the form of a matrix. For example,
24409 for a linear or polynomial fit, this would be a
24410 @texline @math{2\times N}
24412 matrix where the first row is a list of @expr{x} values and the second
24413 row has the corresponding @expr{y} values. For the multilinear fit
24414 shown above, the matrix would have four rows (@expr{x_1}, @expr{x_2},
24415 @expr{x_3}, and @expr{y}, respectively).
24417 If you happen to have an
24418 @texline @math{N\times2}
24420 matrix instead of a
24421 @texline @math{2\times N}
24423 matrix, just press @kbd{v t} first to transpose the matrix.
24425 After you type @kbd{a F}, Calc prompts you to select a model. For a
24426 linear fit, press the digit @kbd{1}.
24428 Calc then prompts for you to name the variables. By default it chooses
24429 high letters like @expr{x} and @expr{y} for independent variables and
24430 low letters like @expr{a} and @expr{b} for parameters. (The dependent
24431 variable doesn't need a name.) The two kinds of variables are separated
24432 by a semicolon. Since you generally care more about the names of the
24433 independent variables than of the parameters, Calc also allows you to
24434 name only those and let the parameters use default names.
24436 For example, suppose the data matrix
24441 [ [ 1, 2, 3, 4, 5 ]
24442 [ 5, 7, 9, 11, 13 ] ]
24448 $$ \pmatrix{ 1 & 2 & 3 & 4 & 5 \cr
24449 5 & 7 & 9 & 11 & 13 }
24455 is on the stack and we wish to do a simple linear fit. Type
24456 @kbd{a F}, then @kbd{1} for the model, then @key{RET} to use
24457 the default names. The result will be the formula @expr{3. + 2. x}
24458 on the stack. Calc has created the model expression @kbd{a + b x},
24459 then found the optimal values of @expr{a} and @expr{b} to fit the
24460 data. (In this case, it was able to find an exact fit.) Calc then
24461 substituted those values for @expr{a} and @expr{b} in the model
24464 The @kbd{a F} command puts two entries in the trail. One is, as
24465 always, a copy of the result that went to the stack; the other is
24466 a vector of the actual parameter values, written as equations:
24467 @expr{[a = 3, b = 2]}, in case you'd rather read them in a list
24468 than pick them out of the formula. (You can type @kbd{t y}
24469 to move this vector to the stack; see @ref{Trail Commands}.
24471 Specifying a different independent variable name will affect the
24472 resulting formula: @kbd{a F 1 k @key{RET}} produces @kbd{3 + 2 k}.
24473 Changing the parameter names (say, @kbd{a F 1 k;b,m @key{RET}}) will affect
24474 the equations that go into the trail.
24480 To see what happens when the fit is not exact, we could change
24481 the number 13 in the data matrix to 14 and try the fit again.
24488 Evaluating this formula, say with @kbd{v x 5 @key{RET} @key{TAB} V M $ @key{RET}}, shows
24489 a reasonably close match to the y-values in the data.
24492 [4.8, 7., 9.2, 11.4, 13.6]
24495 Since there is no line which passes through all the @var{n} data points,
24496 Calc has chosen a line that best approximates the data points using
24497 the method of least squares. The idea is to define the @dfn{chi-square}
24502 chi^2 = sum((y_i - (a + b x_i))^2, i, 1, N)
24507 $$ \chi^2 = \sum_{i=1}^N (y_i - (a + b x_i))^2 $$
24512 which is clearly zero if @expr{a + b x} exactly fits all data points,
24513 and increases as various @expr{a + b x_i} values fail to match the
24514 corresponding @expr{y_i} values. There are several reasons why the
24515 summand is squared, one of them being to ensure that
24516 @texline @math{\chi^2 \ge 0}.
24517 @infoline @expr{chi^2 >= 0}.
24518 Least-squares fitting simply chooses the values of @expr{a} and @expr{b}
24519 for which the error
24520 @texline @math{\chi^2}
24521 @infoline @expr{chi^2}
24522 is as small as possible.
24524 Other kinds of models do the same thing but with a different model
24525 formula in place of @expr{a + b x_i}.
24531 A numeric prefix argument causes the @kbd{a F} command to take the
24532 data in some other form than one big matrix. A positive argument @var{n}
24533 will take @var{N} items from the stack, corresponding to the @var{n} rows
24534 of a data matrix. In the linear case, @var{n} must be 2 since there
24535 is always one independent variable and one dependent variable.
24537 A prefix of zero or plain @kbd{C-u} is a compromise; Calc takes two
24538 items from the stack, an @var{n}-row matrix of @expr{x} values, and a
24539 vector of @expr{y} values. If there is only one independent variable,
24540 the @expr{x} values can be either a one-row matrix or a plain vector,
24541 in which case the @kbd{C-u} prefix is the same as a @w{@kbd{C-u 2}} prefix.
24543 @node Polynomial and Multilinear Fits, Error Estimates for Fits, Linear Fits, Curve Fitting
24544 @subsection Polynomial and Multilinear Fits
24547 To fit the data to higher-order polynomials, just type one of the
24548 digits @kbd{2} through @kbd{9} when prompted for a model. For example,
24549 we could fit the original data matrix from the previous section
24550 (with 13, not 14) to a parabola instead of a line by typing
24551 @kbd{a F 2 @key{RET}}.
24554 2.00000000001 x - 1.5e-12 x^2 + 2.99999999999
24557 Note that since the constant and linear terms are enough to fit the
24558 data exactly, it's no surprise that Calc chose a tiny contribution
24559 for @expr{x^2}. (The fact that it's not exactly zero is due only
24560 to roundoff error. Since our data are exact integers, we could get
24561 an exact answer by typing @kbd{m f} first to get Fraction mode.
24562 Then the @expr{x^2} term would vanish altogether. Usually, though,
24563 the data being fitted will be approximate floats so Fraction mode
24566 Doing the @kbd{a F 2} fit on the data set with 14 instead of 13
24567 gives a much larger @expr{x^2} contribution, as Calc bends the
24568 line slightly to improve the fit.
24571 0.142857142855 x^2 + 1.34285714287 x + 3.59999999998
24574 An important result from the theory of polynomial fitting is that it
24575 is always possible to fit @var{n} data points exactly using a polynomial
24576 of degree @mathit{@var{n}-1}, sometimes called an @dfn{interpolating polynomial}.
24577 Using the modified (14) data matrix, a model number of 4 gives
24578 a polynomial that exactly matches all five data points:
24581 0.04167 x^4 - 0.4167 x^3 + 1.458 x^2 - 0.08333 x + 4.
24584 The actual coefficients we get with a precision of 12, like
24585 @expr{0.0416666663588}, clearly suffer from loss of precision.
24586 It is a good idea to increase the working precision to several
24587 digits beyond what you need when you do a fitting operation.
24588 Or, if your data are exact, use Fraction mode to get exact
24591 You can type @kbd{i} instead of a digit at the model prompt to fit
24592 the data exactly to a polynomial. This just counts the number of
24593 columns of the data matrix to choose the degree of the polynomial
24596 Fitting data ``exactly'' to high-degree polynomials is not always
24597 a good idea, though. High-degree polynomials have a tendency to
24598 wiggle uncontrollably in between the fitting data points. Also,
24599 if the exact-fit polynomial is going to be used to interpolate or
24600 extrapolate the data, it is numerically better to use the @kbd{a p}
24601 command described below. @xref{Interpolation}.
24607 Another generalization of the linear model is to assume the
24608 @expr{y} values are a sum of linear contributions from several
24609 @expr{x} values. This is a @dfn{multilinear} fit, and it is also
24610 selected by the @kbd{1} digit key. (Calc decides whether the fit
24611 is linear or multilinear by counting the rows in the data matrix.)
24613 Given the data matrix,
24617 [ [ 1, 2, 3, 4, 5 ]
24619 [ 14.5, 15, 18.5, 22.5, 24 ] ]
24624 the command @kbd{a F 1 @key{RET}} will call the first row @expr{x} and the
24625 second row @expr{y}, and will fit the values in the third row to the
24626 model @expr{a + b x + c y}.
24632 Calc can do multilinear fits with any number of independent variables
24633 (i.e., with any number of data rows).
24639 Yet another variation is @dfn{homogeneous} linear models, in which
24640 the constant term is known to be zero. In the linear case, this
24641 means the model formula is simply @expr{a x}; in the multilinear
24642 case, the model might be @expr{a x + b y + c z}; and in the polynomial
24643 case, the model could be @expr{a x + b x^2 + c x^3}. You can get
24644 a homogeneous linear or multilinear model by pressing the letter
24645 @kbd{h} followed by a regular model key, like @kbd{1} or @kbd{2}.
24646 This will be indicated by an ``h'' in the minibuffer after the help
24649 It is certainly possible to have other constrained linear models,
24650 like @expr{2.3 + a x} or @expr{a - 4 x}. While there is no single
24651 key to select models like these, a later section shows how to enter
24652 any desired model by hand. In the first case, for example, you
24653 would enter @kbd{a F ' 2.3 + a x}.
24655 Another class of models that will work but must be entered by hand
24656 are multinomial fits, e.g., @expr{a + b x + c y + d x^2 + e y^2 + f x y}.
24658 @node Error Estimates for Fits, Standard Nonlinear Models, Polynomial and Multilinear Fits, Curve Fitting
24659 @subsection Error Estimates for Fits
24664 With the Hyperbolic flag, @kbd{H a F} [@code{efit}] performs the same
24665 fitting operation as @kbd{a F}, but reports the coefficients as error
24666 forms instead of plain numbers. Fitting our two data matrices (first
24667 with 13, then with 14) to a line with @kbd{H a F} gives the results,
24671 2.6 +/- 0.382970843103 + 2.2 +/- 0.115470053838 x
24674 In the first case the estimated errors are zero because the linear
24675 fit is perfect. In the second case, the errors are nonzero but
24676 moderately small, because the data are still very close to linear.
24678 It is also possible for the @emph{input} to a fitting operation to
24679 contain error forms. The data values must either all include errors
24680 or all be plain numbers. Error forms can go anywhere but generally
24681 go on the numbers in the last row of the data matrix. If the last
24682 row contains error forms
24683 @texline `@var{y_i}@w{ @tfn{+/-} }@math{\sigma_i}',
24684 @infoline `@var{y_i}@w{ @tfn{+/-} }@var{sigma_i}',
24686 @texline @math{\chi^2}
24687 @infoline @expr{chi^2}
24692 chi^2 = sum(((y_i - (a + b x_i)) / sigma_i)^2, i, 1, N)
24697 $$ \chi^2 = \sum_{i=1}^N \left(y_i - (a + b x_i) \over \sigma_i\right)^2 $$
24702 so that data points with larger error estimates contribute less to
24703 the fitting operation.
24705 If there are error forms on other rows of the data matrix, all the
24706 errors for a given data point are combined; the square root of the
24707 sum of the squares of the errors forms the
24708 @texline @math{\sigma_i}
24709 @infoline @expr{sigma_i}
24710 used for the data point.
24712 Both @kbd{a F} and @kbd{H a F} can accept error forms in the input
24713 matrix, although if you are concerned about error analysis you will
24714 probably use @kbd{H a F} so that the output also contains error
24717 If the input contains error forms but all the
24718 @texline @math{\sigma_i}
24719 @infoline @expr{sigma_i}
24720 values are the same, it is easy to see that the resulting fitted model
24721 will be the same as if the input did not have error forms at all
24722 @texline (@math{\chi^2}
24723 @infoline (@expr{chi^2}
24724 is simply scaled uniformly by
24725 @texline @math{1 / \sigma^2},
24726 @infoline @expr{1 / sigma^2},
24727 which doesn't affect where it has a minimum). But there @emph{will} be
24728 a difference in the estimated errors of the coefficients reported by
24731 Consult any text on statistical modeling of data for a discussion
24732 of where these error estimates come from and how they should be
24741 With the Inverse flag, @kbd{I a F} [@code{xfit}] produces even more
24742 information. The result is a vector of six items:
24746 The model formula with error forms for its coefficients or
24747 parameters. This is the result that @kbd{H a F} would have
24751 A vector of ``raw'' parameter values for the model. These are the
24752 polynomial coefficients or other parameters as plain numbers, in the
24753 same order as the parameters appeared in the final prompt of the
24754 @kbd{I a F} command. For polynomials of degree @expr{d}, this vector
24755 will have length @expr{M = d+1} with the constant term first.
24758 The covariance matrix @expr{C} computed from the fit. This is
24759 an @var{m}x@var{m} symmetric matrix; the diagonal elements
24760 @texline @math{C_{jj}}
24761 @infoline @expr{C_j_j}
24763 @texline @math{\sigma_j^2}
24764 @infoline @expr{sigma_j^2}
24765 of the parameters. The other elements are covariances
24766 @texline @math{\sigma_{ij}^2}
24767 @infoline @expr{sigma_i_j^2}
24768 that describe the correlation between pairs of parameters. (A related
24769 set of numbers, the @dfn{linear correlation coefficients}
24770 @texline @math{r_{ij}},
24771 @infoline @expr{r_i_j},
24773 @texline @math{\sigma_{ij}^2 / \sigma_i \, \sigma_j}.)
24774 @infoline @expr{sigma_i_j^2 / sigma_i sigma_j}.)
24777 A vector of @expr{M} ``parameter filter'' functions whose
24778 meanings are described below. If no filters are necessary this
24779 will instead be an empty vector; this is always the case for the
24780 polynomial and multilinear fits described so far.
24784 @texline @math{\chi^2}
24785 @infoline @expr{chi^2}
24786 for the fit, calculated by the formulas shown above. This gives a
24787 measure of the quality of the fit; statisticians consider
24788 @texline @math{\chi^2 \approx N - M}
24789 @infoline @expr{chi^2 = N - M}
24790 to indicate a moderately good fit (where again @expr{N} is the number of
24791 data points and @expr{M} is the number of parameters).
24794 A measure of goodness of fit expressed as a probability @expr{Q}.
24795 This is computed from the @code{utpc} probability distribution
24797 @texline @math{\chi^2}
24798 @infoline @expr{chi^2}
24799 with @expr{N - M} degrees of freedom. A
24800 value of 0.5 implies a good fit; some texts recommend that often
24801 @expr{Q = 0.1} or even 0.001 can signify an acceptable fit. In
24803 @texline @math{\chi^2}
24804 @infoline @expr{chi^2}
24805 statistics assume the errors in your inputs
24806 follow a normal (Gaussian) distribution; if they don't, you may
24807 have to accept smaller values of @expr{Q}.
24809 The @expr{Q} value is computed only if the input included error
24810 estimates. Otherwise, Calc will report the symbol @code{nan}
24811 for @expr{Q}. The reason is that in this case the
24812 @texline @math{\chi^2}
24813 @infoline @expr{chi^2}
24814 value has effectively been used to estimate the original errors
24815 in the input, and thus there is no redundant information left
24816 over to use for a confidence test.
24819 @node Standard Nonlinear Models, Curve Fitting Details, Error Estimates for Fits, Curve Fitting
24820 @subsection Standard Nonlinear Models
24823 The @kbd{a F} command also accepts other kinds of models besides
24824 lines and polynomials. Some common models have quick single-key
24825 abbreviations; others must be entered by hand as algebraic formulas.
24827 Here is a complete list of the standard models recognized by @kbd{a F}:
24831 Linear or multilinear. @mathit{a + b x + c y + d z}.
24833 Polynomials. @mathit{a + b x + c x^2 + d x^3}.
24835 Exponential. @mathit{a} @tfn{exp}@mathit{(b x)} @tfn{exp}@mathit{(c y)}.
24837 Base-10 exponential. @mathit{a} @tfn{10^}@mathit{(b x)} @tfn{10^}@mathit{(c y)}.
24839 Exponential (alternate notation). @tfn{exp}@mathit{(a + b x + c y)}.
24841 Base-10 exponential (alternate). @tfn{10^}@mathit{(a + b x + c y)}.
24843 Logarithmic. @mathit{a + b} @tfn{ln}@mathit{(x) + c} @tfn{ln}@mathit{(y)}.
24845 Base-10 logarithmic. @mathit{a + b} @tfn{log10}@mathit{(x) + c} @tfn{log10}@mathit{(y)}.
24847 General exponential. @mathit{a b^x c^y}.
24849 Power law. @mathit{a x^b y^c}.
24851 Quadratic. @mathit{a + b (x-c)^2 + d (x-e)^2}.
24854 @texline @math{{a \over b \sqrt{2 \pi}} \exp\left( -{1 \over 2} \left( x - c \over b \right)^2 \right)}.
24855 @infoline @mathit{(a / b sqrt(2 pi)) exp(-0.5*((x-c)/b)^2)}.
24857 Logistic @emph{s} curve.
24858 @texline @math{a/(1+e^{b(x-c)})}.
24859 @infoline @mathit{a/(1 + exp(b (x - c)))}.
24861 Logistic bell curve.
24862 @texline @math{ae^{b(x-c)}/(1+e^{b(x-c)})^2}.
24863 @infoline @mathit{a exp(b (x - c))/(1 + exp(b (x - c)))^2}.
24865 Hubbert linearization.
24866 @texline @math{{y \over x} = a(1-x/b)}.
24867 @infoline @mathit{(y/x) = a (1 - x/b)}.
24870 All of these models are used in the usual way; just press the appropriate
24871 letter at the model prompt, and choose variable names if you wish. The
24872 result will be a formula as shown in the above table, with the best-fit
24873 values of the parameters substituted. (You may find it easier to read
24874 the parameter values from the vector that is placed in the trail.)
24876 All models except Gaussian, logistics, Hubbert and polynomials can
24877 generalize as shown to any number of independent variables. Also, all
24878 the built-in models except for the logistic and Hubbert curves have an
24879 additive or multiplicative parameter shown as @expr{a} in the above table
24880 which can be replaced by zero or one, as appropriate, by typing @kbd{h}
24881 before the model key.
24883 Note that many of these models are essentially equivalent, but express
24884 the parameters slightly differently. For example, @expr{a b^x} and
24885 the other two exponential models are all algebraic rearrangements of
24886 each other. Also, the ``quadratic'' model is just a degree-2 polynomial
24887 with the parameters expressed differently. Use whichever form best
24888 matches the problem.
24890 The HP-28/48 calculators support four different models for curve
24891 fitting, called @code{LIN}, @code{LOG}, @code{EXP}, and @code{PWR}.
24892 These correspond to Calc models @samp{a + b x}, @samp{a + b ln(x)},
24893 @samp{a exp(b x)}, and @samp{a x^b}, respectively. In each case,
24894 @expr{a} is what the HP-48 identifies as the ``intercept,'' and
24895 @expr{b} is what it calls the ``slope.''
24901 If the model you want doesn't appear on this list, press @kbd{'}
24902 (the apostrophe key) at the model prompt to enter any algebraic
24903 formula, such as @kbd{m x - b}, as the model. (Not all models
24904 will work, though---see the next section for details.)
24906 The model can also be an equation like @expr{y = m x + b}.
24907 In this case, Calc thinks of all the rows of the data matrix on
24908 equal terms; this model effectively has two parameters
24909 (@expr{m} and @expr{b}) and two independent variables (@expr{x}
24910 and @expr{y}), with no ``dependent'' variables. Model equations
24911 do not need to take this @expr{y =} form. For example, the
24912 implicit line equation @expr{a x + b y = 1} works fine as a
24915 When you enter a model, Calc makes an alphabetical list of all
24916 the variables that appear in the model. These are used for the
24917 default parameters, independent variables, and dependent variable
24918 (in that order). If you enter a plain formula (not an equation),
24919 Calc assumes the dependent variable does not appear in the formula
24920 and thus does not need a name.
24922 For example, if the model formula has the variables @expr{a,mu,sigma,t,x},
24923 and the data matrix has three rows (meaning two independent variables),
24924 Calc will use @expr{a,mu,sigma} as the default parameters, and the
24925 data rows will be named @expr{t} and @expr{x}, respectively. If you
24926 enter an equation instead of a plain formula, Calc will use @expr{a,mu}
24927 as the parameters, and @expr{sigma,t,x} as the three independent
24930 You can, of course, override these choices by entering something
24931 different at the prompt. If you leave some variables out of the list,
24932 those variables must have stored values and those stored values will
24933 be used as constants in the model. (Stored values for the parameters
24934 and independent variables are ignored by the @kbd{a F} command.)
24935 If you list only independent variables, all the remaining variables
24936 in the model formula will become parameters.
24938 If there are @kbd{$} signs in the model you type, they will stand
24939 for parameters and all other variables (in alphabetical order)
24940 will be independent. Use @kbd{$} for one parameter, @kbd{$$} for
24941 another, and so on. Thus @kbd{$ x + $$} is another way to describe
24944 If you type a @kbd{$} instead of @kbd{'} at the model prompt itself,
24945 Calc will take the model formula from the stack. (The data must then
24946 appear at the second stack level.) The same conventions are used to
24947 choose which variables in the formula are independent by default and
24948 which are parameters.
24950 Models taken from the stack can also be expressed as vectors of
24951 two or three elements, @expr{[@var{model}, @var{vars}]} or
24952 @expr{[@var{model}, @var{vars}, @var{params}]}. Each of @var{vars}
24953 and @var{params} may be either a variable or a vector of variables.
24954 (If @var{params} is omitted, all variables in @var{model} except
24955 those listed as @var{vars} are parameters.)
24957 When you enter a model manually with @kbd{'}, Calc puts a 3-vector
24958 describing the model in the trail so you can get it back if you wish.
24966 Finally, you can store a model in one of the Calc variables
24967 @code{Model1} or @code{Model2}, then use this model by typing
24968 @kbd{a F u} or @kbd{a F U} (respectively). The value stored in
24969 the variable can be any of the formats that @kbd{a F $} would
24970 accept for a model on the stack.
24976 Calc uses the principal values of inverse functions like @code{ln}
24977 and @code{arcsin} when doing fits. For example, when you enter
24978 the model @samp{y = sin(a t + b)} Calc actually uses the easier
24979 form @samp{arcsin(y) = a t + b}. The @code{arcsin} function always
24980 returns results in the range from @mathit{-90} to 90 degrees (or the
24981 equivalent range in radians). Suppose you had data that you
24982 believed to represent roughly three oscillations of a sine wave,
24983 so that the argument of the sine might go from zero to
24984 @texline @math{3\times360}
24985 @infoline @mathit{3*360}
24987 The above model would appear to be a good way to determine the
24988 true frequency and phase of the sine wave, but in practice it
24989 would fail utterly. The righthand side of the actual model
24990 @samp{arcsin(y) = a t + b} will grow smoothly with @expr{t}, but
24991 the lefthand side will bounce back and forth between @mathit{-90} and 90.
24992 No values of @expr{a} and @expr{b} can make the two sides match,
24993 even approximately.
24995 There is no good solution to this problem at present. You could
24996 restrict your data to small enough ranges so that the above problem
24997 doesn't occur (i.e., not straddling any peaks in the sine wave).
24998 Or, in this case, you could use a totally different method such as
24999 Fourier analysis, which is beyond the scope of the @kbd{a F} command.
25000 (Unfortunately, Calc does not currently have any facilities for
25001 taking Fourier and related transforms.)
25003 @node Curve Fitting Details, Interpolation, Standard Nonlinear Models, Curve Fitting
25004 @subsection Curve Fitting Details
25007 Calc's internal least-squares fitter can only handle multilinear
25008 models. More precisely, it can handle any model of the form
25009 @expr{a f(x,y,z) + b g(x,y,z) + c h(x,y,z)}, where @expr{a,b,c}
25010 are the parameters and @expr{x,y,z} are the independent variables
25011 (of course there can be any number of each, not just three).
25013 In a simple multilinear or polynomial fit, it is easy to see how
25014 to convert the model into this form. For example, if the model
25015 is @expr{a + b x + c x^2}, then @expr{f(x) = 1}, @expr{g(x) = x},
25016 and @expr{h(x) = x^2} are suitable functions.
25018 For most other models, Calc uses a variety of algebraic manipulations
25019 to try to put the problem into the form
25022 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)
25026 where @expr{Y,A,B,C,F,G,H} are arbitrary functions. It computes
25027 @expr{Y}, @expr{F}, @expr{G}, and @expr{H} for all the data points,
25028 does a standard linear fit to find the values of @expr{A}, @expr{B},
25029 and @expr{C}, then uses the equation solver to solve for @expr{a,b,c}
25030 in terms of @expr{A,B,C}.
25032 A remarkable number of models can be cast into this general form.
25033 We'll look at two examples here to see how it works. The power-law
25034 model @expr{y = a x^b} with two independent variables and two parameters
25035 can be rewritten as follows:
25040 y = exp(ln(a) + b ln(x))
25041 ln(y) = ln(a) + b ln(x)
25045 which matches the desired form with
25046 @texline @math{Y = \ln(y)},
25047 @infoline @expr{Y = ln(y)},
25048 @texline @math{A = \ln(a)},
25049 @infoline @expr{A = ln(a)},
25050 @expr{F = 1}, @expr{B = b}, and
25051 @texline @math{G = \ln(x)}.
25052 @infoline @expr{G = ln(x)}.
25053 Calc thus computes the logarithms of your @expr{y} and @expr{x} values,
25054 does a linear fit for @expr{A} and @expr{B}, then solves to get
25055 @texline @math{a = \exp(A)}
25056 @infoline @expr{a = exp(A)}
25059 Another interesting example is the ``quadratic'' model, which can
25060 be handled by expanding according to the distributive law.
25063 y = a + b*(x - c)^2
25064 y = a + b c^2 - 2 b c x + b x^2
25068 which matches with @expr{Y = y}, @expr{A = a + b c^2}, @expr{F = 1},
25069 @expr{B = -2 b c}, @expr{G = x} (the @mathit{-2} factor could just as easily
25070 have been put into @expr{G} instead of @expr{B}), @expr{C = b}, and
25073 The Gaussian model looks quite complicated, but a closer examination
25074 shows that it's actually similar to the quadratic model but with an
25075 exponential that can be brought to the top and moved into @expr{Y}.
25077 The logistic models cannot be put into general linear form. For these
25078 models, and the Hubbert linearization, Calc computes a rough
25079 approximation for the parameters, then uses the Levenberg-Marquardt
25080 iterative method to refine the approximations.
25082 Another model that cannot be put into general linear
25083 form is a Gaussian with a constant background added on, i.e.,
25084 @expr{d} + the regular Gaussian formula. If you have a model like
25085 this, your best bet is to replace enough of your parameters with
25086 constants to make the model linearizable, then adjust the constants
25087 manually by doing a series of fits. You can compare the fits by
25088 graphing them, by examining the goodness-of-fit measures returned by
25089 @kbd{I a F}, or by some other method suitable to your application.
25090 Note that some models can be linearized in several ways. The
25091 Gaussian-plus-@var{d} model can be linearized by setting @expr{d}
25092 (the background) to a constant, or by setting @expr{b} (the standard
25093 deviation) and @expr{c} (the mean) to constants.
25095 To fit a model with constants substituted for some parameters, just
25096 store suitable values in those parameter variables, then omit them
25097 from the list of parameters when you answer the variables prompt.
25103 A last desperate step would be to use the general-purpose
25104 @code{minimize} function rather than @code{fit}. After all, both
25105 functions solve the problem of minimizing an expression (the
25106 @texline @math{\chi^2}
25107 @infoline @expr{chi^2}
25108 sum) by adjusting certain parameters in the expression. The @kbd{a F}
25109 command is able to use a vastly more efficient algorithm due to its
25110 special knowledge about linear chi-square sums, but the @kbd{a N}
25111 command can do the same thing by brute force.
25113 A compromise would be to pick out a few parameters without which the
25114 fit is linearizable, and use @code{minimize} on a call to @code{fit}
25115 which efficiently takes care of the rest of the parameters. The thing
25116 to be minimized would be the value of
25117 @texline @math{\chi^2}
25118 @infoline @expr{chi^2}
25119 returned as the fifth result of the @code{xfit} function:
25122 minimize(xfit(gaus(a,b,c,d,x), x, [a,b,c], data)_5, d, guess)
25126 where @code{gaus} represents the Gaussian model with background,
25127 @code{data} represents the data matrix, and @code{guess} represents
25128 the initial guess for @expr{d} that @code{minimize} requires.
25129 This operation will only be, shall we say, extraordinarily slow
25130 rather than astronomically slow (as would be the case if @code{minimize}
25131 were used by itself to solve the problem).
25137 The @kbd{I a F} [@code{xfit}] command is somewhat trickier when
25138 nonlinear models are used. The second item in the result is the
25139 vector of ``raw'' parameters @expr{A}, @expr{B}, @expr{C}. The
25140 covariance matrix is written in terms of those raw parameters.
25141 The fifth item is a vector of @dfn{filter} expressions. This
25142 is the empty vector @samp{[]} if the raw parameters were the same
25143 as the requested parameters, i.e., if @expr{A = a}, @expr{B = b},
25144 and so on (which is always true if the model is already linear
25145 in the parameters as written, e.g., for polynomial fits). If the
25146 parameters had to be rearranged, the fifth item is instead a vector
25147 of one formula per parameter in the original model. The raw
25148 parameters are expressed in these ``filter'' formulas as
25149 @samp{fitdummy(1)} for @expr{A}, @samp{fitdummy(2)} for @expr{B},
25152 When Calc needs to modify the model to return the result, it replaces
25153 @samp{fitdummy(1)} in all the filters with the first item in the raw
25154 parameters list, and so on for the other raw parameters, then
25155 evaluates the resulting filter formulas to get the actual parameter
25156 values to be substituted into the original model. In the case of
25157 @kbd{H a F} and @kbd{I a F} where the parameters must be error forms,
25158 Calc uses the square roots of the diagonal entries of the covariance
25159 matrix as error values for the raw parameters, then lets Calc's
25160 standard error-form arithmetic take it from there.
25162 If you use @kbd{I a F} with a nonlinear model, be sure to remember
25163 that the covariance matrix is in terms of the raw parameters,
25164 @emph{not} the actual requested parameters. It's up to you to
25165 figure out how to interpret the covariances in the presence of
25166 nontrivial filter functions.
25168 Things are also complicated when the input contains error forms.
25169 Suppose there are three independent and dependent variables, @expr{x},
25170 @expr{y}, and @expr{z}, one or more of which are error forms in the
25171 data. Calc combines all the error values by taking the square root
25172 of the sum of the squares of the errors. It then changes @expr{x}
25173 and @expr{y} to be plain numbers, and makes @expr{z} into an error
25174 form with this combined error. The @expr{Y(x,y,z)} part of the
25175 linearized model is evaluated, and the result should be an error
25176 form. The error part of that result is used for
25177 @texline @math{\sigma_i}
25178 @infoline @expr{sigma_i}
25179 for the data point. If for some reason @expr{Y(x,y,z)} does not return
25180 an error form, the combined error from @expr{z} is used directly for
25181 @texline @math{\sigma_i}.
25182 @infoline @expr{sigma_i}.
25183 Finally, @expr{z} is also stripped of its error
25184 for use in computing @expr{F(x,y,z)}, @expr{G(x,y,z)} and so on;
25185 the righthand side of the linearized model is computed in regular
25186 arithmetic with no error forms.
25188 (While these rules may seem complicated, they are designed to do
25189 the most reasonable thing in the typical case that @expr{Y(x,y,z)}
25190 depends only on the dependent variable @expr{z}, and in fact is
25191 often simply equal to @expr{z}. For common cases like polynomials
25192 and multilinear models, the combined error is simply used as the
25193 @texline @math{\sigma}
25194 @infoline @expr{sigma}
25195 for the data point with no further ado.)
25202 It may be the case that the model you wish to use is linearizable,
25203 but Calc's built-in rules are unable to figure it out. Calc uses
25204 its algebraic rewrite mechanism to linearize a model. The rewrite
25205 rules are kept in the variable @code{FitRules}. You can edit this
25206 variable using the @kbd{s e FitRules} command; in fact, there is
25207 a special @kbd{s F} command just for editing @code{FitRules}.
25208 @xref{Operations on Variables}.
25210 @xref{Rewrite Rules}, for a discussion of rewrite rules.
25244 Calc uses @code{FitRules} as follows. First, it converts the model
25245 to an equation if necessary and encloses the model equation in a
25246 call to the function @code{fitmodel} (which is not actually a defined
25247 function in Calc; it is only used as a placeholder by the rewrite rules).
25248 Parameter variables are renamed to function calls @samp{fitparam(1)},
25249 @samp{fitparam(2)}, and so on, and independent variables are renamed
25250 to @samp{fitvar(1)}, @samp{fitvar(2)}, etc. The dependent variable
25251 is the highest-numbered @code{fitvar}. For example, the power law
25252 model @expr{a x^b} is converted to @expr{y = a x^b}, then to
25256 fitmodel(fitvar(2) = fitparam(1) fitvar(1)^fitparam(2))
25260 Calc then applies the rewrites as if by @samp{C-u 0 a r FitRules}.
25261 (The zero prefix means that rewriting should continue until no further
25262 changes are possible.)
25264 When rewriting is complete, the @code{fitmodel} call should have
25265 been replaced by a @code{fitsystem} call that looks like this:
25268 fitsystem(@var{Y}, @var{FGH}, @var{abc})
25272 where @var{Y} is a formula that describes the function @expr{Y(x,y,z)},
25273 @var{FGH} is the vector of formulas @expr{[F(x,y,z), G(x,y,z), H(x,y,z)]},
25274 and @var{abc} is the vector of parameter filters which refer to the
25275 raw parameters as @samp{fitdummy(1)} for @expr{A}, @samp{fitdummy(2)}
25276 for @expr{B}, etc. While the number of raw parameters (the length of
25277 the @var{FGH} vector) is usually the same as the number of original
25278 parameters (the length of the @var{abc} vector), this is not required.
25280 The power law model eventually boils down to
25284 fitsystem(ln(fitvar(2)),
25285 [1, ln(fitvar(1))],
25286 [exp(fitdummy(1)), fitdummy(2)])
25290 The actual implementation of @code{FitRules} is complicated; it
25291 proceeds in four phases. First, common rearrangements are done
25292 to try to bring linear terms together and to isolate functions like
25293 @code{exp} and @code{ln} either all the way ``out'' (so that they
25294 can be put into @var{Y}) or all the way ``in'' (so that they can
25295 be put into @var{abc} or @var{FGH}). In particular, all
25296 non-constant powers are converted to logs-and-exponentials form,
25297 and the distributive law is used to expand products of sums.
25298 Quotients are rewritten to use the @samp{fitinv} function, where
25299 @samp{fitinv(x)} represents @expr{1/x} while the @code{FitRules}
25300 are operating. (The use of @code{fitinv} makes recognition of
25301 linear-looking forms easier.) If you modify @code{FitRules}, you
25302 will probably only need to modify the rules for this phase.
25304 Phase two, whose rules can actually also apply during phases one
25305 and three, first rewrites @code{fitmodel} to a two-argument
25306 form @samp{fitmodel(@var{Y}, @var{model})}, where @var{Y} is
25307 initially zero and @var{model} has been changed from @expr{a=b}
25308 to @expr{a-b} form. It then tries to peel off invertible functions
25309 from the outside of @var{model} and put them into @var{Y} instead,
25310 calling the equation solver to invert the functions. Finally, when
25311 this is no longer possible, the @code{fitmodel} is changed to a
25312 four-argument @code{fitsystem}, where the fourth argument is
25313 @var{model} and the @var{FGH} and @var{abc} vectors are initially
25314 empty. (The last vector is really @var{ABC}, corresponding to
25315 raw parameters, for now.)
25317 Phase three converts a sum of items in the @var{model} to a sum
25318 of @samp{fitpart(@var{a}, @var{b}, @var{c})} terms which represent
25319 terms @samp{@var{a}*@var{b}*@var{c}} of the sum, where @var{a}
25320 is all factors that do not involve any variables, @var{b} is all
25321 factors that involve only parameters, and @var{c} is the factors
25322 that involve only independent variables. (If this decomposition
25323 is not possible, the rule set will not complete and Calc will
25324 complain that the model is too complex.) Then @code{fitpart}s
25325 with equal @var{b} or @var{c} components are merged back together
25326 using the distributive law in order to minimize the number of
25327 raw parameters needed.
25329 Phase four moves the @code{fitpart} terms into the @var{FGH} and
25330 @var{ABC} vectors. Also, some of the algebraic expansions that
25331 were done in phase 1 are undone now to make the formulas more
25332 computationally efficient. Finally, it calls the solver one more
25333 time to convert the @var{ABC} vector to an @var{abc} vector, and
25334 removes the fourth @var{model} argument (which by now will be zero)
25335 to obtain the three-argument @code{fitsystem} that the linear
25336 least-squares solver wants to see.
25342 @mindex hasfit@idots
25344 @tindex hasfitparams
25352 Two functions which are useful in connection with @code{FitRules}
25353 are @samp{hasfitparams(x)} and @samp{hasfitvars(x)}, which check
25354 whether @expr{x} refers to any parameters or independent variables,
25355 respectively. Specifically, these functions return ``true'' if the
25356 argument contains any @code{fitparam} (or @code{fitvar}) function
25357 calls, and ``false'' otherwise. (Recall that ``true'' means a
25358 nonzero number, and ``false'' means zero. The actual nonzero number
25359 returned is the largest @var{n} from all the @samp{fitparam(@var{n})}s
25360 or @samp{fitvar(@var{n})}s, respectively, that appear in the formula.)
25366 The @code{fit} function in algebraic notation normally takes four
25367 arguments, @samp{fit(@var{model}, @var{vars}, @var{params}, @var{data})},
25368 where @var{model} is the model formula as it would be typed after
25369 @kbd{a F '}, @var{vars} is the independent variable or a vector of
25370 independent variables, @var{params} likewise gives the parameter(s),
25371 and @var{data} is the data matrix. Note that the length of @var{vars}
25372 must be equal to the number of rows in @var{data} if @var{model} is
25373 an equation, or one less than the number of rows if @var{model} is
25374 a plain formula. (Actually, a name for the dependent variable is
25375 allowed but will be ignored in the plain-formula case.)
25377 If @var{params} is omitted, the parameters are all variables in
25378 @var{model} except those that appear in @var{vars}. If @var{vars}
25379 is also omitted, Calc sorts all the variables that appear in
25380 @var{model} alphabetically and uses the higher ones for @var{vars}
25381 and the lower ones for @var{params}.
25383 Alternatively, @samp{fit(@var{modelvec}, @var{data})} is allowed
25384 where @var{modelvec} is a 2- or 3-vector describing the model
25385 and variables, as discussed previously.
25387 If Calc is unable to do the fit, the @code{fit} function is left
25388 in symbolic form, ordinarily with an explanatory message. The
25389 message will be ``Model expression is too complex'' if the
25390 linearizer was unable to put the model into the required form.
25392 The @code{efit} (corresponding to @kbd{H a F}) and @code{xfit}
25393 (for @kbd{I a F}) functions are completely analogous.
25395 @node Interpolation, , Curve Fitting Details, Curve Fitting
25396 @subsection Polynomial Interpolation
25399 @pindex calc-poly-interp
25401 The @kbd{a p} (@code{calc-poly-interp}) [@code{polint}] command does
25402 a polynomial interpolation at a particular @expr{x} value. It takes
25403 two arguments from the stack: A data matrix of the sort used by
25404 @kbd{a F}, and a single number which represents the desired @expr{x}
25405 value. Calc effectively does an exact polynomial fit as if by @kbd{a F i},
25406 then substitutes the @expr{x} value into the result in order to get an
25407 approximate @expr{y} value based on the fit. (Calc does not actually
25408 use @kbd{a F i}, however; it uses a direct method which is both more
25409 efficient and more numerically stable.)
25411 The result of @kbd{a p} is actually a vector of two values: The @expr{y}
25412 value approximation, and an error measure @expr{dy} that reflects Calc's
25413 estimation of the probable error of the approximation at that value of
25414 @expr{x}. If the input @expr{x} is equal to any of the @expr{x} values
25415 in the data matrix, the output @expr{y} will be the corresponding @expr{y}
25416 value from the matrix, and the output @expr{dy} will be exactly zero.
25418 A prefix argument of 2 causes @kbd{a p} to take separate x- and
25419 y-vectors from the stack instead of one data matrix.
25421 If @expr{x} is a vector of numbers, @kbd{a p} will return a matrix of
25422 interpolated results for each of those @expr{x} values. (The matrix will
25423 have two columns, the @expr{y} values and the @expr{dy} values.)
25424 If @expr{x} is a formula instead of a number, the @code{polint} function
25425 remains in symbolic form; use the @kbd{a "} command to expand it out to
25426 a formula that describes the fit in symbolic terms.
25428 In all cases, the @kbd{a p} command leaves the data vectors or matrix
25429 on the stack. Only the @expr{x} value is replaced by the result.
25433 The @kbd{H a p} [@code{ratint}] command does a rational function
25434 interpolation. It is used exactly like @kbd{a p}, except that it
25435 uses as its model the quotient of two polynomials. If there are
25436 @expr{N} data points, the numerator and denominator polynomials will
25437 each have degree @expr{N/2} (if @expr{N} is odd, the denominator will
25438 have degree one higher than the numerator).
25440 Rational approximations have the advantage that they can accurately
25441 describe functions that have poles (points at which the function's value
25442 goes to infinity, so that the denominator polynomial of the approximation
25443 goes to zero). If @expr{x} corresponds to a pole of the fitted rational
25444 function, then the result will be a division by zero. If Infinite mode
25445 is enabled, the result will be @samp{[uinf, uinf]}.
25447 There is no way to get the actual coefficients of the rational function
25448 used by @kbd{H a p}. (The algorithm never generates these coefficients
25449 explicitly, and quotients of polynomials are beyond @w{@kbd{a F}}'s
25450 capabilities to fit.)
25452 @node Summations, Logical Operations, Curve Fitting, Algebra
25453 @section Summations
25456 @cindex Summation of a series
25458 @pindex calc-summation
25460 The @kbd{a +} (@code{calc-summation}) [@code{sum}] command computes
25461 the sum of a formula over a certain range of index values. The formula
25462 is taken from the top of the stack; the command prompts for the
25463 name of the summation index variable, the lower limit of the
25464 sum (any formula), and the upper limit of the sum. If you
25465 enter a blank line at any of these prompts, that prompt and
25466 any later ones are answered by reading additional elements from
25467 the stack. Thus, @kbd{' k^2 @key{RET} ' k @key{RET} 1 @key{RET} 5 @key{RET} a + @key{RET}}
25468 produces the result 55.
25470 $$ \sum_{k=1}^5 k^2 = 55 $$
25473 The choice of index variable is arbitrary, but it's best not to
25474 use a variable with a stored value. In particular, while
25475 @code{i} is often a favorite index variable, it should be avoided
25476 in Calc because @code{i} has the imaginary constant @expr{(0, 1)}
25477 as a value. If you pressed @kbd{=} on a sum over @code{i}, it would
25478 be changed to a nonsensical sum over the ``variable'' @expr{(0, 1)}!
25479 If you really want to use @code{i} as an index variable, use
25480 @w{@kbd{s u i @key{RET}}} first to ``unstore'' this variable.
25481 (@xref{Storing Variables}.)
25483 A numeric prefix argument steps the index by that amount rather
25484 than by one. Thus @kbd{' a_k @key{RET} C-u -2 a + k @key{RET} 10 @key{RET} 0 @key{RET}}
25485 yields @samp{a_10 + a_8 + a_6 + a_4 + a_2 + a_0}. A prefix
25486 argument of plain @kbd{C-u} causes @kbd{a +} to prompt for the
25487 step value, in which case you can enter any formula or enter
25488 a blank line to take the step value from the stack. With the
25489 @kbd{C-u} prefix, @kbd{a +} can take up to five arguments from
25490 the stack: The formula, the variable, the lower limit, the
25491 upper limit, and (at the top of the stack), the step value.
25493 Calc knows how to do certain sums in closed form. For example,
25494 @samp{sum(6 k^2, k, 1, n) = @w{2 n^3} + 3 n^2 + n}. In particular,
25495 this is possible if the formula being summed is polynomial or
25496 exponential in the index variable. Sums of logarithms are
25497 transformed into logarithms of products. Sums of trigonometric
25498 and hyperbolic functions are transformed to sums of exponentials
25499 and then done in closed form. Also, of course, sums in which the
25500 lower and upper limits are both numbers can always be evaluated
25501 just by grinding them out, although Calc will use closed forms
25502 whenever it can for the sake of efficiency.
25504 The notation for sums in algebraic formulas is
25505 @samp{sum(@var{expr}, @var{var}, @var{low}, @var{high}, @var{step})}.
25506 If @var{step} is omitted, it defaults to one. If @var{high} is
25507 omitted, @var{low} is actually the upper limit and the lower limit
25508 is one. If @var{low} is also omitted, the limits are @samp{-inf}
25509 and @samp{inf}, respectively.
25511 Infinite sums can sometimes be evaluated: @samp{sum(.5^k, k, 1, inf)}
25512 returns @expr{1}. This is done by evaluating the sum in closed
25513 form (to @samp{1. - 0.5^n} in this case), then evaluating this
25514 formula with @code{n} set to @code{inf}. Calc's usual rules
25515 for ``infinite'' arithmetic can find the answer from there. If
25516 infinite arithmetic yields a @samp{nan}, or if the sum cannot be
25517 solved in closed form, Calc leaves the @code{sum} function in
25518 symbolic form. @xref{Infinities}.
25520 As a special feature, if the limits are infinite (or omitted, as
25521 described above) but the formula includes vectors subscripted by
25522 expressions that involve the iteration variable, Calc narrows
25523 the limits to include only the range of integers which result in
25524 valid subscripts for the vector. For example, the sum
25525 @samp{sum(k [a,b,c,d,e,f,g]_(2k),k)} evaluates to @samp{b + 2 d + 3 f}.
25527 The limits of a sum do not need to be integers. For example,
25528 @samp{sum(a_k, k, 0, 2 n, n)} produces @samp{a_0 + a_n + a_(2 n)}.
25529 Calc computes the number of iterations using the formula
25530 @samp{1 + (@var{high} - @var{low}) / @var{step}}, which must,
25531 after algebraic simplification, evaluate to an integer.
25533 If the number of iterations according to the above formula does
25534 not come out to an integer, the sum is invalid and will be left
25535 in symbolic form. However, closed forms are still supplied, and
25536 you are on your honor not to misuse the resulting formulas by
25537 substituting mismatched bounds into them. For example,
25538 @samp{sum(k, k, 1, 10, 2)} is invalid, but Calc will go ahead and
25539 evaluate the closed form solution for the limits 1 and 10 to get
25540 the rather dubious answer, 29.25.
25542 If the lower limit is greater than the upper limit (assuming a
25543 positive step size), the result is generally zero. However,
25544 Calc only guarantees a zero result when the upper limit is
25545 exactly one step less than the lower limit, i.e., if the number
25546 of iterations is @mathit{-1}. Thus @samp{sum(f(k), k, n, n-1)} is zero
25547 but the sum from @samp{n} to @samp{n-2} may report a nonzero value
25548 if Calc used a closed form solution.
25550 Calc's logical predicates like @expr{a < b} return 1 for ``true''
25551 and 0 for ``false.'' @xref{Logical Operations}. This can be
25552 used to advantage for building conditional sums. For example,
25553 @samp{sum(prime(k)*k^2, k, 1, 20)} is the sum of the squares of all
25554 prime numbers from 1 to 20; the @code{prime} predicate returns 1 if
25555 its argument is prime and 0 otherwise. You can read this expression
25556 as ``the sum of @expr{k^2}, where @expr{k} is prime.'' Indeed,
25557 @samp{sum(prime(k)*k^2, k)} would represent the sum of @emph{all} primes
25558 squared, since the limits default to plus and minus infinity, but
25559 there are no such sums that Calc's built-in rules can do in
25562 As another example, @samp{sum((k != k_0) * f(k), k, 1, n)} is the
25563 sum of @expr{f(k)} for all @expr{k} from 1 to @expr{n}, excluding
25564 one value @expr{k_0}. Slightly more tricky is the summand
25565 @samp{(k != k_0) / (k - k_0)}, which is an attempt to describe
25566 the sum of all @expr{1/(k-k_0)} except at @expr{k = k_0}, where
25567 this would be a division by zero. But at @expr{k = k_0}, this
25568 formula works out to the indeterminate form @expr{0 / 0}, which
25569 Calc will not assume is zero. Better would be to use
25570 @samp{(k != k_0) ? 1/(k-k_0) : 0}; the @samp{? :} operator does
25571 an ``if-then-else'' test: This expression says, ``if
25572 @texline @math{k \ne k_0},
25573 @infoline @expr{k != k_0},
25574 then @expr{1/(k-k_0)}, else zero.'' Now the formula @expr{1/(k-k_0)}
25575 will not even be evaluated by Calc when @expr{k = k_0}.
25577 @cindex Alternating sums
25579 @pindex calc-alt-summation
25581 The @kbd{a -} (@code{calc-alt-summation}) [@code{asum}] command
25582 computes an alternating sum. Successive terms of the sequence
25583 are given alternating signs, with the first term (corresponding
25584 to the lower index value) being positive. Alternating sums
25585 are converted to normal sums with an extra term of the form
25586 @samp{(-1)^(k-@var{low})}. This formula is adjusted appropriately
25587 if the step value is other than one. For example, the Taylor
25588 series for the sine function is @samp{asum(x^k / k!, k, 1, inf, 2)}.
25589 (Calc cannot evaluate this infinite series, but it can approximate
25590 it if you replace @code{inf} with any particular odd number.)
25591 Calc converts this series to a regular sum with a step of one,
25592 namely @samp{sum((-1)^k x^(2k+1) / (2k+1)!, k, 0, inf)}.
25594 @cindex Product of a sequence
25596 @pindex calc-product
25598 The @kbd{a *} (@code{calc-product}) [@code{prod}] command is
25599 the analogous way to take a product of many terms. Calc also knows
25600 some closed forms for products, such as @samp{prod(k, k, 1, n) = n!}.
25601 Conditional products can be written @samp{prod(k^prime(k), k, 1, n)}
25602 or @samp{prod(prime(k) ? k : 1, k, 1, n)}.
25605 @pindex calc-tabulate
25607 The @kbd{a T} (@code{calc-tabulate}) [@code{table}] command
25608 evaluates a formula at a series of iterated index values, just
25609 like @code{sum} and @code{prod}, but its result is simply a
25610 vector of the results. For example, @samp{table(a_i, i, 1, 7, 2)}
25611 produces @samp{[a_1, a_3, a_5, a_7]}.
25613 @node Logical Operations, Rewrite Rules, Summations, Algebra
25614 @section Logical Operations
25617 The following commands and algebraic functions return true/false values,
25618 where 1 represents ``true'' and 0 represents ``false.'' In cases where
25619 a truth value is required (such as for the condition part of a rewrite
25620 rule, or as the condition for a @w{@kbd{Z [ Z ]}} control structure), any
25621 nonzero value is accepted to mean ``true.'' (Specifically, anything
25622 for which @code{dnonzero} returns 1 is ``true,'' and anything for
25623 which @code{dnonzero} returns 0 or cannot decide is assumed ``false.''
25624 Note that this means that @w{@kbd{Z [ Z ]}} will execute the ``then''
25625 portion if its condition is provably true, but it will execute the
25626 ``else'' portion for any condition like @expr{a = b} that is not
25627 provably true, even if it might be true. Algebraic functions that
25628 have conditions as arguments, like @code{? :} and @code{&&}, remain
25629 unevaluated if the condition is neither provably true nor provably
25630 false. @xref{Declarations}.)
25633 @pindex calc-equal-to
25637 The @kbd{a =} (@code{calc-equal-to}) command, or @samp{eq(a,b)} function
25638 (which can also be written @samp{a = b} or @samp{a == b} in an algebraic
25639 formula) is true if @expr{a} and @expr{b} are equal, either because they
25640 are identical expressions, or because they are numbers which are
25641 numerically equal. (Thus the integer 1 is considered equal to the float
25642 1.0.) If the equality of @expr{a} and @expr{b} cannot be determined,
25643 the comparison is left in symbolic form. Note that as a command, this
25644 operation pops two values from the stack and pushes back either a 1 or
25645 a 0, or a formula @samp{a = b} if the values' equality cannot be determined.
25647 Many Calc commands use @samp{=} formulas to represent @dfn{equations}.
25648 For example, the @kbd{a S} (@code{calc-solve-for}) command rearranges
25649 an equation to solve for a given variable. The @kbd{a M}
25650 (@code{calc-map-equation}) command can be used to apply any
25651 function to both sides of an equation; for example, @kbd{2 a M *}
25652 multiplies both sides of the equation by two. Note that just
25653 @kbd{2 *} would not do the same thing; it would produce the formula
25654 @samp{2 (a = b)} which represents 2 if the equality is true or
25657 The @code{eq} function with more than two arguments (e.g., @kbd{C-u 3 a =}
25658 or @samp{a = b = c}) tests if all of its arguments are equal. In
25659 algebraic notation, the @samp{=} operator is unusual in that it is
25660 neither left- nor right-associative: @samp{a = b = c} is not the
25661 same as @samp{(a = b) = c} or @samp{a = (b = c)} (which each compare
25662 one variable with the 1 or 0 that results from comparing two other
25666 @pindex calc-not-equal-to
25669 The @kbd{a #} (@code{calc-not-equal-to}) command, or @samp{neq(a,b)} or
25670 @samp{a != b} function, is true if @expr{a} and @expr{b} are not equal.
25671 This also works with more than two arguments; @samp{a != b != c != d}
25672 tests that all four of @expr{a}, @expr{b}, @expr{c}, and @expr{d} are
25689 @pindex calc-less-than
25690 @pindex calc-greater-than
25691 @pindex calc-less-equal
25692 @pindex calc-greater-equal
25721 The @kbd{a <} (@code{calc-less-than}) [@samp{lt(a,b)} or @samp{a < b}]
25722 operation is true if @expr{a} is less than @expr{b}. Similar functions
25723 are @kbd{a >} (@code{calc-greater-than}) [@samp{gt(a,b)} or @samp{a > b}],
25724 @kbd{a [} (@code{calc-less-equal}) [@samp{leq(a,b)} or @samp{a <= b}], and
25725 @kbd{a ]} (@code{calc-greater-equal}) [@samp{geq(a,b)} or @samp{a >= b}].
25727 While the inequality functions like @code{lt} do not accept more
25728 than two arguments, the syntax @w{@samp{a <= b < c}} is translated to an
25729 equivalent expression involving intervals: @samp{b in [a .. c)}.
25730 (See the description of @code{in} below.) All four combinations
25731 of @samp{<} and @samp{<=} are allowed, or any of the four combinations
25732 of @samp{>} and @samp{>=}. Four-argument constructions like
25733 @samp{a < b < c < d}, and mixtures like @w{@samp{a < b = c}} that
25734 involve both equations and inequalities, are not allowed.
25737 @pindex calc-remove-equal
25739 The @kbd{a .} (@code{calc-remove-equal}) [@code{rmeq}] command extracts
25740 the righthand side of the equation or inequality on the top of the
25741 stack. It also works elementwise on vectors. For example, if
25742 @samp{[x = 2.34, y = z / 2]} is on the stack, then @kbd{a .} produces
25743 @samp{[2.34, z / 2]}. As a special case, if the righthand side is a
25744 variable and the lefthand side is a number (as in @samp{2.34 = x}), then
25745 Calc keeps the lefthand side instead. Finally, this command works with
25746 assignments @samp{x := 2.34} as well as equations, always taking the
25747 righthand side, and for @samp{=>} (evaluates-to) operators, always
25748 taking the lefthand side.
25751 @pindex calc-logical-and
25754 The @kbd{a &} (@code{calc-logical-and}) [@samp{land(a,b)} or @samp{a && b}]
25755 function is true if both of its arguments are true, i.e., are
25756 non-zero numbers. In this case, the result will be either @expr{a} or
25757 @expr{b}, chosen arbitrarily. If either argument is zero, the result is
25758 zero. Otherwise, the formula is left in symbolic form.
25761 @pindex calc-logical-or
25764 The @kbd{a |} (@code{calc-logical-or}) [@samp{lor(a,b)} or @samp{a || b}]
25765 function is true if either or both of its arguments are true (nonzero).
25766 The result is whichever argument was nonzero, choosing arbitrarily if both
25767 are nonzero. If both @expr{a} and @expr{b} are zero, the result is
25771 @pindex calc-logical-not
25774 The @kbd{a !} (@code{calc-logical-not}) [@samp{lnot(a)} or @samp{!@: a}]
25775 function is true if @expr{a} is false (zero), or false if @expr{a} is
25776 true (nonzero). It is left in symbolic form if @expr{a} is not a
25780 @pindex calc-logical-if
25790 @cindex Arguments, not evaluated
25791 The @kbd{a :} (@code{calc-logical-if}) [@samp{if(a,b,c)} or @samp{a ? b :@: c}]
25792 function is equal to either @expr{b} or @expr{c} if @expr{a} is a nonzero
25793 number or zero, respectively. If @expr{a} is not a number, the test is
25794 left in symbolic form and neither @expr{b} nor @expr{c} is evaluated in
25795 any way. In algebraic formulas, this is one of the few Calc functions
25796 whose arguments are not automatically evaluated when the function itself
25797 is evaluated. The others are @code{lambda}, @code{quote}, and
25800 One minor surprise to watch out for is that the formula @samp{a?3:4}
25801 will not work because the @samp{3:4} is parsed as a fraction instead of
25802 as three separate symbols. Type something like @samp{a ? 3 : 4} or
25803 @samp{a?(3):4} instead.
25805 As a special case, if @expr{a} evaluates to a vector, then both @expr{b}
25806 and @expr{c} are evaluated; the result is a vector of the same length
25807 as @expr{a} whose elements are chosen from corresponding elements of
25808 @expr{b} and @expr{c} according to whether each element of @expr{a}
25809 is zero or nonzero. Each of @expr{b} and @expr{c} must be either a
25810 vector of the same length as @expr{a}, or a non-vector which is matched
25811 with all elements of @expr{a}.
25814 @pindex calc-in-set
25816 The @kbd{a @{} (@code{calc-in-set}) [@samp{in(a,b)}] function is true if
25817 the number @expr{a} is in the set of numbers represented by @expr{b}.
25818 If @expr{b} is an interval form, @expr{a} must be one of the values
25819 encompassed by the interval. If @expr{b} is a vector, @expr{a} must be
25820 equal to one of the elements of the vector. (If any vector elements are
25821 intervals, @expr{a} must be in any of the intervals.) If @expr{b} is a
25822 plain number, @expr{a} must be numerically equal to @expr{b}.
25823 @xref{Set Operations}, for a group of commands that manipulate sets
25830 The @samp{typeof(a)} function produces an integer or variable which
25831 characterizes @expr{a}. If @expr{a} is a number, vector, or variable,
25832 the result will be one of the following numbers:
25837 3 Floating-point number
25839 5 Rectangular complex number
25840 6 Polar complex number
25846 12 Infinity (inf, uinf, or nan)
25848 101 Vector (but not a matrix)
25852 Otherwise, @expr{a} is a formula, and the result is a variable which
25853 represents the name of the top-level function call.
25867 The @samp{integer(a)} function returns true if @expr{a} is an integer.
25868 The @samp{real(a)} function
25869 is true if @expr{a} is a real number, either integer, fraction, or
25870 float. The @samp{constant(a)} function returns true if @expr{a} is
25871 any of the objects for which @code{typeof} would produce an integer
25872 code result except for variables, and provided that the components of
25873 an object like a vector or error form are themselves constant.
25874 Note that infinities do not satisfy any of these tests, nor do
25875 special constants like @code{pi} and @code{e}.
25877 @xref{Declarations}, for a set of similar functions that recognize
25878 formulas as well as actual numbers. For example, @samp{dint(floor(x))}
25879 is true because @samp{floor(x)} is provably integer-valued, but
25880 @samp{integer(floor(x))} does not because @samp{floor(x)} is not
25881 literally an integer constant.
25887 The @samp{refers(a,b)} function is true if the variable (or sub-expression)
25888 @expr{b} appears in @expr{a}, or false otherwise. Unlike the other
25889 tests described here, this function returns a definite ``no'' answer
25890 even if its arguments are still in symbolic form. The only case where
25891 @code{refers} will be left unevaluated is if @expr{a} is a plain
25892 variable (different from @expr{b}).
25898 The @samp{negative(a)} function returns true if @expr{a} ``looks'' negative,
25899 because it is a negative number, because it is of the form @expr{-x},
25900 or because it is a product or quotient with a term that looks negative.
25901 This is most useful in rewrite rules. Beware that @samp{negative(a)}
25902 evaluates to 1 or 0 for @emph{any} argument @expr{a}, so it can only
25903 be stored in a formula if the default simplifications are turned off
25904 first with @kbd{m O} (or if it appears in an unevaluated context such
25905 as a rewrite rule condition).
25911 The @samp{variable(a)} function is true if @expr{a} is a variable,
25912 or false if not. If @expr{a} is a function call, this test is left
25913 in symbolic form. Built-in variables like @code{pi} and @code{inf}
25914 are considered variables like any others by this test.
25920 The @samp{nonvar(a)} function is true if @expr{a} is a non-variable.
25921 If its argument is a variable it is left unsimplified; it never
25922 actually returns zero. However, since Calc's condition-testing
25923 commands consider ``false'' anything not provably true, this is
25942 @cindex Linearity testing
25943 The functions @code{lin}, @code{linnt}, @code{islin}, and @code{islinnt}
25944 check if an expression is ``linear,'' i.e., can be written in the form
25945 @expr{a + b x} for some constants @expr{a} and @expr{b}, and some
25946 variable or subformula @expr{x}. The function @samp{islin(f,x)} checks
25947 if formula @expr{f} is linear in @expr{x}, returning 1 if so. For
25948 example, @samp{islin(x,x)}, @samp{islin(-x,x)}, @samp{islin(3,x)}, and
25949 @samp{islin(x y / 3 - 2, x)} all return 1. The @samp{lin(f,x)} function
25950 is similar, except that instead of returning 1 it returns the vector
25951 @expr{[a, b, x]}. For the above examples, this vector would be
25952 @expr{[0, 1, x]}, @expr{[0, -1, x]}, @expr{[3, 0, x]}, and
25953 @expr{[-2, y/3, x]}, respectively. Both @code{lin} and @code{islin}
25954 generally remain unevaluated for expressions which are not linear,
25955 e.g., @samp{lin(2 x^2, x)} and @samp{lin(sin(x), x)}. The second
25956 argument can also be a formula; @samp{islin(2 + 3 sin(x), sin(x))}
25959 The @code{linnt} and @code{islinnt} functions perform a similar check,
25960 but require a ``non-trivial'' linear form, which means that the
25961 @expr{b} coefficient must be non-zero. For example, @samp{lin(2,x)}
25962 returns @expr{[2, 0, x]} and @samp{lin(y,x)} returns @expr{[y, 0, x]},
25963 but @samp{linnt(2,x)} and @samp{linnt(y,x)} are left unevaluated
25964 (in other words, these formulas are considered to be only ``trivially''
25965 linear in @expr{x}).
25967 All four linearity-testing functions allow you to omit the second
25968 argument, in which case the input may be linear in any non-constant
25969 formula. Here, the @expr{a=0}, @expr{b=1} case is also considered
25970 trivial, and only constant values for @expr{a} and @expr{b} are
25971 recognized. Thus, @samp{lin(2 x y)} returns @expr{[0, 2, x y]},
25972 @samp{lin(2 - x y)} returns @expr{[2, -1, x y]}, and @samp{lin(x y)}
25973 returns @expr{[0, 1, x y]}. The @code{linnt} function would allow the
25974 first two cases but not the third. Also, neither @code{lin} nor
25975 @code{linnt} accept plain constants as linear in the one-argument
25976 case: @samp{islin(2,x)} is true, but @samp{islin(2)} is false.
25982 The @samp{istrue(a)} function returns 1 if @expr{a} is a nonzero
25983 number or provably nonzero formula, or 0 if @expr{a} is anything else.
25984 Calls to @code{istrue} can only be manipulated if @kbd{m O} mode is
25985 used to make sure they are not evaluated prematurely. (Note that
25986 declarations are used when deciding whether a formula is true;
25987 @code{istrue} returns 1 when @code{dnonzero} would return 1, and
25988 it returns 0 when @code{dnonzero} would return 0 or leave itself
25991 @node Rewrite Rules, , Logical Operations, Algebra
25992 @section Rewrite Rules
25995 @cindex Rewrite rules
25996 @cindex Transformations
25997 @cindex Pattern matching
25999 @pindex calc-rewrite
26001 The @kbd{a r} (@code{calc-rewrite}) [@code{rewrite}] command makes
26002 substitutions in a formula according to a specified pattern or patterns
26003 known as @dfn{rewrite rules}. Whereas @kbd{a b} (@code{calc-substitute})
26004 matches literally, so that substituting @samp{sin(x)} with @samp{cos(x)}
26005 matches only the @code{sin} function applied to the variable @code{x},
26006 rewrite rules match general kinds of formulas; rewriting using the rule
26007 @samp{sin(x) := cos(x)} matches @code{sin} of any argument and replaces
26008 it with @code{cos} of that same argument. The only significance of the
26009 name @code{x} is that the same name is used on both sides of the rule.
26011 Rewrite rules rearrange formulas already in Calc's memory.
26012 @xref{Syntax Tables}, to read about @dfn{syntax rules}, which are
26013 similar to algebraic rewrite rules but operate when new algebraic
26014 entries are being parsed, converting strings of characters into
26018 * Entering Rewrite Rules::
26019 * Basic Rewrite Rules::
26020 * Conditional Rewrite Rules::
26021 * Algebraic Properties of Rewrite Rules::
26022 * Other Features of Rewrite Rules::
26023 * Composing Patterns in Rewrite Rules::
26024 * Nested Formulas with Rewrite Rules::
26025 * Multi-Phase Rewrite Rules::
26026 * Selections with Rewrite Rules::
26027 * Matching Commands::
26028 * Automatic Rewrites::
26029 * Debugging Rewrites::
26030 * Examples of Rewrite Rules::
26033 @node Entering Rewrite Rules, Basic Rewrite Rules, Rewrite Rules, Rewrite Rules
26034 @subsection Entering Rewrite Rules
26037 Rewrite rules normally use the ``assignment'' operator
26038 @samp{@var{old} := @var{new}}.
26039 This operator is equivalent to the function call @samp{assign(old, new)}.
26040 The @code{assign} function is undefined by itself in Calc, so an
26041 assignment formula such as a rewrite rule will be left alone by ordinary
26042 Calc commands. But certain commands, like the rewrite system, interpret
26043 assignments in special ways.
26045 For example, the rule @samp{sin(x)^2 := 1-cos(x)^2} says to replace
26046 every occurrence of the sine of something, squared, with one minus the
26047 square of the cosine of that same thing. All by itself as a formula
26048 on the stack it does nothing, but when given to the @kbd{a r} command
26049 it turns that command into a sine-squared-to-cosine-squared converter.
26051 To specify a set of rules to be applied all at once, make a vector of
26054 When @kbd{a r} prompts you to enter the rewrite rules, you can answer
26059 With a rule: @kbd{f(x) := g(x) @key{RET}}.
26061 With a vector of rules: @kbd{[f1(x) := g1(x), f2(x) := g2(x)] @key{RET}}.
26062 (You can omit the enclosing square brackets if you wish.)
26064 With the name of a variable that contains the rule or rules vector:
26065 @kbd{myrules @key{RET}}.
26067 With any formula except a rule, a vector, or a variable name; this
26068 will be interpreted as the @var{old} half of a rewrite rule,
26069 and you will be prompted a second time for the @var{new} half:
26070 @kbd{f(x) @key{RET} g(x) @key{RET}}.
26072 With a blank line, in which case the rule, rules vector, or variable
26073 will be taken from the top of the stack (and the formula to be
26074 rewritten will come from the second-to-top position).
26077 If you enter the rules directly (as opposed to using rules stored
26078 in a variable), those rules will be put into the Trail so that you
26079 can retrieve them later. @xref{Trail Commands}.
26081 It is most convenient to store rules you use often in a variable and
26082 invoke them by giving the variable name. The @kbd{s e}
26083 (@code{calc-edit-variable}) command is an easy way to create or edit a
26084 rule set stored in a variable. You may also wish to use @kbd{s p}
26085 (@code{calc-permanent-variable}) to save your rules permanently;
26086 @pxref{Operations on Variables}.
26088 Rewrite rules are compiled into a special internal form for faster
26089 matching. If you enter a rule set directly it must be recompiled
26090 every time. If you store the rules in a variable and refer to them
26091 through that variable, they will be compiled once and saved away
26092 along with the variable for later reference. This is another good
26093 reason to store your rules in a variable.
26095 Calc also accepts an obsolete notation for rules, as vectors
26096 @samp{[@var{old}, @var{new}]}. But because it is easily confused with a
26097 vector of two rules, the use of this notation is no longer recommended.
26099 @node Basic Rewrite Rules, Conditional Rewrite Rules, Entering Rewrite Rules, Rewrite Rules
26100 @subsection Basic Rewrite Rules
26103 To match a particular formula @expr{x} with a particular rewrite rule
26104 @samp{@var{old} := @var{new}}, Calc compares the structure of @expr{x} with
26105 the structure of @var{old}. Variables that appear in @var{old} are
26106 treated as @dfn{meta-variables}; the corresponding positions in @expr{x}
26107 may contain any sub-formulas. For example, the pattern @samp{f(x,y)}
26108 would match the expression @samp{f(12, a+1)} with the meta-variable
26109 @samp{x} corresponding to 12 and with @samp{y} corresponding to
26110 @samp{a+1}. However, this pattern would not match @samp{f(12)} or
26111 @samp{g(12, a+1)}, since there is no assignment of the meta-variables
26112 that will make the pattern match these expressions. Notice that if
26113 the pattern is a single meta-variable, it will match any expression.
26115 If a given meta-variable appears more than once in @var{old}, the
26116 corresponding sub-formulas of @expr{x} must be identical. Thus
26117 the pattern @samp{f(x,x)} would match @samp{f(12, 12)} and
26118 @samp{f(a+1, a+1)} but not @samp{f(12, a+1)} or @samp{f(a+b, b+a)}.
26119 (@xref{Conditional Rewrite Rules}, for a way to match the latter.)
26121 Things other than variables must match exactly between the pattern
26122 and the target formula. To match a particular variable exactly, use
26123 the pseudo-function @samp{quote(v)} in the pattern. For example, the
26124 pattern @samp{x+quote(y)} matches @samp{x+y}, @samp{2+y}, or
26127 The special variable names @samp{e}, @samp{pi}, @samp{i}, @samp{phi},
26128 @samp{gamma}, @samp{inf}, @samp{uinf}, and @samp{nan} always match
26129 literally. Thus the pattern @samp{sin(d + e + f)} acts exactly like
26130 @samp{sin(d + quote(e) + f)}.
26132 If the @var{old} pattern is found to match a given formula, that
26133 formula is replaced by @var{new}, where any occurrences in @var{new}
26134 of meta-variables from the pattern are replaced with the sub-formulas
26135 that they matched. Thus, applying the rule @samp{f(x,y) := g(y+x,x)}
26136 to @samp{f(12, a+1)} would produce @samp{g(a+13, 12)}.
26138 The normal @kbd{a r} command applies rewrite rules over and over
26139 throughout the target formula until no further changes are possible
26140 (up to a limit of 100 times). Use @kbd{C-u 1 a r} to make only one
26143 @node Conditional Rewrite Rules, Algebraic Properties of Rewrite Rules, Basic Rewrite Rules, Rewrite Rules
26144 @subsection Conditional Rewrite Rules
26147 A rewrite rule can also be @dfn{conditional}, written in the form
26148 @samp{@var{old} := @var{new} :: @var{cond}}. (There is also the obsolete
26149 form @samp{[@var{old}, @var{new}, @var{cond}]}.) If a @var{cond} part
26151 rule, this is an additional condition that must be satisfied before
26152 the rule is accepted. Once @var{old} has been successfully matched
26153 to the target expression, @var{cond} is evaluated (with all the
26154 meta-variables substituted for the values they matched) and simplified
26155 with Calc's algebraic simplifications. If the result is a nonzero
26156 number or any other object known to be nonzero (@pxref{Declarations}),
26157 the rule is accepted. If the result is zero or if it is a symbolic
26158 formula that is not known to be nonzero, the rule is rejected.
26159 @xref{Logical Operations}, for a number of functions that return
26160 1 or 0 according to the results of various tests.
26162 For example, the formula @samp{n > 0} simplifies to 1 or 0 if @expr{n}
26163 is replaced by a positive or nonpositive number, respectively (or if
26164 @expr{n} has been declared to be positive or nonpositive). Thus,
26165 the rule @samp{f(x,y) := g(y+x,x) :: x+y > 0} would apply to
26166 @samp{f(0, 4)} but not to @samp{f(-3, 2)} or @samp{f(12, a+1)}
26167 (assuming no outstanding declarations for @expr{a}). In the case of
26168 @samp{f(-3, 2)}, the condition can be shown not to be satisfied; in
26169 the case of @samp{f(12, a+1)}, the condition merely cannot be shown
26170 to be satisfied, but that is enough to reject the rule.
26172 While Calc will use declarations to reason about variables in the
26173 formula being rewritten, declarations do not apply to meta-variables.
26174 For example, the rule @samp{f(a) := g(a+1)} will match for any values
26175 of @samp{a}, such as complex numbers, vectors, or formulas, even if
26176 @samp{a} has been declared to be real or scalar. If you want the
26177 meta-variable @samp{a} to match only literal real numbers, use
26178 @samp{f(a) := g(a+1) :: real(a)}. If you want @samp{a} to match only
26179 reals and formulas which are provably real, use @samp{dreal(a)} as
26182 The @samp{::} operator is a shorthand for the @code{condition}
26183 function; @samp{@var{old} := @var{new} :: @var{cond}} is equivalent to
26184 the formula @samp{condition(assign(@var{old}, @var{new}), @var{cond})}.
26186 If you have several conditions, you can use @samp{... :: c1 :: c2 :: c3}
26187 or @samp{... :: c1 && c2 && c3}. The two are entirely equivalent.
26189 It is also possible to embed conditions inside the pattern:
26190 @samp{f(x :: x>0, y) := g(y+x, x)}. This is purely a notational
26191 convenience, though; where a condition appears in a rule has no
26192 effect on when it is tested. The rewrite-rule compiler automatically
26193 decides when it is best to test each condition while a rule is being
26196 Certain conditions are handled as special cases by the rewrite rule
26197 system and are tested very efficiently: Where @expr{x} is any
26198 meta-variable, these conditions are @samp{integer(x)}, @samp{real(x)},
26199 @samp{constant(x)}, @samp{negative(x)}, @samp{x >= y} where @expr{y}
26200 is either a constant or another meta-variable and @samp{>=} may be
26201 replaced by any of the six relational operators, and @samp{x % a = b}
26202 where @expr{a} and @expr{b} are constants. Other conditions, like
26203 @samp{x >= y+1} or @samp{dreal(x)}, will be less efficient to check
26204 since Calc must bring the whole evaluator and simplifier into play.
26206 An interesting property of @samp{::} is that neither of its arguments
26207 will be touched by Calc's default simplifications. This is important
26208 because conditions often are expressions that cannot safely be
26209 evaluated early. For example, the @code{typeof} function never
26210 remains in symbolic form; entering @samp{typeof(a)} will put the
26211 number 100 (the type code for variables like @samp{a}) on the stack.
26212 But putting the condition @samp{... :: typeof(a) = 6} on the stack
26213 is safe since @samp{::} prevents the @code{typeof} from being
26214 evaluated until the condition is actually used by the rewrite system.
26216 Since @samp{::} protects its lefthand side, too, you can use a dummy
26217 condition to protect a rule that must itself not evaluate early.
26218 For example, it's not safe to put @samp{a(f,x) := apply(f, [x])} on
26219 the stack because it will immediately evaluate to @samp{a(f,x) := f(x)},
26220 where the meta-variable-ness of @code{f} on the righthand side has been
26221 lost. But @samp{a(f,x) := apply(f, [x]) :: 1} is safe, and of course
26222 the condition @samp{1} is always true (nonzero) so it has no effect on
26223 the functioning of the rule. (The rewrite compiler will ensure that
26224 it doesn't even impact the speed of matching the rule.)
26226 @node Algebraic Properties of Rewrite Rules, Other Features of Rewrite Rules, Conditional Rewrite Rules, Rewrite Rules
26227 @subsection Algebraic Properties of Rewrite Rules
26230 The rewrite mechanism understands the algebraic properties of functions
26231 like @samp{+} and @samp{*}. In particular, pattern matching takes
26232 the associativity and commutativity of the following functions into
26236 + - * = != && || and or xor vint vunion vxor gcd lcm max min beta
26239 For example, the rewrite rule:
26242 a x + b x := (a + b) x
26246 will match formulas of the form,
26249 a x + b x, x a + x b, a x + x b, x a + b x
26252 Rewrites also understand the relationship between the @samp{+} and @samp{-}
26253 operators. The above rewrite rule will also match the formulas,
26256 a x - b x, x a - x b, a x - x b, x a - b x
26260 by matching @samp{b} in the pattern to @samp{-b} from the formula.
26262 Applied to a sum of many terms like @samp{r + a x + s + b x + t}, this
26263 pattern will check all pairs of terms for possible matches. The rewrite
26264 will take whichever suitable pair it discovers first.
26266 In general, a pattern using an associative operator like @samp{a + b}
26267 will try @var{2 n} different ways to match a sum of @var{n} terms
26268 like @samp{x + y + z - w}. First, @samp{a} is matched against each
26269 of @samp{x}, @samp{y}, @samp{z}, and @samp{-w} in turn, with @samp{b}
26270 being matched to the remainders @samp{y + z - w}, @samp{x + z - w}, etc.
26271 If none of these succeed, then @samp{b} is matched against each of the
26272 four terms with @samp{a} matching the remainder. Half-and-half matches,
26273 like @samp{(x + y) + (z - w)}, are not tried.
26275 Note that @samp{*} is not commutative when applied to matrices, but
26276 rewrite rules pretend that it is. If you type @kbd{m v} to enable
26277 Matrix mode (@pxref{Matrix Mode}), rewrite rules will match @samp{*}
26278 literally, ignoring its usual commutativity property. (In the
26279 current implementation, the associativity also vanishes---it is as
26280 if the pattern had been enclosed in a @code{plain} marker; see below.)
26281 If you are applying rewrites to formulas with matrices, it's best to
26282 enable Matrix mode first to prevent algebraically incorrect rewrites
26285 The pattern @samp{-x} will actually match any expression. For example,
26293 will rewrite @samp{f(a)} to @samp{-f(-a)}. To avoid this, either use
26294 a @code{plain} marker as described below, or add a @samp{negative(x)}
26295 condition. The @code{negative} function is true if its argument
26296 ``looks'' negative, for example, because it is a negative number or
26297 because it is a formula like @samp{-x}. The new rule using this
26301 f(x) := -f(-x) :: negative(x) @r{or, equivalently,}
26302 f(-x) := -f(x) :: negative(-x)
26305 In the same way, the pattern @samp{x - y} will match the sum @samp{a + b}
26306 by matching @samp{y} to @samp{-b}.
26308 The pattern @samp{a b} will also match the formula @samp{x/y} if
26309 @samp{y} is a number. Thus the rule @samp{a x + @w{b x} := (a+b) x}
26310 will also convert @samp{a x + x / 2} to @samp{(a + 0.5) x} (or
26311 @samp{(a + 1:2) x}, depending on the current fraction mode).
26313 Calc will @emph{not} take other liberties with @samp{*}, @samp{/}, and
26314 @samp{^}. For example, the pattern @samp{f(a b)} will not match
26315 @samp{f(x^2)}, and @samp{f(a + b)} will not match @samp{f(2 x)}, even
26316 though conceivably these patterns could match with @samp{a = b = x}.
26317 Nor will @samp{f(a b)} match @samp{f(x / y)} if @samp{y} is not a
26318 constant, even though it could be considered to match with @samp{a = x}
26319 and @samp{b = 1/y}. The reasons are partly for efficiency, and partly
26320 because while few mathematical operations are substantively different
26321 for addition and subtraction, often it is preferable to treat the cases
26322 of multiplication, division, and integer powers separately.
26324 Even more subtle is the rule set
26327 [ f(a) + f(b) := f(a + b), -f(a) := f(-a) ]
26331 attempting to match @samp{f(x) - f(y)}. You might think that Calc
26332 will view this subtraction as @samp{f(x) + (-f(y))} and then apply
26333 the above two rules in turn, but actually this will not work because
26334 Calc only does this when considering rules for @samp{+} (like the
26335 first rule in this set). So it will see first that @samp{f(x) + (-f(y))}
26336 does not match @samp{f(a) + f(b)} for any assignments of the
26337 meta-variables, and then it will see that @samp{f(x) - f(y)} does
26338 not match @samp{-f(a)} for any assignment of @samp{a}. Because Calc
26339 tries only one rule at a time, it will not be able to rewrite
26340 @samp{f(x) - f(y)} with this rule set. An explicit @samp{f(a) - f(b)}
26341 rule will have to be added.
26343 Another thing patterns will @emph{not} do is break up complex numbers.
26344 The pattern @samp{myconj(a + @w{b i)} := a - b i} will work for formulas
26345 involving the special constant @samp{i} (such as @samp{3 - 4 i}), but
26346 it will not match actual complex numbers like @samp{(3, -4)}. A version
26347 of the above rule for complex numbers would be
26350 myconj(a) := re(a) - im(a) (0,1) :: im(a) != 0
26354 (Because the @code{re} and @code{im} functions understand the properties
26355 of the special constant @samp{i}, this rule will also work for
26356 @samp{3 - 4 i}. In fact, this particular rule would probably be better
26357 without the @samp{im(a) != 0} condition, since if @samp{im(a) = 0} the
26358 righthand side of the rule will still give the correct answer for the
26359 conjugate of a real number.)
26361 It is also possible to specify optional arguments in patterns. The rule
26364 opt(a) x + opt(b) (x^opt(c) + opt(d)) := f(a, b, c, d)
26368 will match the formula
26375 in a fairly straightforward manner, but it will also match reduced
26379 x + x^2, 2(x + 1) - x, x + x
26383 producing, respectively,
26386 f(1, 1, 2, 0), f(-1, 2, 1, 1), f(1, 1, 1, 0)
26389 (The latter two formulas can be entered only if default simplifications
26390 have been turned off with @kbd{m O}.)
26392 The default value for a term of a sum is zero. The default value
26393 for a part of a product, for a power, or for the denominator of a
26394 quotient, is one. Also, @samp{-x} matches the pattern @samp{opt(a) b}
26395 with @samp{a = -1}.
26397 In particular, the distributive-law rule can be refined to
26400 opt(a) x + opt(b) x := (a + b) x
26404 so that it will convert, e.g., @samp{a x - x}, to @samp{(a - 1) x}.
26406 The pattern @samp{opt(a) + opt(b) x} matches almost any formulas which
26407 are linear in @samp{x}. You can also use the @code{lin} and @code{islin}
26408 functions with rewrite conditions to test for this; @pxref{Logical
26409 Operations}. These functions are not as convenient to use in rewrite
26410 rules, but they recognize more kinds of formulas as linear:
26411 @samp{x/z} is considered linear with @expr{b = 1/z} by @code{lin},
26412 but it will not match the above pattern because that pattern calls
26413 for a multiplication, not a division.
26415 As another example, the obvious rule to replace @samp{sin(x)^2 + cos(x)^2}
26419 sin(x)^2 + cos(x)^2 := 1
26423 misses many cases because the sine and cosine may both be multiplied by
26424 an equal factor. Here's a more successful rule:
26427 opt(a) sin(x)^2 + opt(a) cos(x)^2 := a
26430 Note that this rule will @emph{not} match @samp{sin(x)^2 + 6 cos(x)^2}
26431 because one @expr{a} would have ``matched'' 1 while the other matched 6.
26433 Calc automatically converts a rule like
26443 f(temp, x) := g(x) :: temp = x-1
26447 (where @code{temp} stands for a new, invented meta-variable that
26448 doesn't actually have a name). This modified rule will successfully
26449 match @samp{f(6, 7)}, binding @samp{temp} and @samp{x} to 6 and 7,
26450 respectively, then verifying that they differ by one even though
26451 @samp{6} does not superficially look like @samp{x-1}.
26453 However, Calc does not solve equations to interpret a rule. The
26457 f(x-1, x+1) := g(x)
26461 will not work. That is, it will match @samp{f(a - 1 + b, a + 1 + b)}
26462 but not @samp{f(6, 8)}. Calc always interprets at least one occurrence
26463 of a variable by literal matching. If the variable appears ``isolated''
26464 then Calc is smart enough to use it for literal matching. But in this
26465 last example, Calc is forced to rewrite the rule to @samp{f(x-1, temp)
26466 := g(x) :: temp = x+1} where the @samp{x-1} term must correspond to an
26467 actual ``something-minus-one'' in the target formula.
26469 A successful way to write this would be @samp{f(x, x+2) := g(x+1)}.
26470 You could make this resemble the original form more closely by using
26471 @code{let} notation, which is described in the next section:
26474 f(xm1, x+1) := g(x) :: let(x := xm1+1)
26477 Calc does this rewriting or ``conditionalizing'' for any sub-pattern
26478 which involves only the functions in the following list, operating
26479 only on constants and meta-variables which have already been matched
26480 elsewhere in the pattern. When matching a function call, Calc is
26481 careful to match arguments which are plain variables before arguments
26482 which are calls to any of the functions below, so that a pattern like
26483 @samp{f(x-1, x)} can be conditionalized even though the isolated
26484 @samp{x} comes after the @samp{x-1}.
26487 + - * / \ % ^ abs sign round rounde roundu trunc floor ceil
26488 max min re im conj arg
26491 You can suppress all of the special treatments described in this
26492 section by surrounding a function call with a @code{plain} marker.
26493 This marker causes the function call which is its argument to be
26494 matched literally, without regard to commutativity, associativity,
26495 negation, or conditionalization. When you use @code{plain}, the
26496 ``deep structure'' of the formula being matched can show through.
26500 plain(a - a b) := f(a, b)
26504 will match only literal subtractions. However, the @code{plain}
26505 marker does not affect its arguments' arguments. In this case,
26506 commutativity and associativity is still considered while matching
26507 the @w{@samp{a b}} sub-pattern, so the whole pattern will match
26508 @samp{x - y x} as well as @samp{x - x y}. We could go still
26512 plain(a - plain(a b)) := f(a, b)
26516 which would do a completely strict match for the pattern.
26518 By contrast, the @code{quote} marker means that not only the
26519 function name but also the arguments must be literally the same.
26520 The above pattern will match @samp{x - x y} but
26523 quote(a - a b) := f(a, b)
26527 will match only the single formula @samp{a - a b}. Also,
26530 quote(a - quote(a b)) := f(a, b)
26534 will match only @samp{a - quote(a b)}---probably not the desired
26537 A certain amount of algebra is also done when substituting the
26538 meta-variables on the righthand side of a rule. For example,
26542 a + f(b) := f(a + b)
26546 matching @samp{f(x) - y} would produce @samp{f((-y) + x)} if
26547 taken literally, but the rewrite mechanism will simplify the
26548 righthand side to @samp{f(x - y)} automatically. (Of course,
26549 the default simplifications would do this anyway, so this
26550 special simplification is only noticeable if you have turned the
26551 default simplifications off.) This rewriting is done only when
26552 a meta-variable expands to a ``negative-looking'' expression.
26553 If this simplification is not desirable, you can use a @code{plain}
26554 marker on the righthand side:
26557 a + f(b) := f(plain(a + b))
26561 In this example, we are still allowing the pattern-matcher to
26562 use all the algebra it can muster, but the righthand side will
26563 always simplify to a literal addition like @samp{f((-y) + x)}.
26565 @node Other Features of Rewrite Rules, Composing Patterns in Rewrite Rules, Algebraic Properties of Rewrite Rules, Rewrite Rules
26566 @subsection Other Features of Rewrite Rules
26569 Certain ``function names'' serve as markers in rewrite rules.
26570 Here is a complete list of these markers. First are listed the
26571 markers that work inside a pattern; then come the markers that
26572 work in the righthand side of a rule.
26578 One kind of marker, @samp{import(x)}, takes the place of a whole
26579 rule. Here @expr{x} is the name of a variable containing another
26580 rule set; those rules are ``spliced into'' the rule set that
26581 imports them. For example, if @samp{[f(a+b) := f(a) + f(b),
26582 f(a b) := a f(b) :: real(a)]} is stored in variable @samp{linearF},
26583 then the rule set @samp{[f(0) := 0, import(linearF)]} will apply
26584 all three rules. It is possible to modify the imported rules
26585 slightly: @samp{import(x, v1, x1, v2, x2, @dots{})} imports
26586 the rule set @expr{x} with all occurrences of
26587 @texline @math{v_1},
26588 @infoline @expr{v1},
26589 as either a variable name or a function name, replaced with
26590 @texline @math{x_1}
26591 @infoline @expr{x1}
26593 @texline @math{v_1}
26594 @infoline @expr{v1}
26595 is used as a function name, then
26596 @texline @math{x_1}
26597 @infoline @expr{x1}
26598 must be either a function name itself or a @w{@samp{< >}} nameless
26599 function; @pxref{Specifying Operators}.) For example, @samp{[g(0) := 0,
26600 import(linearF, f, g)]} applies the linearity rules to the function
26601 @samp{g} instead of @samp{f}. Imports can be nested, but the
26602 import-with-renaming feature may fail to rename sub-imports properly.
26604 The special functions allowed in patterns are:
26612 This pattern matches exactly @expr{x}; variable names in @expr{x} are
26613 not interpreted as meta-variables. The only flexibility is that
26614 numbers are compared for numeric equality, so that the pattern
26615 @samp{f(quote(12))} will match both @samp{f(12)} and @samp{f(12.0)}.
26616 (Numbers are always treated this way by the rewrite mechanism:
26617 The rule @samp{f(x,x) := g(x)} will match @samp{f(12, 12.0)}.
26618 The rewrite may produce either @samp{g(12)} or @samp{g(12.0)}
26619 as a result in this case.)
26626 Here @expr{x} must be a function call @samp{f(x1,x2,@dots{})}. This
26627 pattern matches a call to function @expr{f} with the specified
26628 argument patterns. No special knowledge of the properties of the
26629 function @expr{f} is used in this case; @samp{+} is not commutative or
26630 associative. Unlike @code{quote}, the arguments @samp{x1,x2,@dots{}}
26631 are treated as patterns. If you wish them to be treated ``plainly''
26632 as well, you must enclose them with more @code{plain} markers:
26633 @samp{plain(plain(@w{-a}) + plain(b c))}.
26640 Here @expr{x} must be a variable name. This must appear as an
26641 argument to a function or an element of a vector; it specifies that
26642 the argument or element is optional.
26643 As an argument to @samp{+}, @samp{-}, @samp{*}, @samp{&&}, or @samp{||},
26644 or as the second argument to @samp{/} or @samp{^}, the value @var{def}
26645 may be omitted. The pattern @samp{x + opt(y)} matches a sum by
26646 binding one summand to @expr{x} and the other to @expr{y}, and it
26647 matches anything else by binding the whole expression to @expr{x} and
26648 zero to @expr{y}. The other operators above work similarly.
26650 For general miscellaneous functions, the default value @code{def}
26651 must be specified. Optional arguments are dropped starting with
26652 the rightmost one during matching. For example, the pattern
26653 @samp{f(opt(a,0), b, opt(c,b))} will match @samp{f(b)}, @samp{f(a,b)},
26654 or @samp{f(a,b,c)}. Default values of zero and @expr{b} are
26655 supplied in this example for the omitted arguments. Note that
26656 the literal variable @expr{b} will be the default in the latter
26657 case, @emph{not} the value that matched the meta-variable @expr{b}.
26658 In other words, the default @var{def} is effectively quoted.
26660 @item condition(x,c)
26666 This matches the pattern @expr{x}, with the attached condition
26667 @expr{c}. It is the same as @samp{x :: c}.
26675 This matches anything that matches both pattern @expr{x} and
26676 pattern @expr{y}. It is the same as @samp{x &&& y}.
26677 @pxref{Composing Patterns in Rewrite Rules}.
26685 This matches anything that matches either pattern @expr{x} or
26686 pattern @expr{y}. It is the same as @w{@samp{x ||| y}}.
26694 This matches anything that does not match pattern @expr{x}.
26695 It is the same as @samp{!!! x}.
26701 @tindex cons (rewrites)
26702 This matches any vector of one or more elements. The first
26703 element is matched to @expr{h}; a vector of the remaining
26704 elements is matched to @expr{t}. Note that vectors of fixed
26705 length can also be matched as actual vectors: The rule
26706 @samp{cons(a,cons(b,[])) := cons(a+b,[])} is equivalent
26707 to the rule @samp{[a,b] := [a+b]}.
26713 @tindex rcons (rewrites)
26714 This is like @code{cons}, except that the @emph{last} element
26715 is matched to @expr{h}, with the remaining elements matched
26718 @item apply(f,args)
26722 @tindex apply (rewrites)
26723 This matches any function call. The name of the function, in
26724 the form of a variable, is matched to @expr{f}. The arguments
26725 of the function, as a vector of zero or more objects, are
26726 matched to @samp{args}. Constants, variables, and vectors
26727 do @emph{not} match an @code{apply} pattern. For example,
26728 @samp{apply(f,x)} matches any function call, @samp{apply(quote(f),x)}
26729 matches any call to the function @samp{f}, @samp{apply(f,[a,b])}
26730 matches any function call with exactly two arguments, and
26731 @samp{apply(quote(f), cons(a,cons(b,x)))} matches any call
26732 to the function @samp{f} with two or more arguments. Another
26733 way to implement the latter, if the rest of the rule does not
26734 need to refer to the first two arguments of @samp{f} by name,
26735 would be @samp{apply(quote(f), x :: vlen(x) >= 2)}.
26736 Here's a more interesting sample use of @code{apply}:
26739 apply(f,[x+n]) := n + apply(f,[x])
26740 :: in(f, [floor,ceil,round,trunc]) :: integer(n)
26743 Note, however, that this will be slower to match than a rule
26744 set with four separate rules. The reason is that Calc sorts
26745 the rules of a rule set according to top-level function name;
26746 if the top-level function is @code{apply}, Calc must try the
26747 rule for every single formula and sub-formula. If the top-level
26748 function in the pattern is, say, @code{floor}, then Calc invokes
26749 the rule only for sub-formulas which are calls to @code{floor}.
26751 Formulas normally written with operators like @code{+} are still
26752 considered function calls: @code{apply(f,x)} matches @samp{a+b}
26753 with @samp{f = add}, @samp{x = [a,b]}.
26755 You must use @code{apply} for meta-variables with function names
26756 on both sides of a rewrite rule: @samp{apply(f, [x]) := f(x+1)}
26757 is @emph{not} correct, because it rewrites @samp{spam(6)} into
26758 @samp{f(7)}. The righthand side should be @samp{apply(f, [x+1])}.
26759 Also note that you will have to use No-Simplify mode (@kbd{m O})
26760 when entering this rule so that the @code{apply} isn't
26761 evaluated immediately to get the new rule @samp{f(x) := f(x+1)}.
26762 Or, use @kbd{s e} to enter the rule without going through the stack,
26763 or enter the rule as @samp{apply(f, [x]) := apply(f, [x+1]) @w{:: 1}}.
26764 @xref{Conditional Rewrite Rules}.
26771 This is used for applying rules to formulas with selections;
26772 @pxref{Selections with Rewrite Rules}.
26775 Special functions for the righthand sides of rules are:
26779 The notation @samp{quote(x)} is changed to @samp{x} when the
26780 righthand side is used. As far as the rewrite rule is concerned,
26781 @code{quote} is invisible. However, @code{quote} has the special
26782 property in Calc that its argument is not evaluated. Thus,
26783 while it will not work to put the rule @samp{t(a) := typeof(a)}
26784 on the stack because @samp{typeof(a)} is evaluated immediately
26785 to produce @samp{t(a) := 100}, you can use @code{quote} to
26786 protect the righthand side: @samp{t(a) := quote(typeof(a))}.
26787 (@xref{Conditional Rewrite Rules}, for another trick for
26788 protecting rules from evaluation.)
26791 Special properties of and simplifications for the function call
26792 @expr{x} are not used. One interesting case where @code{plain}
26793 is useful is the rule, @samp{q(x) := quote(x)}, trying to expand a
26794 shorthand notation for the @code{quote} function. This rule will
26795 not work as shown; instead of replacing @samp{q(foo)} with
26796 @samp{quote(foo)}, it will replace it with @samp{foo}! The correct
26797 rule would be @samp{q(x) := plain(quote(x))}.
26800 Where @expr{t} is a vector, this is converted into an expanded
26801 vector during rewrite processing. Note that @code{cons} is a regular
26802 Calc function which normally does this anyway; the only way @code{cons}
26803 is treated specially by rewrites is that @code{cons} on the righthand
26804 side of a rule will be evaluated even if default simplifications
26805 have been turned off.
26808 Analogous to @code{cons} except putting @expr{h} at the @emph{end} of
26809 the vector @expr{t}.
26811 @item apply(f,args)
26812 Where @expr{f} is a variable and @var{args} is a vector, this
26813 is converted to a function call. Once again, note that @code{apply}
26814 is also a regular Calc function.
26821 The formula @expr{x} is handled in the usual way, then the
26822 default simplifications are applied to it even if they have
26823 been turned off normally. This allows you to treat any function
26824 similarly to the way @code{cons} and @code{apply} are always
26825 treated. However, there is a slight difference: @samp{cons(2+3, [])}
26826 with default simplifications off will be converted to @samp{[2+3]},
26827 whereas @samp{eval(cons(2+3, []))} will be converted to @samp{[5]}.
26834 The formula @expr{x} has meta-variables substituted in the usual
26835 way, then algebraically simplified.
26837 @item evalextsimp(x)
26841 @tindex evalextsimp
26842 The formula @expr{x} has meta-variables substituted in the normal
26843 way, then ``extendedly'' simplified as if by the @kbd{a e} command.
26846 @xref{Selections with Rewrite Rules}.
26849 There are also some special functions you can use in conditions.
26857 The expression @expr{x} is evaluated with meta-variables substituted.
26858 The algebraic simplifications are @emph{not} applied by
26859 default, but @expr{x} can include calls to @code{evalsimp} or
26860 @code{evalextsimp} as described above to invoke higher levels
26861 of simplification. The result of @expr{x} is then bound to the
26862 meta-variable @expr{v}. As usual, if this meta-variable has already
26863 been matched to something else the two values must be equal; if the
26864 meta-variable is new then it is bound to the result of the expression.
26865 This variable can then appear in later conditions, and on the righthand
26867 In fact, @expr{v} may be any pattern in which case the result of
26868 evaluating @expr{x} is matched to that pattern, binding any
26869 meta-variables that appear in that pattern. Note that @code{let}
26870 can only appear by itself as a condition, or as one term of an
26871 @samp{&&} which is a whole condition: It cannot be inside
26872 an @samp{||} term or otherwise buried.
26874 The alternate, equivalent form @samp{let(v, x)} is also recognized.
26875 Note that the use of @samp{:=} by @code{let}, while still being
26876 assignment-like in character, is unrelated to the use of @samp{:=}
26877 in the main part of a rewrite rule.
26879 As an example, @samp{f(a) := g(ia) :: let(ia := 1/a) :: constant(ia)}
26880 replaces @samp{f(a)} with @samp{g} of the inverse of @samp{a}, if
26881 that inverse exists and is constant. For example, if @samp{a} is a
26882 singular matrix the operation @samp{1/a} is left unsimplified and
26883 @samp{constant(ia)} fails, but if @samp{a} is an invertible matrix
26884 then the rule succeeds. Without @code{let} there would be no way
26885 to express this rule that didn't have to invert the matrix twice.
26886 Note that, because the meta-variable @samp{ia} is otherwise unbound
26887 in this rule, the @code{let} condition itself always ``succeeds''
26888 because no matter what @samp{1/a} evaluates to, it can successfully
26889 be bound to @code{ia}.
26891 Here's another example, for integrating cosines of linear
26892 terms: @samp{myint(cos(y),x) := sin(y)/b :: let([a,b,x] := lin(y,x))}.
26893 The @code{lin} function returns a 3-vector if its argument is linear,
26894 or leaves itself unevaluated if not. But an unevaluated @code{lin}
26895 call will not match the 3-vector on the lefthand side of the @code{let},
26896 so this @code{let} both verifies that @code{y} is linear, and binds
26897 the coefficients @code{a} and @code{b} for use elsewhere in the rule.
26898 (It would have been possible to use @samp{sin(a x + b)/b} for the
26899 righthand side instead, but using @samp{sin(y)/b} avoids gratuitous
26900 rearrangement of the argument of the sine.)
26906 Similarly, here is a rule that implements an inverse-@code{erf}
26907 function. It uses @code{root} to search for a solution. If
26908 @code{root} succeeds, it will return a vector of two numbers
26909 where the first number is the desired solution. If no solution
26910 is found, @code{root} remains in symbolic form. So we use
26911 @code{let} to check that the result was indeed a vector.
26914 ierf(x) := y :: let([y,z] := root(erf(a) = x, a, .5))
26918 The meta-variable @var{v}, which must already have been matched
26919 to something elsewhere in the rule, is compared against pattern
26920 @var{p}. Since @code{matches} is a standard Calc function, it
26921 can appear anywhere in a condition. But if it appears alone or
26922 as a term of a top-level @samp{&&}, then you get the special
26923 extra feature that meta-variables which are bound to things
26924 inside @var{p} can be used elsewhere in the surrounding rewrite
26927 The only real difference between @samp{let(p := v)} and
26928 @samp{matches(v, p)} is that the former evaluates @samp{v} using
26929 the default simplifications, while the latter does not.
26933 This is actually a variable, not a function. If @code{remember}
26934 appears as a condition in a rule, then when that rule succeeds
26935 the original expression and rewritten expression are added to the
26936 front of the rule set that contained the rule. If the rule set
26937 was not stored in a variable, @code{remember} is ignored. The
26938 lefthand side is enclosed in @code{quote} in the added rule if it
26939 contains any variables.
26941 For example, the rule @samp{f(n) := n f(n-1) :: remember} applied
26942 to @samp{f(7)} will add the rule @samp{f(7) := 7 f(6)} to the front
26943 of the rule set. The rule set @code{EvalRules} works slightly
26944 differently: There, the evaluation of @samp{f(6)} will complete before
26945 the result is added to the rule set, in this case as @samp{f(7) := 5040}.
26946 Thus @code{remember} is most useful inside @code{EvalRules}.
26948 It is up to you to ensure that the optimization performed by
26949 @code{remember} is safe. For example, the rule @samp{foo(n) := n
26950 :: evalv(eatfoo) > 0 :: remember} is a bad idea (@code{evalv} is
26951 the function equivalent of the @kbd{=} command); if the variable
26952 @code{eatfoo} ever contains 1, rules like @samp{foo(7) := 7} will
26953 be added to the rule set and will continue to operate even if
26954 @code{eatfoo} is later changed to 0.
26961 Remember the match as described above, but only if condition @expr{c}
26962 is true. For example, @samp{remember(n % 4 = 0)} in the above factorial
26963 rule remembers only every fourth result. Note that @samp{remember(1)}
26964 is equivalent to @samp{remember}, and @samp{remember(0)} has no effect.
26967 @node Composing Patterns in Rewrite Rules, Nested Formulas with Rewrite Rules, Other Features of Rewrite Rules, Rewrite Rules
26968 @subsection Composing Patterns in Rewrite Rules
26971 There are three operators, @samp{&&&}, @samp{|||}, and @samp{!!!},
26972 that combine rewrite patterns to make larger patterns. The
26973 combinations are ``and,'' ``or,'' and ``not,'' respectively, and
26974 these operators are the pattern equivalents of @samp{&&}, @samp{||}
26975 and @samp{!} (which operate on zero-or-nonzero logical values).
26977 Note that @samp{&&&}, @samp{|||}, and @samp{!!!} are left in symbolic
26978 form by all regular Calc features; they have special meaning only in
26979 the context of rewrite rule patterns.
26981 The pattern @samp{@var{p1} &&& @var{p2}} matches anything that
26982 matches both @var{p1} and @var{p2}. One especially useful case is
26983 when one of @var{p1} or @var{p2} is a meta-variable. For example,
26984 here is a rule that operates on error forms:
26987 f(x &&& a +/- b, x) := g(x)
26990 This does the same thing, but is arguably simpler than, the rule
26993 f(a +/- b, a +/- b) := g(a +/- b)
27000 Here's another interesting example:
27003 ends(cons(a, x) &&& rcons(y, b)) := [a, b]
27007 which effectively clips out the middle of a vector leaving just
27008 the first and last elements. This rule will change a one-element
27009 vector @samp{[a]} to @samp{[a, a]}. The similar rule
27012 ends(cons(a, rcons(y, b))) := [a, b]
27016 would do the same thing except that it would fail to match a
27017 one-element vector.
27023 The pattern @samp{@var{p1} ||| @var{p2}} matches anything that
27024 matches either @var{p1} or @var{p2}. Calc first tries matching
27025 against @var{p1}; if that fails, it goes on to try @var{p2}.
27031 A simple example of @samp{|||} is
27034 curve(inf ||| -inf) := 0
27038 which converts both @samp{curve(inf)} and @samp{curve(-inf)} to zero.
27040 Here is a larger example:
27043 log(a, b) ||| (ln(a) :: let(b := e)) := mylog(a, b)
27046 This matches both generalized and natural logarithms in a single rule.
27047 Note that the @samp{::} term must be enclosed in parentheses because
27048 that operator has lower precedence than @samp{|||} or @samp{:=}.
27050 (In practice this rule would probably include a third alternative,
27051 omitted here for brevity, to take care of @code{log10}.)
27053 While Calc generally treats interior conditions exactly the same as
27054 conditions on the outside of a rule, it does guarantee that if all the
27055 variables in the condition are special names like @code{e}, or already
27056 bound in the pattern to which the condition is attached (say, if
27057 @samp{a} had appeared in this condition), then Calc will process this
27058 condition right after matching the pattern to the left of the @samp{::}.
27059 Thus, we know that @samp{b} will be bound to @samp{e} only if the
27060 @code{ln} branch of the @samp{|||} was taken.
27062 Note that this rule was careful to bind the same set of meta-variables
27063 on both sides of the @samp{|||}. Calc does not check this, but if
27064 you bind a certain meta-variable only in one branch and then use that
27065 meta-variable elsewhere in the rule, results are unpredictable:
27068 f(a,b) ||| g(b) := h(a,b)
27071 Here if the pattern matches @samp{g(17)}, Calc makes no promises about
27072 the value that will be substituted for @samp{a} on the righthand side.
27078 The pattern @samp{!!! @var{pat}} matches anything that does not
27079 match @var{pat}. Any meta-variables that are bound while matching
27080 @var{pat} remain unbound outside of @var{pat}.
27085 f(x &&& !!! a +/- b, !!![]) := g(x)
27089 converts @code{f} whose first argument is anything @emph{except} an
27090 error form, and whose second argument is not the empty vector, into
27091 a similar call to @code{g} (but without the second argument).
27093 If we know that the second argument will be a vector (empty or not),
27094 then an equivalent rule would be:
27097 f(x, y) := g(x) :: typeof(x) != 7 :: vlen(y) > 0
27101 where of course 7 is the @code{typeof} code for error forms.
27102 Another final condition, that works for any kind of @samp{y},
27103 would be @samp{!istrue(y == [])}. (The @code{istrue} function
27104 returns an explicit 0 if its argument was left in symbolic form;
27105 plain @samp{!(y == [])} or @samp{y != []} would not work to replace
27106 @samp{!!![]} since these would be left unsimplified, and thus cause
27107 the rule to fail, if @samp{y} was something like a variable name.)
27109 It is possible for a @samp{!!!} to refer to meta-variables bound
27110 elsewhere in the pattern. For example,
27117 matches any call to @code{f} with different arguments, changing
27118 this to @code{g} with only the first argument.
27120 If a function call is to be matched and one of the argument patterns
27121 contains a @samp{!!!} somewhere inside it, that argument will be
27129 will be careful to bind @samp{a} to the second argument of @code{f}
27130 before testing the first argument. If Calc had tried to match the
27131 first argument of @code{f} first, the results would have been
27132 disastrous: since @code{a} was unbound so far, the pattern @samp{a}
27133 would have matched anything at all, and the pattern @samp{!!!a}
27134 therefore would @emph{not} have matched anything at all!
27136 @node Nested Formulas with Rewrite Rules, Multi-Phase Rewrite Rules, Composing Patterns in Rewrite Rules, Rewrite Rules
27137 @subsection Nested Formulas with Rewrite Rules
27140 When @kbd{a r} (@code{calc-rewrite}) is used, it takes an expression from
27141 the top of the stack and attempts to match any of the specified rules
27142 to any part of the expression, starting with the whole expression
27143 and then, if that fails, trying deeper and deeper sub-expressions.
27144 For each part of the expression, the rules are tried in the order
27145 they appear in the rules vector. The first rule to match the first
27146 sub-expression wins; it replaces the matched sub-expression according
27147 to the @var{new} part of the rule.
27149 Often, the rule set will match and change the formula several times.
27150 The top-level formula is first matched and substituted repeatedly until
27151 it no longer matches the pattern; then, sub-formulas are tried, and
27152 so on. Once every part of the formula has gotten its chance, the
27153 rewrite mechanism starts over again with the top-level formula
27154 (in case a substitution of one of its arguments has caused it again
27155 to match). This continues until no further matches can be made
27156 anywhere in the formula.
27158 It is possible for a rule set to get into an infinite loop. The
27159 most obvious case, replacing a formula with itself, is not a problem
27160 because a rule is not considered to ``succeed'' unless the righthand
27161 side actually comes out to something different than the original
27162 formula or sub-formula that was matched. But if you accidentally
27163 had both @samp{ln(a b) := ln(a) + ln(b)} and the reverse
27164 @samp{ln(a) + ln(b) := ln(a b)} in your rule set, Calc would
27165 run forever switching a formula back and forth between the two
27168 To avoid disaster, Calc normally stops after 100 changes have been
27169 made to the formula. This will be enough for most multiple rewrites,
27170 but it will keep an endless loop of rewrites from locking up the
27171 computer forever. (On most systems, you can also type @kbd{C-g} to
27172 halt any Emacs command prematurely.)
27174 To change this limit, give a positive numeric prefix argument.
27175 In particular, @kbd{M-1 a r} applies only one rewrite at a time,
27176 useful when you are first testing your rule (or just if repeated
27177 rewriting is not what is called for by your application).
27186 You can also put a ``function call'' @samp{iterations(@var{n})}
27187 in place of a rule anywhere in your rules vector (but usually at
27188 the top). Then, @var{n} will be used instead of 100 as the default
27189 number of iterations for this rule set. You can use
27190 @samp{iterations(inf)} if you want no iteration limit by default.
27191 A prefix argument will override the @code{iterations} limit in the
27199 More precisely, the limit controls the number of ``iterations,''
27200 where each iteration is a successful matching of a rule pattern whose
27201 righthand side, after substituting meta-variables and applying the
27202 default simplifications, is different from the original sub-formula
27205 A prefix argument of zero sets the limit to infinity. Use with caution!
27207 Given a negative numeric prefix argument, @kbd{a r} will match and
27208 substitute the top-level expression up to that many times, but
27209 will not attempt to match the rules to any sub-expressions.
27211 In a formula, @code{rewrite(@var{expr}, @var{rules}, @var{n})}
27212 does a rewriting operation. Here @var{expr} is the expression
27213 being rewritten, @var{rules} is the rule, vector of rules, or
27214 variable containing the rules, and @var{n} is the optional
27215 iteration limit, which may be a positive integer, a negative
27216 integer, or @samp{inf} or @samp{-inf}. If @var{n} is omitted
27217 the @code{iterations} value from the rule set is used; if both
27218 are omitted, 100 is used.
27220 @node Multi-Phase Rewrite Rules, Selections with Rewrite Rules, Nested Formulas with Rewrite Rules, Rewrite Rules
27221 @subsection Multi-Phase Rewrite Rules
27224 It is possible to separate a rewrite rule set into several @dfn{phases}.
27225 During each phase, certain rules will be enabled while certain others
27226 will be disabled. A @dfn{phase schedule} controls the order in which
27227 phases occur during the rewriting process.
27234 If a call to the marker function @code{phase} appears in the rules
27235 vector in place of a rule, all rules following that point will be
27236 members of the phase(s) identified in the arguments to @code{phase}.
27237 Phases are given integer numbers. The markers @samp{phase()} and
27238 @samp{phase(all)} both mean the following rules belong to all phases;
27239 this is the default at the start of the rule set.
27241 If you do not explicitly schedule the phases, Calc sorts all phase
27242 numbers that appear in the rule set and executes the phases in
27243 ascending order. For example, the rule set
27260 has three phases, 1 through 3. Phase 1 consists of the @code{f0},
27261 @code{f1}, and @code{f4} rules (in that order). Phase 2 consists of
27262 @code{f0}, @code{f2}, and @code{f4}. Phase 3 consists of @code{f0}
27265 When Calc rewrites a formula using this rule set, it first rewrites
27266 the formula using only the phase 1 rules until no further changes are
27267 possible. Then it switches to the phase 2 rule set and continues
27268 until no further changes occur, then finally rewrites with phase 3.
27269 When no more phase 3 rules apply, rewriting finishes. (This is
27270 assuming @kbd{a r} with a large enough prefix argument to allow the
27271 rewriting to run to completion; the sequence just described stops
27272 early if the number of iterations specified in the prefix argument,
27273 100 by default, is reached.)
27275 During each phase, Calc descends through the nested levels of the
27276 formula as described previously. (@xref{Nested Formulas with Rewrite
27277 Rules}.) Rewriting starts at the top of the formula, then works its
27278 way down to the parts, then goes back to the top and works down again.
27279 The phase 2 rules do not begin until no phase 1 rules apply anywhere
27286 A @code{schedule} marker appearing in the rule set (anywhere, but
27287 conventionally at the top) changes the default schedule of phases.
27288 In the simplest case, @code{schedule} has a sequence of phase numbers
27289 for arguments; each phase number is invoked in turn until the
27290 arguments to @code{schedule} are exhausted. Thus adding
27291 @samp{schedule(3,2,1)} at the top of the above rule set would
27292 reverse the order of the phases; @samp{schedule(1,2,3)} would have
27293 no effect since this is the default schedule; and @samp{schedule(1,2,1,3)}
27294 would give phase 1 a second chance after phase 2 has completed, before
27295 moving on to phase 3.
27297 Any argument to @code{schedule} can instead be a vector of phase
27298 numbers (or even of sub-vectors). Then the sub-sequence of phases
27299 described by the vector are tried repeatedly until no change occurs
27300 in any phase in the sequence. For example, @samp{schedule([1, 2], 3)}
27301 tries phase 1, then phase 2, then, if either phase made any changes
27302 to the formula, repeats these two phases until they can make no
27303 further progress. Finally, it goes on to phase 3 for finishing
27306 Also, items in @code{schedule} can be variable names as well as
27307 numbers. A variable name is interpreted as the name of a function
27308 to call on the whole formula. For example, @samp{schedule(1, simplify)}
27309 says to apply the phase-1 rules (presumably, all of them), then to
27310 call @code{simplify} which is the function name equivalent of @kbd{a s}.
27311 Likewise, @samp{schedule([1, simplify])} says to alternate between
27312 phase 1 and @kbd{a s} until no further changes occur.
27314 Phases can be used purely to improve efficiency; if it is known that
27315 a certain group of rules will apply only at the beginning of rewriting,
27316 and a certain other group will apply only at the end, then rewriting
27317 will be faster if these groups are identified as separate phases.
27318 Once the phase 1 rules are done, Calc can put them aside and no longer
27319 spend any time on them while it works on phase 2.
27321 There are also some problems that can only be solved with several
27322 rewrite phases. For a real-world example of a multi-phase rule set,
27323 examine the set @code{FitRules}, which is used by the curve-fitting
27324 command to convert a model expression to linear form.
27325 @xref{Curve Fitting Details}. This set is divided into four phases.
27326 The first phase rewrites certain kinds of expressions to be more
27327 easily linearizable, but less computationally efficient. After the
27328 linear components have been picked out, the final phase includes the
27329 opposite rewrites to put each component back into an efficient form.
27330 If both sets of rules were included in one big phase, Calc could get
27331 into an infinite loop going back and forth between the two forms.
27333 Elsewhere in @code{FitRules}, the components are first isolated,
27334 then recombined where possible to reduce the complexity of the linear
27335 fit, then finally packaged one component at a time into vectors.
27336 If the packaging rules were allowed to begin before the recombining
27337 rules were finished, some components might be put away into vectors
27338 before they had a chance to recombine. By putting these rules in
27339 two separate phases, this problem is neatly avoided.
27341 @node Selections with Rewrite Rules, Matching Commands, Multi-Phase Rewrite Rules, Rewrite Rules
27342 @subsection Selections with Rewrite Rules
27345 If a sub-formula of the current formula is selected (as by @kbd{j s};
27346 @pxref{Selecting Subformulas}), the @kbd{a r} (@code{calc-rewrite})
27347 command applies only to that sub-formula. Together with a negative
27348 prefix argument, you can use this fact to apply a rewrite to one
27349 specific part of a formula without affecting any other parts.
27352 @pindex calc-rewrite-selection
27353 The @kbd{j r} (@code{calc-rewrite-selection}) command allows more
27354 sophisticated operations on selections. This command prompts for
27355 the rules in the same way as @kbd{a r}, but it then applies those
27356 rules to the whole formula in question even though a sub-formula
27357 of it has been selected. However, the selected sub-formula will
27358 first have been surrounded by a @samp{select( )} function call.
27359 (Calc's evaluator does not understand the function name @code{select};
27360 this is only a tag used by the @kbd{j r} command.)
27362 For example, suppose the formula on the stack is @samp{2 (a + b)^2}
27363 and the sub-formula @samp{a + b} is selected. This formula will
27364 be rewritten to @samp{2 select(a + b)^2} and then the rewrite
27365 rules will be applied in the usual way. The rewrite rules can
27366 include references to @code{select} to tell where in the pattern
27367 the selected sub-formula should appear.
27369 If there is still exactly one @samp{select( )} function call in
27370 the formula after rewriting is done, it indicates which part of
27371 the formula should be selected afterwards. Otherwise, the
27372 formula will be unselected.
27374 You can make @kbd{j r} act much like @kbd{a r} by enclosing both parts
27375 of the rewrite rule with @samp{select()}. However, @kbd{j r}
27376 allows you to use the current selection in more flexible ways.
27377 Suppose you wished to make a rule which removed the exponent from
27378 the selected term; the rule @samp{select(a)^x := select(a)} would
27379 work. In the above example, it would rewrite @samp{2 select(a + b)^2}
27380 to @samp{2 select(a + b)}. This would then be returned to the
27381 stack as @samp{2 (a + b)} with the @samp{a + b} selected.
27383 The @kbd{j r} command uses one iteration by default, unlike
27384 @kbd{a r} which defaults to 100 iterations. A numeric prefix
27385 argument affects @kbd{j r} in the same way as @kbd{a r}.
27386 @xref{Nested Formulas with Rewrite Rules}.
27388 As with other selection commands, @kbd{j r} operates on the stack
27389 entry that contains the cursor. (If the cursor is on the top-of-stack
27390 @samp{.} marker, it works as if the cursor were on the formula
27393 If you don't specify a set of rules, the rules are taken from the
27394 top of the stack, just as with @kbd{a r}. In this case, the
27395 cursor must indicate stack entry 2 or above as the formula to be
27396 rewritten (otherwise the same formula would be used as both the
27397 target and the rewrite rules).
27399 If the indicated formula has no selection, the cursor position within
27400 the formula temporarily selects a sub-formula for the purposes of this
27401 command. If the cursor is not on any sub-formula (e.g., it is in
27402 the line-number area to the left of the formula), the @samp{select( )}
27403 markers are ignored by the rewrite mechanism and the rules are allowed
27404 to apply anywhere in the formula.
27406 As a special feature, the normal @kbd{a r} command also ignores
27407 @samp{select( )} calls in rewrite rules. For example, if you used the
27408 above rule @samp{select(a)^x := select(a)} with @kbd{a r}, it would apply
27409 the rule as if it were @samp{a^x := a}. Thus, you can write general
27410 purpose rules with @samp{select( )} hints inside them so that they
27411 will ``do the right thing'' in both @kbd{a r} and @kbd{j r},
27412 both with and without selections.
27414 @node Matching Commands, Automatic Rewrites, Selections with Rewrite Rules, Rewrite Rules
27415 @subsection Matching Commands
27421 The @kbd{a m} (@code{calc-match}) [@code{match}] function takes a
27422 vector of formulas and a rewrite-rule-style pattern, and produces
27423 a vector of all formulas which match the pattern. The command
27424 prompts you to enter the pattern; as for @kbd{a r}, you can enter
27425 a single pattern (i.e., a formula with meta-variables), or a
27426 vector of patterns, or a variable which contains patterns, or
27427 you can give a blank response in which case the patterns are taken
27428 from the top of the stack. The pattern set will be compiled once
27429 and saved if it is stored in a variable. If there are several
27430 patterns in the set, vector elements are kept if they match any
27433 For example, @samp{match(a+b, [x, x+y, x-y, 7, x+y+z])}
27434 will return @samp{[x+y, x-y, x+y+z]}.
27436 The @code{import} mechanism is not available for pattern sets.
27438 The @kbd{a m} command can also be used to extract all vector elements
27439 which satisfy any condition: The pattern @samp{x :: x>0} will select
27440 all the positive vector elements.
27444 With the Inverse flag [@code{matchnot}], this command extracts all
27445 vector elements which do @emph{not} match the given pattern.
27451 There is also a function @samp{matches(@var{x}, @var{p})} which
27452 evaluates to 1 if expression @var{x} matches pattern @var{p}, or
27453 to 0 otherwise. This is sometimes useful for including into the
27454 conditional clauses of other rewrite rules.
27460 The function @code{vmatches} is just like @code{matches}, except
27461 that if the match succeeds it returns a vector of assignments to
27462 the meta-variables instead of the number 1. For example,
27463 @samp{vmatches(f(1,2), f(a,b))} returns @samp{[a := 1, b := 2]}.
27464 If the match fails, the function returns the number 0.
27466 @node Automatic Rewrites, Debugging Rewrites, Matching Commands, Rewrite Rules
27467 @subsection Automatic Rewrites
27470 @cindex @code{EvalRules} variable
27472 It is possible to get Calc to apply a set of rewrite rules on all
27473 results, effectively adding to the built-in set of default
27474 simplifications. To do this, simply store your rule set in the
27475 variable @code{EvalRules}. There is a convenient @kbd{s E} command
27476 for editing @code{EvalRules}; @pxref{Operations on Variables}.
27478 For example, suppose you want @samp{sin(a + b)} to be expanded out
27479 to @samp{sin(b) cos(a) + cos(b) sin(a)} wherever it appears, and
27480 similarly for @samp{cos(a + b)}. The corresponding rewrite rule
27485 [ sin(a + b) := cos(a) sin(b) + sin(a) cos(b),
27486 cos(a + b) := cos(a) cos(b) - sin(a) sin(b) ]
27490 To apply these manually, you could put them in a variable called
27491 @code{trigexp} and then use @kbd{a r trigexp} every time you wanted
27492 to expand trig functions. But if instead you store them in the
27493 variable @code{EvalRules}, they will automatically be applied to all
27494 sines and cosines of sums. Then, with @samp{2 x} and @samp{45} on
27495 the stack, typing @kbd{+ S} will (assuming Degrees mode) result in
27496 @samp{0.7071 sin(2 x) + 0.7071 cos(2 x)} automatically.
27498 As each level of a formula is evaluated, the rules from
27499 @code{EvalRules} are applied before the default simplifications.
27500 Rewriting continues until no further @code{EvalRules} apply.
27501 Note that this is different from the usual order of application of
27502 rewrite rules: @code{EvalRules} works from the bottom up, simplifying
27503 the arguments to a function before the function itself, while @kbd{a r}
27504 applies rules from the top down.
27506 Because the @code{EvalRules} are tried first, you can use them to
27507 override the normal behavior of any built-in Calc function.
27509 It is important not to write a rule that will get into an infinite
27510 loop. For example, the rule set @samp{[f(0) := 1, f(n) := n f(n-1)]}
27511 appears to be a good definition of a factorial function, but it is
27512 unsafe. Imagine what happens if @samp{f(2.5)} is simplified. Calc
27513 will continue to subtract 1 from this argument forever without reaching
27514 zero. A safer second rule would be @samp{f(n) := n f(n-1) :: n>0}.
27515 Another dangerous rule is @samp{g(x, y) := g(y, x)}. Rewriting
27516 @samp{g(2, 4)}, this would bounce back and forth between that and
27517 @samp{g(4, 2)} forever. If an infinite loop in @code{EvalRules}
27518 occurs, Emacs will eventually stop with a ``Computation got stuck
27519 or ran too long'' message.
27521 Another subtle difference between @code{EvalRules} and regular rewrites
27522 concerns rules that rewrite a formula into an identical formula. For
27523 example, @samp{f(n) := f(floor(n))} ``fails to match'' when @expr{n} is
27524 already an integer. But in @code{EvalRules} this case is detected only
27525 if the righthand side literally becomes the original formula before any
27526 further simplification. This means that @samp{f(n) := f(floor(n))} will
27527 get into an infinite loop if it occurs in @code{EvalRules}. Calc will
27528 replace @samp{f(6)} with @samp{f(floor(6))}, which is different from
27529 @samp{f(6)}, so it will consider the rule to have matched and will
27530 continue simplifying that formula; first the argument is simplified
27531 to get @samp{f(6)}, then the rule matches again to get @samp{f(floor(6))}
27532 again, ad infinitum. A much safer rule would check its argument first,
27533 say, with @samp{f(n) := f(floor(n)) :: !dint(n)}.
27535 (What really happens is that the rewrite mechanism substitutes the
27536 meta-variables in the righthand side of a rule, compares to see if the
27537 result is the same as the original formula and fails if so, then uses
27538 the default simplifications to simplify the result and compares again
27539 (and again fails if the formula has simplified back to its original
27540 form). The only special wrinkle for the @code{EvalRules} is that the
27541 same rules will come back into play when the default simplifications
27542 are used. What Calc wants to do is build @samp{f(floor(6))}, see that
27543 this is different from the original formula, simplify to @samp{f(6)},
27544 see that this is the same as the original formula, and thus halt the
27545 rewriting. But while simplifying, @samp{f(6)} will again trigger
27546 the same @code{EvalRules} rule and Calc will get into a loop inside
27547 the rewrite mechanism itself.)
27549 The @code{phase}, @code{schedule}, and @code{iterations} markers do
27550 not work in @code{EvalRules}. If the rule set is divided into phases,
27551 only the phase 1 rules are applied, and the schedule is ignored.
27552 The rules are always repeated as many times as possible.
27554 The @code{EvalRules} are applied to all function calls in a formula,
27555 but not to numbers (and other number-like objects like error forms),
27556 nor to vectors or individual variable names. (Though they will apply
27557 to @emph{components} of vectors and error forms when appropriate.) You
27558 might try to make a variable @code{phihat} which automatically expands
27559 to its definition without the need to press @kbd{=} by writing the
27560 rule @samp{quote(phihat) := (1-sqrt(5))/2}, but unfortunately this rule
27561 will not work as part of @code{EvalRules}.
27563 Finally, another limitation is that Calc sometimes calls its built-in
27564 functions directly rather than going through the default simplifications.
27565 When it does this, @code{EvalRules} will not be able to override those
27566 functions. For example, when you take the absolute value of the complex
27567 number @expr{(2, 3)}, Calc computes @samp{sqrt(2*2 + 3*3)} by calling
27568 the multiplication, addition, and square root functions directly rather
27569 than applying the default simplifications to this formula. So an
27570 @code{EvalRules} rule that (perversely) rewrites @samp{sqrt(13) := 6}
27571 would not apply. (However, if you put Calc into Symbolic mode so that
27572 @samp{sqrt(13)} will be left in symbolic form by the built-in square
27573 root function, your rule will be able to apply. But if the complex
27574 number were @expr{(3,4)}, so that @samp{sqrt(25)} must be calculated,
27575 then Symbolic mode will not help because @samp{sqrt(25)} can be
27576 evaluated exactly to 5.)
27578 One subtle restriction that normally only manifests itself with
27579 @code{EvalRules} is that while a given rewrite rule is in the process
27580 of being checked, that same rule cannot be recursively applied. Calc
27581 effectively removes the rule from its rule set while checking the rule,
27582 then puts it back once the match succeeds or fails. (The technical
27583 reason for this is that compiled pattern programs are not reentrant.)
27584 For example, consider the rule @samp{foo(x) := x :: foo(x/2) > 0}
27585 attempting to match @samp{foo(8)}. This rule will be inactive while
27586 the condition @samp{foo(4) > 0} is checked, even though it might be
27587 an integral part of evaluating that condition. Note that this is not
27588 a problem for the more usual recursive type of rule, such as
27589 @samp{foo(x) := foo(x/2)}, because there the rule has succeeded and
27590 been reactivated by the time the righthand side is evaluated.
27592 If @code{EvalRules} has no stored value (its default state), or if
27593 anything but a vector is stored in it, then it is ignored.
27595 Even though Calc's rewrite mechanism is designed to compare rewrite
27596 rules to formulas as quickly as possible, storing rules in
27597 @code{EvalRules} may make Calc run substantially slower. This is
27598 particularly true of rules where the top-level call is a commonly used
27599 function, or is not fixed. The rule @samp{f(n) := n f(n-1) :: n>0} will
27600 only activate the rewrite mechanism for calls to the function @code{f},
27601 but @samp{lg(n) + lg(m) := lg(n m)} will check every @samp{+} operator.
27604 apply(f, [a*b]) := apply(f, [a]) + apply(f, [b]) :: in(f, [ln, log10])
27608 may seem more ``efficient'' than two separate rules for @code{ln} and
27609 @code{log10}, but actually it is vastly less efficient because rules
27610 with @code{apply} as the top-level pattern must be tested against
27611 @emph{every} function call that is simplified.
27613 @cindex @code{AlgSimpRules} variable
27614 @vindex AlgSimpRules
27615 Suppose you want @samp{sin(a + b)} to be expanded out not all the time,
27616 but only when algebraic simplifications are used to simplify the
27617 formula. The variable @code{AlgSimpRules} holds rules for this purpose.
27618 The @kbd{a s} command will apply @code{EvalRules} and
27619 @code{AlgSimpRules} to the formula, as well as all of its built-in
27622 Most of the special limitations for @code{EvalRules} don't apply to
27623 @code{AlgSimpRules}. Calc simply does an @kbd{a r AlgSimpRules}
27624 command with an infinite repeat count as the first step of algebraic
27625 simplifications. It then applies its own built-in simplifications
27626 throughout the formula, and then repeats these two steps (along with
27627 applying the default simplifications) until no further changes are
27630 @cindex @code{ExtSimpRules} variable
27631 @cindex @code{UnitSimpRules} variable
27632 @vindex ExtSimpRules
27633 @vindex UnitSimpRules
27634 There are also @code{ExtSimpRules} and @code{UnitSimpRules} variables
27635 that are used by @kbd{a e} and @kbd{u s}, respectively; these commands
27636 also apply @code{EvalRules} and @code{AlgSimpRules}. The variable
27637 @code{IntegSimpRules} contains simplification rules that are used
27638 only during integration by @kbd{a i}.
27640 @node Debugging Rewrites, Examples of Rewrite Rules, Automatic Rewrites, Rewrite Rules
27641 @subsection Debugging Rewrites
27644 If a buffer named @file{*Trace*} exists, the rewrite mechanism will
27645 record some useful information there as it operates. The original
27646 formula is written there, as is the result of each successful rewrite,
27647 and the final result of the rewriting. All phase changes are also
27650 Calc always appends to @file{*Trace*}. You must empty this buffer
27651 yourself periodically if it is in danger of growing unwieldy.
27653 Note that the rewriting mechanism is substantially slower when the
27654 @file{*Trace*} buffer exists, even if the buffer is not visible on
27655 the screen. Once you are done, you will probably want to kill this
27656 buffer (with @kbd{C-x k *Trace* @key{RET}}). If you leave it in
27657 existence and forget about it, all your future rewrite commands will
27658 be needlessly slow.
27660 @node Examples of Rewrite Rules, , Debugging Rewrites, Rewrite Rules
27661 @subsection Examples of Rewrite Rules
27664 Returning to the example of substituting the pattern
27665 @samp{sin(x)^2 + cos(x)^2} with 1, we saw that the rule
27666 @samp{opt(a) sin(x)^2 + opt(a) cos(x)^2 := a} does a good job of
27667 finding suitable cases. Another solution would be to use the rule
27668 @samp{cos(x)^2 := 1 - sin(x)^2}, followed by algebraic simplification
27669 if necessary. This rule will be the most effective way to do the job,
27670 but at the expense of making some changes that you might not desire.
27672 Another algebraic rewrite rule is @samp{exp(x+y) := exp(x) exp(y)}.
27673 To make this work with the @w{@kbd{j r}} command so that it can be
27674 easily targeted to a particular exponential in a large formula,
27675 you might wish to write the rule as @samp{select(exp(x+y)) :=
27676 select(exp(x) exp(y))}. The @samp{select} markers will be
27677 ignored by the regular @kbd{a r} command
27678 (@pxref{Selections with Rewrite Rules}).
27680 A surprisingly useful rewrite rule is @samp{a/(b-c) := a*(b+c)/(b^2-c^2)}.
27681 This will simplify the formula whenever @expr{b} and/or @expr{c} can
27682 be made simpler by squaring. For example, applying this rule to
27683 @samp{2 / (sqrt(2) + 3)} yields @samp{6:7 - 2:7 sqrt(2)} (assuming
27684 Symbolic mode has been enabled to keep the square root from being
27685 evaluated to a floating-point approximation). This rule is also
27686 useful when working with symbolic complex numbers, e.g.,
27687 @samp{(a + b i) / (c + d i)}.
27689 As another example, we could define our own ``triangular numbers'' function
27690 with the rules @samp{[tri(0) := 0, tri(n) := n + tri(n-1) :: n>0]}. Enter
27691 this vector and store it in a variable: @kbd{@w{s t} trirules}. Now, given
27692 a suitable formula like @samp{tri(5)} on the stack, type @samp{a r trirules}
27693 to apply these rules repeatedly. After six applications, @kbd{a r} will
27694 stop with 15 on the stack. Once these rules are debugged, it would probably
27695 be most useful to add them to @code{EvalRules} so that Calc will evaluate
27696 the new @code{tri} function automatically. We could then use @kbd{Z K} on
27697 the keyboard macro @kbd{' tri($) @key{RET}} to make a command that applies
27698 @code{tri} to the value on the top of the stack. @xref{Programming}.
27700 @cindex Quaternions
27701 The following rule set, contributed by
27702 @texline Fran\c cois
27704 Pinard, implements @dfn{quaternions}, a generalization of the concept of
27705 complex numbers. Quaternions have four components, and are here
27706 represented by function calls @samp{quat(@var{w}, [@var{x}, @var{y},
27707 @var{z}])} with ``real part'' @var{w} and the three ``imaginary'' parts
27708 collected into a vector. Various arithmetical operations on quaternions
27709 are supported. To use these rules, either add them to @code{EvalRules},
27710 or create a command based on @kbd{a r} for simplifying quaternion
27711 formulas. A convenient way to enter quaternions would be a command
27712 defined by a keyboard macro containing: @kbd{' quat($$$$, [$$$, $$, $])
27716 [ quat(w, x, y, z) := quat(w, [x, y, z]),
27717 quat(w, [0, 0, 0]) := w,
27718 abs(quat(w, v)) := hypot(w, v),
27719 -quat(w, v) := quat(-w, -v),
27720 r + quat(w, v) := quat(r + w, v) :: real(r),
27721 r - quat(w, v) := quat(r - w, -v) :: real(r),
27722 quat(w1, v1) + quat(w2, v2) := quat(w1 + w2, v1 + v2),
27723 r * quat(w, v) := quat(r * w, r * v) :: real(r),
27724 plain(quat(w1, v1) * quat(w2, v2))
27725 := quat(w1 * w2 - v1 * v2, w1 * v2 + w2 * v1 + cross(v1, v2)),
27726 quat(w1, v1) / r := quat(w1 / r, v1 / r) :: real(r),
27727 z / quat(w, v) := z * quatinv(quat(w, v)),
27728 quatinv(quat(w, v)) := quat(w, -v) / (w^2 + v^2),
27729 quatsqr(quat(w, v)) := quat(w^2 - v^2, 2 * w * v),
27730 quat(w, v)^k := quatsqr(quat(w, v)^(k / 2))
27731 :: integer(k) :: k > 0 :: k % 2 = 0,
27732 quat(w, v)^k := quatsqr(quat(w, v)^((k - 1) / 2)) * quat(w, v)
27733 :: integer(k) :: k > 2,
27734 quat(w, v)^-k := quatinv(quat(w, v)^k) :: integer(k) :: k > 0 ]
27737 Quaternions, like matrices, have non-commutative multiplication.
27738 In other words, @expr{q1 * q2 = q2 * q1} is not necessarily true if
27739 @expr{q1} and @expr{q2} are @code{quat} forms. The @samp{quat*quat}
27740 rule above uses @code{plain} to prevent Calc from rearranging the
27741 product. It may also be wise to add the line @samp{[quat(), matrix]}
27742 to the @code{Decls} matrix, to ensure that Calc's other algebraic
27743 operations will not rearrange a quaternion product. @xref{Declarations}.
27745 These rules also accept a four-argument @code{quat} form, converting
27746 it to the preferred form in the first rule. If you would rather see
27747 results in the four-argument form, just append the two items
27748 @samp{phase(2), quat(w, [x, y, z]) := quat(w, x, y, z)} to the end
27749 of the rule set. (But remember that multi-phase rule sets don't work
27750 in @code{EvalRules}.)
27752 @node Units, Store and Recall, Algebra, Top
27753 @chapter Operating on Units
27756 One special interpretation of algebraic formulas is as numbers with units.
27757 For example, the formula @samp{5 m / s^2} can be read ``five meters
27758 per second squared.'' The commands in this chapter help you
27759 manipulate units expressions in this form. Units-related commands
27760 begin with the @kbd{u} prefix key.
27763 * Basic Operations on Units::
27764 * The Units Table::
27765 * Predefined Units::
27766 * User-Defined Units::
27767 * Logarithmic Units::
27771 @node Basic Operations on Units, The Units Table, Units, Units
27772 @section Basic Operations on Units
27775 A @dfn{units expression} is a formula which is basically a number
27776 multiplied and/or divided by one or more @dfn{unit names}, which may
27777 optionally be raised to integer powers. Actually, the value part need not
27778 be a number; any product or quotient involving unit names is a units
27779 expression. Many of the units commands will also accept any formula,
27780 where the command applies to all units expressions which appear in the
27783 A unit name is a variable whose name appears in the @dfn{unit table},
27784 or a variable whose name is a prefix character like @samp{k} (for ``kilo'')
27785 or @samp{u} (for ``micro'') followed by a name in the unit table.
27786 A substantial table of built-in units is provided with Calc;
27787 @pxref{Predefined Units}. You can also define your own unit names;
27788 @pxref{User-Defined Units}.
27790 Note that if the value part of a units expression is exactly @samp{1},
27791 it will be removed by the Calculator's automatic algebra routines: The
27792 formula @samp{1 mm} is ``simplified'' to @samp{mm}. This is only a
27793 display anomaly, however; @samp{mm} will work just fine as a
27794 representation of one millimeter.
27796 You may find that Algebraic mode (@pxref{Algebraic Entry}) makes working
27797 with units expressions easier. Otherwise, you will have to remember
27798 to hit the apostrophe key every time you wish to enter units.
27801 @pindex calc-simplify-units
27803 @mindex usimpl@idots
27806 The @kbd{u s} (@code{calc-simplify-units}) [@code{usimplify}] command
27808 expression. It uses Calc's algebraic simplifications to simplify the
27809 expression first as a regular algebraic formula; it then looks for
27810 features that can be further simplified by converting one object's units
27811 to be compatible with another's. For example, @samp{5 m + 23 mm} will
27812 simplify to @samp{5.023 m}. When different but compatible units are
27813 added, the righthand term's units are converted to match those of the
27814 lefthand term. @xref{Simplification Modes}, for a way to have this done
27815 automatically at all times.
27817 Units simplification also handles quotients of two units with the same
27818 dimensionality, as in @w{@samp{2 in s/L cm}} to @samp{5.08 s/L}; fractional
27819 powers of unit expressions, as in @samp{sqrt(9 mm^2)} to @samp{3 mm} and
27820 @samp{sqrt(9 acre)} to a quantity in meters; and @code{floor},
27821 @code{ceil}, @code{round}, @code{rounde}, @code{roundu}, @code{trunc},
27822 @code{float}, @code{frac}, @code{abs}, and @code{clean}
27823 applied to units expressions, in which case
27824 the operation in question is applied only to the numeric part of the
27825 expression. Finally, trigonometric functions of quantities with units
27826 of angle are evaluated, regardless of the current angular mode.
27829 @pindex calc-convert-units
27830 The @kbd{u c} (@code{calc-convert-units}) command converts a units
27831 expression to new, compatible units. For example, given the units
27832 expression @samp{55 mph}, typing @kbd{u c m/s @key{RET}} produces
27833 @samp{24.5872 m/s}. If you have previously converted a units expression
27834 with the same type of units (in this case, distance over time), you will
27835 be offered the previous choice of new units as a default. Continuing
27836 the above example, entering the units expression @samp{100 km/hr} and
27837 typing @kbd{u c @key{RET}} (without specifying new units) produces
27838 @samp{27.7777777778 m/s}.
27841 @pindex calc-convert-temperature
27842 @cindex Temperature conversion
27843 The @kbd{u c} command treats temperature units (like @samp{degC} and
27844 @samp{K}) as relative temperatures. For example, @kbd{u c} converts
27845 @samp{10 degC} to @samp{18 degF}: A change of 10 degrees Celsius
27846 corresponds to a change of 18 degrees Fahrenheit. To convert absolute
27847 temperatures, you can use the @kbd{u t}
27848 (@code{calc-convert-temperature}) command. The value on the stack
27849 must be a simple units expression with units of temperature only.
27850 This command would convert @samp{10 degC} to @samp{50 degF}, the
27851 equivalent temperature on the Fahrenheit scale.
27853 While many of Calc's conversion factors are exact, some are necessarily
27854 approximate. If Calc is in fraction mode (@pxref{Fraction Mode}), then
27855 unit conversions will try to give exact, rational conversions, but it
27856 isn't always possible. Given @samp{55 mph} in fraction mode, typing
27857 @kbd{u c m/s @key{RET}} produces @samp{15367:625 m/s}, for example,
27858 while typing @kbd{u c au/yr @key{RET}} produces
27859 @samp{5.18665819999e-3 au/yr}.
27861 If the units you request are inconsistent with the original units, the
27862 number will be converted into your units times whatever ``remainder''
27863 units are left over. (This can be disabled; @pxref{Customizing Calc}.)
27864 For example, converting @samp{55 mph} into acres
27865 produces @samp{6.08e-3 acre / m s}. (Recall that multiplication binds
27866 more strongly than division in Calc formulas, so the units here are
27867 acres per meter-second.) Remainder units are expressed in terms of
27868 ``fundamental'' units like @samp{m} and @samp{s}, regardless of the
27871 One special exception is that if you specify a single unit name, and
27872 a compatible unit appears somewhere in the units expression, then
27873 that compatible unit will be converted to the new unit and the
27874 remaining units in the expression will be left alone. For example,
27875 given the input @samp{980 cm/s^2}, the command @kbd{u c ms} will
27876 change the @samp{s} to @samp{ms} to get @samp{9.8e-4 cm/ms^2}.
27877 The ``remainder unit'' @samp{cm} is left alone rather than being
27878 changed to the base unit @samp{m}.
27880 You can use explicit unit conversion instead of the @kbd{u s} command
27881 to gain more control over the units of the result of an expression.
27882 For example, given @samp{5 m + 23 mm}, you can type @kbd{u c m} or
27883 @kbd{u c mm} to express the result in either meters or millimeters.
27884 (For that matter, you could type @kbd{u c fath} to express the result
27885 in fathoms, if you preferred!)
27887 In place of a specific set of units, you can also enter one of the
27888 units system names @code{si}, @code{mks} (equivalent), or @code{cgs}.
27889 For example, @kbd{u c si @key{RET}} converts the expression into
27890 International System of Units (SI) base units. Also, @kbd{u c base}
27891 converts to Calc's base units, which are the same as @code{si} units
27892 except that @code{base} uses @samp{g} as the fundamental unit of mass
27893 whereas @code{si} uses @samp{kg}.
27895 @cindex Composite units
27896 The @kbd{u c} command also accepts @dfn{composite units}, which
27897 are expressed as the sum of several compatible unit names. For
27898 example, converting @samp{30.5 in} to units @samp{mi+ft+in} (miles,
27899 feet, and inches) produces @samp{2 ft + 6.5 in}. Calc first
27900 sorts the unit names into order of decreasing relative size.
27901 It then accounts for as much of the input quantity as it can
27902 using an integer number times the largest unit, then moves on
27903 to the next smaller unit, and so on. Only the smallest unit
27904 may have a non-integer amount attached in the result. A few
27905 standard unit names exist for common combinations, such as
27906 @code{mfi} for @samp{mi+ft+in}, and @code{tpo} for @samp{ton+lb+oz}.
27907 Composite units are expanded as if by @kbd{a x}, so that
27908 @samp{(ft+in)/hr} is first converted to @samp{ft/hr+in/hr}.
27910 If the value on the stack does not contain any units, @kbd{u c} will
27911 prompt first for the old units which this value should be considered
27912 to have, then for the new units. (If the value on the stack can be
27913 simplified so that it doesn't contain any units, like @samp{ft/in} can
27914 be simplified to 12, then @kbd{u c} will still prompt for both old
27915 units and new units. Assuming the old and new units you give are
27916 consistent with each other, the result also will not contain any
27917 units. For example, @kbd{@w{u c} cm @key{RET} in @key{RET}} converts
27918 the number 2 on the stack to 5.08.
27921 @pindex calc-base-units
27922 The @kbd{u b} (@code{calc-base-units}) command is shorthand for
27923 @kbd{u c base}; it converts the units expression on the top of the
27924 stack into @code{base} units. If @kbd{u s} does not simplify a
27925 units expression as far as you would like, try @kbd{u b}.
27927 Like the @kbd{u c} command, the @kbd{u b} command treats temperature
27928 units as relative temperatures.
27931 @pindex calc-remove-units
27933 @pindex calc-extract-units
27934 The @kbd{u r} (@code{calc-remove-units}) command removes units from the
27935 formula at the top of the stack. The @kbd{u x}
27936 (@code{calc-extract-units}) command extracts only the units portion of a
27937 formula. These commands essentially replace every term of the formula
27938 that does or doesn't (respectively) look like a unit name by the
27939 constant 1, then resimplify the formula.
27942 @pindex calc-autorange-units
27943 The @kbd{u a} (@code{calc-autorange-units}) command turns on and off a
27944 mode in which unit prefixes like @code{k} (``kilo'') are automatically
27945 applied to keep the numeric part of a units expression in a reasonable
27946 range. This mode affects @kbd{u s} and all units conversion commands
27947 except @kbd{u b}. For example, with autoranging on, @samp{12345 Hz}
27948 will be simplified to @samp{12.345 kHz}. Autoranging is useful for
27949 some kinds of units (like @code{Hz} and @code{m}), but is probably
27950 undesirable for non-metric units like @code{ft} and @code{tbsp}.
27951 (Composite units are more appropriate for those; see above.)
27953 Autoranging always applies the prefix to the leftmost unit name.
27954 Calc chooses the largest prefix that causes the number to be greater
27955 than or equal to 1.0. Thus an increasing sequence of adjusted times
27956 would be @samp{1 ms, 10 ms, 100 ms, 1 s, 10 s, 100 s, 1 ks}.
27957 Generally the rule of thumb is that the number will be adjusted
27958 to be in the interval @samp{[1 .. 1000)}, although there are several
27959 exceptions to this rule. First, if the unit has a power then this
27960 is not possible; @samp{0.1 s^2} simplifies to @samp{100000 ms^2}.
27961 Second, the ``centi-'' prefix is allowed to form @code{cm} (centimeters),
27962 but will not apply to other units. The ``deci-,'' ``deka-,'' and
27963 ``hecto-'' prefixes are never used. Thus the allowable interval is
27964 @samp{[1 .. 10)} for millimeters and @samp{[1 .. 100)} for centimeters.
27965 Finally, a prefix will not be added to a unit if the resulting name
27966 is also the actual name of another unit; @samp{1e-15 t} would normally
27967 be considered a ``femto-ton,'' but it is written as @samp{1000 at}
27968 (1000 atto-tons) instead because @code{ft} would be confused with feet.
27970 @node The Units Table, Predefined Units, Basic Operations on Units, Units
27971 @section The Units Table
27975 @pindex calc-enter-units-table
27976 The @kbd{u v} (@code{calc-enter-units-table}) command displays the units table
27977 in another buffer called @file{*Units Table*}. Each entry in this table
27978 gives the unit name as it would appear in an expression, the definition
27979 of the unit in terms of simpler units, and a full name or description of
27980 the unit. Fundamental units are defined as themselves; these are the
27981 units produced by the @kbd{u b} command. The fundamental units are
27982 meters, seconds, grams, kelvins, amperes, candelas, moles, radians,
27985 The Units Table buffer also displays the Unit Prefix Table. Note that
27986 two prefixes, ``kilo'' and ``hecto,'' accept either upper- or lower-case
27987 prefix letters. @samp{Meg} is also accepted as a synonym for the @samp{M}
27988 prefix. Whenever a unit name can be interpreted as either a built-in name
27989 or a prefix followed by another built-in name, the former interpretation
27990 wins. For example, @samp{2 pt} means two pints, not two pico-tons.
27992 The Units Table buffer, once created, is not rebuilt unless you define
27993 new units. To force the buffer to be rebuilt, give any numeric prefix
27994 argument to @kbd{u v}.
27997 @pindex calc-view-units-table
27998 The @kbd{u V} (@code{calc-view-units-table}) command is like @kbd{u v} except
27999 that the cursor is not moved into the Units Table buffer. You can
28000 type @kbd{u V} again to remove the Units Table from the display. To
28001 return from the Units Table buffer after a @kbd{u v}, type @kbd{C-x * c}
28002 again or use the regular Emacs @w{@kbd{C-x o}} (@code{other-window})
28003 command. You can also kill the buffer with @kbd{C-x k} if you wish;
28004 the actual units table is safely stored inside the Calculator.
28007 @pindex calc-get-unit-definition
28008 The @kbd{u g} (@code{calc-get-unit-definition}) command retrieves a unit's
28009 defining expression and pushes it onto the Calculator stack. For example,
28010 @kbd{u g in} will produce the expression @samp{2.54 cm}. This is the
28011 same definition for the unit that would appear in the Units Table buffer.
28012 Note that this command works only for actual unit names; @kbd{u g km}
28013 will report that no such unit exists, for example, because @code{km} is
28014 really the unit @code{m} with a @code{k} (``kilo'') prefix. To see a
28015 definition of a unit in terms of base units, it is easier to push the
28016 unit name on the stack and then reduce it to base units with @kbd{u b}.
28019 @pindex calc-explain-units
28020 The @kbd{u e} (@code{calc-explain-units}) command displays an English
28021 description of the units of the expression on the stack. For example,
28022 for the expression @samp{62 km^2 g / s^2 mol K}, the description is
28023 ``Square-Kilometer Gram per (Second-squared Mole Degree-Kelvin).'' This
28024 command uses the English descriptions that appear in the righthand
28025 column of the Units Table.
28027 @node Predefined Units, User-Defined Units, The Units Table, Units
28028 @section Predefined Units
28031 The definitions of many units have changed over the years. For example,
28032 the meter was originally defined in 1791 as one ten-millionth of the
28033 distance from the equator to the north pole. In order to be more
28034 precise, the definition was adjusted several times, and now a meter is
28035 defined as the distance that light will travel in a vacuum in
28036 1/299792458 of a second; consequently, the speed of light in a
28037 vacuum is exactly 299792458 m/s. Many other units have been
28038 redefined in terms of fundamental physical processes; a second, for
28039 example, is currently defined as 9192631770 periods of a certain
28040 radiation related to the cesium-133 atom. The only SI unit that is not
28041 based on a fundamental physical process (although there are efforts to
28042 change this) is the kilogram, which was originally defined as the mass
28043 of one liter of water, but is now defined as the mass of the
28044 international prototype of the kilogram (IPK), a cylinder of platinum-iridium
28045 kept at the Bureau international des poids et mesures in S@`evres,
28046 France. (There are several copies of the IPK throughout the world.)
28047 The British imperial units, once defined in terms of physical objects,
28048 were redefined in 1963 in terms of SI units. The US customary units,
28049 which were the same as British units until the British imperial system
28050 was created in 1824, were also defined in terms of the SI units in 1893.
28051 Because of these redefinitions, conversions between metric, British
28052 Imperial, and US customary units can often be done precisely.
28054 Since the exact definitions of many kinds of units have evolved over the
28055 years, and since certain countries sometimes have local differences in
28056 their definitions, it is a good idea to examine Calc's definition of a
28057 unit before depending on its exact value. For example, there are three
28058 different units for gallons, corresponding to the US (@code{gal}),
28059 Canadian (@code{galC}), and British (@code{galUK}) definitions. Also,
28060 note that @code{oz} is a standard ounce of mass, @code{ozt} is a Troy
28061 ounce, and @code{ozfl} is a fluid ounce.
28063 The temperature units corresponding to degrees Kelvin and Centigrade
28064 (Celsius) are the same in this table, since most units commands treat
28065 temperatures as being relative. The @code{calc-convert-temperature}
28066 command has special rules for handling the different absolute magnitudes
28067 of the various temperature scales.
28069 The unit of volume ``liters'' can be referred to by either the lower-case
28070 @code{l} or the upper-case @code{L}.
28072 The unit @code{A} stands for Amperes; the name @code{Ang} is used
28080 The unit @code{pt} stands for pints; the name @code{point} stands for
28081 a typographical point, defined by @samp{72 point = 1 in}. This is
28082 slightly different than the point defined by the American Typefounder's
28083 Association in 1886, but the point used by Calc has become standard
28084 largely due to its use by the PostScript page description language.
28085 There is also @code{texpt}, which stands for a printer's point as
28086 defined by the @TeX{} typesetting system: @samp{72.27 texpt = 1 in}.
28087 Other units used by @TeX{} are available; they are @code{texpc} (a pica),
28088 @code{texbp} (a ``big point'', equal to a standard point which is larger
28089 than the point used by @TeX{}), @code{texdd} (a Didot point),
28090 @code{texcc} (a Cicero) and @code{texsp} (a scaled @TeX{} point,
28091 all dimensions representable in @TeX{} are multiples of this value).
28093 When Calc is using the @TeX{} or @LaTeX{} language mode (@pxref{TeX
28094 and LaTeX Language Modes}), the @TeX{} specific unit names will not
28095 use the @samp{tex} prefix; the unit name for a @TeX{} point will be
28096 @samp{pt} instead of @samp{texpt}, for example. To avoid conflicts,
28097 the unit names for pint and parsec will simply be @samp{pint} and
28098 @samp{parsec} instead of @samp{pt} and @samp{pc}.
28101 The unit @code{e} stands for the elementary (electron) unit of charge;
28102 because algebra command could mistake this for the special constant
28103 @expr{e}, Calc provides the alternate unit name @code{ech} which is
28104 preferable to @code{e}.
28106 The name @code{g} stands for one gram of mass; there is also @code{gf},
28107 one gram of force. (Likewise for @kbd{lb}, pounds, and @kbd{lbf}.)
28108 Meanwhile, one ``@expr{g}'' of acceleration is denoted @code{ga}.
28110 The unit @code{ton} is a U.S. ton of @samp{2000 lb}, and @code{t} is
28111 a metric ton of @samp{1000 kg}.
28113 The names @code{s} (or @code{sec}) and @code{min} refer to units of
28114 time; @code{arcsec} and @code{arcmin} are units of angle.
28116 Some ``units'' are really physical constants; for example, @code{c}
28117 represents the speed of light, and @code{h} represents Planck's
28118 constant. You can use these just like other units: converting
28119 @samp{.5 c} to @samp{m/s} expresses one-half the speed of light in
28120 meters per second. You can also use this merely as a handy reference;
28121 the @kbd{u g} command gets the definition of one of these constants
28122 in its normal terms, and @kbd{u b} expresses the definition in base
28125 Two units, @code{pi} and @code{alpha} (the fine structure constant,
28126 approximately @mathit{1/137}) are dimensionless. The units simplification
28127 commands simply treat these names as equivalent to their corresponding
28128 values. However you can, for example, use @kbd{u c} to convert a pure
28129 number into multiples of the fine structure constant, or @kbd{u b} to
28130 convert this back into a pure number. (When @kbd{u c} prompts for the
28131 ``old units,'' just enter a blank line to signify that the value
28132 really is unitless.)
28134 @c Describe angular units, luminosity vs. steradians problem.
28136 @node User-Defined Units, Logarithmic Units, Predefined Units, Units
28137 @section User-Defined Units
28140 Calc provides ways to get quick access to your selected ``favorite''
28141 units, as well as ways to define your own new units.
28144 @pindex calc-quick-units
28146 @cindex @code{Units} variable
28147 @cindex Quick units
28148 To select your favorite units, store a vector of unit names or
28149 expressions in the Calc variable @code{Units}. The @kbd{u 1}
28150 through @kbd{u 9} commands (@code{calc-quick-units}) provide access
28151 to these units. If the value on the top of the stack is a plain
28152 number (with no units attached), then @kbd{u 1} gives it the
28153 specified units. (Basically, it multiplies the number by the
28154 first item in the @code{Units} vector.) If the number on the
28155 stack @emph{does} have units, then @kbd{u 1} converts that number
28156 to the new units. For example, suppose the vector @samp{[in, ft]}
28157 is stored in @code{Units}. Then @kbd{30 u 1} will create the
28158 expression @samp{30 in}, and @kbd{u 2} will convert that expression
28161 The @kbd{u 0} command accesses the tenth element of @code{Units}.
28162 Only ten quick units may be defined at a time. If the @code{Units}
28163 variable has no stored value (the default), or if its value is not
28164 a vector, then the quick-units commands will not function. The
28165 @kbd{s U} command is a convenient way to edit the @code{Units}
28166 variable; @pxref{Operations on Variables}.
28169 @pindex calc-define-unit
28170 @cindex User-defined units
28171 The @kbd{u d} (@code{calc-define-unit}) command records the units
28172 expression on the top of the stack as the definition for a new,
28173 user-defined unit. For example, putting @samp{16.5 ft} on the stack and
28174 typing @kbd{u d rod} defines the new unit @samp{rod} to be equivalent to
28175 16.5 feet. The unit conversion and simplification commands will now
28176 treat @code{rod} just like any other unit of length. You will also be
28177 prompted for an optional English description of the unit, which will
28178 appear in the Units Table. If you wish the definition of this unit to
28179 be displayed in a special way in the Units Table buffer (such as with an
28180 asterisk to indicate an approximate value), then you can call this
28181 command with an argument, @kbd{C-u u d}; you will then also be prompted
28182 for a string that will be used to display the definition.
28185 @pindex calc-undefine-unit
28186 The @kbd{u u} (@code{calc-undefine-unit}) command removes a user-defined
28187 unit. It is not possible to remove one of the predefined units,
28190 If you define a unit with an existing unit name, your new definition
28191 will replace the original definition of that unit. If the unit was a
28192 predefined unit, the old definition will not be replaced, only
28193 ``shadowed.'' The built-in definition will reappear if you later use
28194 @kbd{u u} to remove the shadowing definition.
28196 To create a new fundamental unit, use either 1 or the unit name itself
28197 as the defining expression. Otherwise the expression can involve any
28198 other units that you like (except for composite units like @samp{mfi}).
28199 You can create a new composite unit with a sum of other units as the
28200 defining expression. The next unit operation like @kbd{u c} or @kbd{u v}
28201 will rebuild the internal unit table incorporating your modifications.
28202 Note that erroneous definitions (such as two units defined in terms of
28203 each other) will not be detected until the unit table is next rebuilt;
28204 @kbd{u v} is a convenient way to force this to happen.
28206 Temperature units are treated specially inside the Calculator; it is not
28207 possible to create user-defined temperature units.
28210 @pindex calc-permanent-units
28211 @cindex Calc init file, user-defined units
28212 The @kbd{u p} (@code{calc-permanent-units}) command stores the user-defined
28213 units in your Calc init file (the file given by the variable
28214 @code{calc-settings-file}, typically @file{~/.emacs.d/calc.el}), so that the
28215 units will still be available in subsequent Emacs sessions. If there
28216 was already a set of user-defined units in your Calc init file, it
28217 is replaced by the new set. (@xref{General Mode Commands}, for a way to
28218 tell Calc to use a different file for the Calc init file.)
28220 @node Logarithmic Units, Musical Notes, User-Defined Units, Units
28221 @section Logarithmic Units
28223 The units @code{dB} (decibels) and @code{Np} (nepers) are logarithmic
28224 units which are manipulated differently than standard units. Calc
28225 provides commands to work with these logarithmic units.
28227 Decibels and nepers are used to measure power quantities as well as
28228 field quantities (quantities whose squares are proportional to power);
28229 these two types of quantities are handled slightly different from each
28230 other. By default the Calc commands work as if power quantities are
28231 being used; with the @kbd{H} prefix the Calc commands work as if field
28232 quantities are being used.
28234 The decibel level of a power
28235 @infoline @math{P1},
28236 @texline @math{P_1},
28237 relative to a reference power
28238 @infoline @math{P0},
28239 @texline @math{P_0},
28241 @infoline @math{10 log10(P1/P0) dB}.
28242 @texline @math{10 \log_{10}(P_{1}/P_{0}) {\rm dB}}.
28243 (The factor of 10 is because a decibel, as its name implies, is
28244 one-tenth of a bel. The bel, named after Alexander Graham Bell, was
28245 considered to be too large of a unit and was effectively replaced by
28246 the decibel.) If @math{F} is a field quantity with power
28247 @math{P=k F^2}, then a reference quantity of
28248 @infoline @math{F0}
28249 @texline @math{F_0}
28250 would correspond to a power of
28251 @infoline @math{P0=k F0^2}.
28252 @texline @math{P_{0}=kF_{0}^2}.
28254 @infoline @math{P1=k F1^2},
28255 @texline @math{P_{1}=kF_{1}^2},
28260 10 log10(P1/P0) = 10 log10(F1^2/F0^2) = 20 log10(F1/F0).
28264 $$ 10 \log_{10}(P_1/P_0) = 10 \log_{10}(F_1^2/F_0^2) = 20
28265 \log_{10}(F_1/F_0)$$
28269 In order to get the same decibel level regardless of whether a field
28270 quantity or the corresponding power quantity is used, the decibel
28271 level of a field quantity
28272 @infoline @math{F1},
28273 @texline @math{F_1},
28274 relative to a reference
28275 @infoline @math{F0},
28276 @texline @math{F_0},
28278 @infoline @math{20 log10(F1/F0) dB}.
28279 @texline @math{20 \log_{10}(F_{1}/F_{0}) {\rm dB}}.
28280 For example, the decibel value of a sound pressure level of
28281 @infoline @math{60 uPa}
28282 @texline @math{60 \mu{\rm Pa}}
28284 @infoline @math{20 uPa}
28285 @texline @math{20 \mu{\rm Pa}}
28286 (the threshold of human hearing) is
28287 @infoline @math{20 log10(60 uPa/ 20 uPa) dB = 20 log10(3) dB},
28288 @texline @math{20 \log_{10}(60 \mu{\rm Pa}/20 \mu{\rm Pa}) {\rm dB} = 20 \log_{10}(3) {\rm dB}},
28290 @infoline @math{9.54 dB}.
28291 @texline @math{9.54 {\rm dB}}.
28292 Note that in taking the ratio, the original units cancel and so these
28293 logarithmic units are dimensionless.
28295 Nepers (named after John Napier, who is credited with inventing the
28296 logarithm) are similar to bels except they use natural logarithms instead
28297 of common logarithms. The neper level of a power
28298 @infoline @math{P1},
28299 @texline @math{P_1},
28300 relative to a reference power
28301 @infoline @math{P0},
28302 @texline @math{P_0},
28304 @infoline @math{(1/2) ln(P1/P0) Np}.
28305 @texline @math{(1/2) \ln(P_1/P_0) {\rm Np}}.
28306 The neper level of a field
28307 @infoline @math{F1},
28308 @texline @math{F_1},
28309 relative to a reference field
28310 @infoline @math{F0},
28311 @texline @math{F_0},
28313 @infoline @math{ln(F1/F0) Np}.
28314 @texline @math{\ln(F_1/F_0) {\rm Np}}.
28316 @vindex calc-lu-power-reference
28317 @vindex calc-lu-field-reference
28318 For power quantities, Calc uses
28319 @infoline @math{1 mW}
28320 @texline @math{1 {\rm mW}}
28321 as the default reference quantity; this default can be changed by changing
28322 the value of the customizable variable
28323 @code{calc-lu-power-reference} (@pxref{Customizing Calc}).
28324 For field quantities, Calc uses
28325 @infoline @math{20 uPa}
28326 @texline @math{20 \mu{\rm Pa}}
28327 as the default reference quantity; this is the value used in acoustics
28328 which is where decibels are commonly encountered. This default can be
28329 changed by changing the value of the customizable variable
28330 @code{calc-lu-field-reference} (@pxref{Customizing Calc}). A
28331 non-default reference quantity will be read from the stack if the
28332 capital @kbd{O} prefix is used.
28335 @pindex calc-lu-quant
28338 The @kbd{l q} (@code{calc-lu-quant}) [@code{lupquant}]
28339 command computes the power quantity corresponding to a given number of
28340 logarithmic units. With the capital @kbd{O} prefix, @kbd{O l q}, the
28341 reference level will be read from the top of the stack. (In an
28342 algebraic formula, @code{lupquant} can be given an optional second
28343 argument which will be used for the reference level.) For example,
28344 @code{20 dB @key{RET} l q} will return @code{100 mW};
28345 @code{20 dB @key{RET} 4 W @key{RET} O l q} will return @code{400 W}.
28346 The @kbd{H l q} [@code{lufquant}] command behaves like @kbd{l q} but
28347 computes field quantities instead of power quantities.
28357 The @kbd{l d} (@code{calc-db}) [@code{dbpower}] command will compute
28358 the decibel level of a power quantity using the default reference
28359 level; @kbd{H l d} [@code{dbfield}] will compute the decibel level of
28360 a field quantity. The commands @kbd{l n} (@code{calc-np})
28361 [@code{nppower}] and @kbd{H l n} [@code{npfield}] will similarly
28362 compute neper levels. With the capital @kbd{O} prefix these commands
28363 will read a reference level from the stack; in an algebraic formula
28364 the reference level can be given as an optional second argument.
28367 @pindex calc-lu-plus
28371 @pindex calc-lu-minus
28375 @pindex calc-lu-times
28379 @pindex calc-lu-divide
28382 The sum of two power or field quantities doesn't correspond to the sum
28383 of the corresponding decibel or neper levels. If the powers
28384 corresponding to decibel levels
28385 @infoline @math{D1}
28386 @texline @math{D_1}
28388 @infoline @math{D2}
28389 @texline @math{D_2}
28390 are added, the corresponding decibel level ``sum'' will be
28394 10 log10(10^(D1/10) + 10^(D2/10)) dB.
28398 $$ 10 \log_{10}(10^{D_1/10} + 10^{D_2/10}) {\rm dB}.$$
28402 When field quantities are combined, it often means the corresponding
28403 powers are added and so the above formula might be used. In
28404 acoustics, for example, the sound pressure level is a field quantity
28405 and so the decibels are often defined using the field formula, but the
28406 sound pressure levels are combined as the sound power levels, and so
28407 the above formula should be used. If two field quantities themselves
28408 are added, the new decibel level will be
28412 20 log10(10^(D1/20) + 10^(D2/20)) dB.
28416 $$ 20 \log_{10}(10^{D_1/20} + 10^{D_2/20}) {\rm dB}.$$
28420 If the power corresponding to @math{D} dB is multiplied by a number @math{N},
28421 then the corresponding decibel level will be
28425 D + 10 log10(N) dB,
28429 $$ D + 10 \log_{10}(N) {\rm dB},$$
28433 if a field quantity is multiplied by @math{N} the corresponding decibel level
28438 D + 20 log10(N) dB.
28442 $$ D + 20 \log_{10}(N) {\rm dB}.$$
28446 There are similar formulas for combining nepers. The @kbd{l +}
28447 (@code{calc-lu-plus}) [@code{lupadd}] command will ``add'' two
28448 logarithmic unit power levels this way; with the @kbd{H} prefix,
28449 @kbd{H l +} [@code{lufadd}] will add logarithmic unit field levels.
28450 Similarly, logarithmic units can be ``subtracted'' with @kbd{l -}
28451 (@code{calc-lu-minus}) [@code{lupsub}] or @kbd{H l -} [@code{lufsub}].
28452 The @kbd{l *} (@code{calc-lu-times}) [@code{lupmul}] and @kbd{H l *}
28453 [@code{lufmul}] commands will ``multiply'' a logarithmic unit by a
28454 number; the @kbd{l /} (@code{calc-lu-divide}) [@code{lupdiv}] and
28455 @kbd{H l /} [@code{lufdiv}] commands will ``divide'' a logarithmic
28456 unit by a number. Note that the reference quantities don't play a role
28457 in this arithmetic.
28459 @node Musical Notes, , Logarithmic Units, Units
28460 @section Musical Notes
28462 Calc can convert between musical notes and their associated
28463 frequencies. Notes can be given using either scientific pitch
28464 notation or midi numbers. Since these note systems are basically
28465 logarithmic scales, Calc uses the @kbd{l} prefix for functions
28466 operating on notes.
28468 Scientific pitch notation refers to a note by giving a letter
28469 A through G, possibly followed by a flat or sharp) with a subscript
28470 indicating an octave number. Each octave starts with C and ends with
28472 @c increasing each note by a semitone will result
28473 @c in the sequence @expr{C}, @expr{C} sharp, @expr{D}, @expr{E} flat, @expr{E},
28474 @c @expr{F}, @expr{F} sharp, @expr{G}, @expr{A} flat, @expr{A}, @expr{B}
28475 @c flat and @expr{B}.
28476 the octave numbered 0 was chosen to correspond to the lowest
28477 audible frequency. Using this system, middle C (about 261.625 Hz)
28478 corresponds to the note @expr{C} in octave 4 and is denoted
28479 @expr{C_4}. Any frequency can be described by giving a note plus an
28480 offset in cents (where a cent is a ratio of frequencies so that a
28481 semitone consists of 100 cents).
28483 The midi note number system assigns numbers to notes so that
28484 @expr{C_(-1)} corresponds to the midi note number 0 and @expr{G_9}
28485 corresponds to the midi note number 127. A midi controller can have
28486 up to 128 keys and each midi note number from 0 to 127 corresponds to
28492 The @kbd{l s} (@code{calc-spn}) [@code{spn}] command converts either
28493 a frequency or a midi number to scientific pitch notation. For
28494 example, @code{500 Hz} gets converted to
28495 @code{B_4 + 21.3094853649 cents} and @code{84} to @code{C_6}.
28501 The @kbd{l m} (@code{calc-midi}) [@code{midi}] command converts either
28502 a frequency or a note given in scientific pitch notation to the
28503 corresponding midi number. For example, @code{C_6} gets converted to 84
28504 and @code{440 Hz} to 69.
28509 The @kbd{l f} (@code{calc-freq}) [@code{freq}] command converts either
28510 either a midi number or a note given in scientific pitch notation to
28511 the corresponding frequency. For example, @code{Asharp_2 + 30 cents}
28512 gets converted to @code{118.578040134 Hz} and @code{55} to
28513 @code{195.99771799 Hz}.
28515 Since the frequencies of notes are not usually given exactly (and are
28516 typically irrational), the customizable variable
28517 @code{calc-note-threshold} determines how close (in cents) a frequency
28518 needs to be to a note to be recognized as that note
28519 (@pxref{Customizing Calc}). This variable has a default value of
28520 @code{1}. For example, middle @var{C} is approximately
28521 @expr{261.625565302 Hz}; this frequency is often shortened to
28522 @expr{261.625 Hz}. Without @code{calc-note-threshold} (or a value of
28523 @expr{0}), Calc would convert @code{261.625 Hz} to scientific pitch
28524 notation @code{B_3 + 99.9962592773 cents}; with the default value of
28525 @code{1}, Calc converts @code{261.625 Hz} to @code{C_4}.
28529 @node Store and Recall, Graphics, Units, Top
28530 @chapter Storing and Recalling
28533 Calculator variables are really just Lisp variables that contain numbers
28534 or formulas in a form that Calc can understand. The commands in this
28535 section allow you to manipulate variables conveniently. Commands related
28536 to variables use the @kbd{s} prefix key.
28539 * Storing Variables::
28540 * Recalling Variables::
28541 * Operations on Variables::
28543 * Evaluates-To Operator::
28546 @node Storing Variables, Recalling Variables, Store and Recall, Store and Recall
28547 @section Storing Variables
28552 @cindex Storing variables
28553 @cindex Quick variables
28556 The @kbd{s s} (@code{calc-store}) command stores the value at the top of
28557 the stack into a specified variable. It prompts you to enter the
28558 name of the variable. If you press a single digit, the value is stored
28559 immediately in one of the ``quick'' variables @code{q0} through
28560 @code{q9}. Or you can enter any variable name.
28563 @pindex calc-store-into
28564 The @kbd{s s} command leaves the stored value on the stack. There is
28565 also an @kbd{s t} (@code{calc-store-into}) command, which removes a
28566 value from the stack and stores it in a variable.
28568 If the top of stack value is an equation @samp{a = 7} or assignment
28569 @samp{a := 7} with a variable on the lefthand side, then Calc will
28570 assign that variable with that value by default, i.e., if you type
28571 @kbd{s s @key{RET}} or @kbd{s t @key{RET}}. In this example, the
28572 value 7 would be stored in the variable @samp{a}. (If you do type
28573 a variable name at the prompt, the top-of-stack value is stored in
28574 its entirety, even if it is an equation: @samp{s s b @key{RET}}
28575 with @samp{a := 7} on the stack stores @samp{a := 7} in @code{b}.)
28577 In fact, the top of stack value can be a vector of equations or
28578 assignments with different variables on their lefthand sides; the
28579 default will be to store all the variables with their corresponding
28580 righthand sides simultaneously.
28582 It is also possible to type an equation or assignment directly at
28583 the prompt for the @kbd{s s} or @kbd{s t} command: @kbd{s s foo = 7}.
28584 In this case the expression to the right of the @kbd{=} or @kbd{:=}
28585 symbol is evaluated as if by the @kbd{=} command, and that value is
28586 stored in the variable. No value is taken from the stack; @kbd{s s}
28587 and @kbd{s t} are equivalent when used in this way.
28591 The prefix keys @kbd{s} and @kbd{t} may be followed immediately by a
28592 digit; @kbd{s 9} is equivalent to @kbd{s s 9}, and @kbd{t 9} is
28593 equivalent to @kbd{s t 9}. (The @kbd{t} prefix is otherwise used
28594 for trail and time/date commands.)
28630 @pindex calc-store-plus
28631 @pindex calc-store-minus
28632 @pindex calc-store-times
28633 @pindex calc-store-div
28634 @pindex calc-store-power
28635 @pindex calc-store-concat
28636 @pindex calc-store-neg
28637 @pindex calc-store-inv
28638 @pindex calc-store-decr
28639 @pindex calc-store-incr
28640 There are also several ``arithmetic store'' commands. For example,
28641 @kbd{s +} removes a value from the stack and adds it to the specified
28642 variable. The other arithmetic stores are @kbd{s -}, @kbd{s *}, @kbd{s /},
28643 @kbd{s ^}, and @w{@kbd{s |}} (vector concatenation), plus @kbd{s n} and
28644 @kbd{s &} which negate or invert the value in a variable, and @w{@kbd{s [}}
28645 and @kbd{s ]} which decrease or increase a variable by one.
28647 All the arithmetic stores accept the Inverse prefix to reverse the
28648 order of the operands. If @expr{v} represents the contents of the
28649 variable, and @expr{a} is the value drawn from the stack, then regular
28650 @w{@kbd{s -}} assigns
28651 @texline @math{v \coloneq v - a},
28652 @infoline @expr{v := v - a},
28653 but @kbd{I s -} assigns
28654 @texline @math{v \coloneq a - v}.
28655 @infoline @expr{v := a - v}.
28656 While @kbd{I s *} might seem pointless, it is
28657 useful if matrix multiplication is involved. Actually, all the
28658 arithmetic stores use formulas designed to behave usefully both
28659 forwards and backwards:
28663 s + v := v + a v := a + v
28664 s - v := v - a v := a - v
28665 s * v := v * a v := a * v
28666 s / v := v / a v := a / v
28667 s ^ v := v ^ a v := a ^ v
28668 s | v := v | a v := a | v
28669 s n v := v / (-1) v := (-1) / v
28670 s & v := v ^ (-1) v := (-1) ^ v
28671 s [ v := v - 1 v := 1 - v
28672 s ] v := v - (-1) v := (-1) - v
28676 In the last four cases, a numeric prefix argument will be used in
28677 place of the number one. (For example, @kbd{M-2 s ]} increases
28678 a variable by 2, and @kbd{M-2 I s ]} replaces a variable by
28679 minus-two minus the variable.
28681 The first six arithmetic stores can also be typed @kbd{s t +}, @kbd{s t -},
28682 etc. The commands @kbd{s s +}, @kbd{s s -}, and so on are analogous
28683 arithmetic stores that don't remove the value @expr{a} from the stack.
28685 All arithmetic stores report the new value of the variable in the
28686 Trail for your information. They signal an error if the variable
28687 previously had no stored value. If default simplifications have been
28688 turned off, the arithmetic stores temporarily turn them on for numeric
28689 arguments only (i.e., they temporarily do an @kbd{m N} command).
28690 @xref{Simplification Modes}. Large vectors put in the trail by
28691 these commands always use abbreviated (@kbd{t .}) mode.
28694 @pindex calc-store-map
28695 The @kbd{s m} command is a general way to adjust a variable's value
28696 using any Calc function. It is a ``mapping'' command analogous to
28697 @kbd{V M}, @kbd{V R}, etc. @xref{Reducing and Mapping}, to see
28698 how to specify a function for a mapping command. Basically,
28699 all you do is type the Calc command key that would invoke that
28700 function normally. For example, @kbd{s m n} applies the @kbd{n}
28701 key to negate the contents of the variable, so @kbd{s m n} is
28702 equivalent to @kbd{s n}. Also, @kbd{s m Q} takes the square root
28703 of the value stored in a variable, @kbd{s m v v} uses @kbd{v v} to
28704 reverse the vector stored in the variable, and @kbd{s m H I S}
28705 takes the hyperbolic arcsine of the variable contents.
28707 If the mapping function takes two or more arguments, the additional
28708 arguments are taken from the stack; the old value of the variable
28709 is provided as the first argument. Thus @kbd{s m -} with @expr{a}
28710 on the stack computes @expr{v - a}, just like @kbd{s -}. With the
28711 Inverse prefix, the variable's original value becomes the @emph{last}
28712 argument instead of the first. Thus @kbd{I s m -} is also
28713 equivalent to @kbd{I s -}.
28716 @pindex calc-store-exchange
28717 The @kbd{s x} (@code{calc-store-exchange}) command exchanges the value
28718 of a variable with the value on the top of the stack. Naturally, the
28719 variable must already have a stored value for this to work.
28721 You can type an equation or assignment at the @kbd{s x} prompt. The
28722 command @kbd{s x a=6} takes no values from the stack; instead, it
28723 pushes the old value of @samp{a} on the stack and stores @samp{a = 6}.
28726 @pindex calc-unstore
28727 @cindex Void variables
28728 @cindex Un-storing variables
28729 Until you store something in them, most variables are ``void,'' that is,
28730 they contain no value at all. If they appear in an algebraic formula
28731 they will be left alone even if you press @kbd{=} (@code{calc-evaluate}).
28732 The @kbd{s u} (@code{calc-unstore}) command returns a variable to the
28736 @pindex calc-copy-variable
28737 The @kbd{s c} (@code{calc-copy-variable}) command copies the stored
28738 value of one variable to another. One way it differs from a simple
28739 @kbd{s r} followed by an @kbd{s t} (aside from saving keystrokes) is
28740 that the value never goes on the stack and thus is never rounded,
28741 evaluated, or simplified in any way; it is not even rounded down to the
28744 The only variables with predefined values are the ``special constants''
28745 @code{pi}, @code{e}, @code{i}, @code{phi}, and @code{gamma}. You are free
28746 to unstore these variables or to store new values into them if you like,
28747 although some of the algebraic-manipulation functions may assume these
28748 variables represent their standard values. Calc displays a warning if
28749 you change the value of one of these variables, or of one of the other
28750 special variables @code{inf}, @code{uinf}, and @code{nan} (which are
28753 Note that @code{pi} doesn't actually have 3.14159265359 stored in it,
28754 but rather a special magic value that evaluates to @cpi{} at the current
28755 precision. Likewise @code{e}, @code{i}, and @code{phi} evaluate
28756 according to the current precision or polar mode. If you recall a value
28757 from @code{pi} and store it back, this magic property will be lost. The
28758 magic property is preserved, however, when a variable is copied with
28762 @pindex calc-copy-special-constant
28763 If one of the ``special constants'' is redefined (or undefined) so that
28764 it no longer has its magic property, the property can be restored with
28765 @kbd{s k} (@code{calc-copy-special-constant}). This command will prompt
28766 for a special constant and a variable to store it in, and so a special
28767 constant can be stored in any variable. Here, the special constant that
28768 you enter doesn't depend on the value of the corresponding variable;
28769 @code{pi} will represent 3.14159@dots{} regardless of what is currently
28770 stored in the Calc variable @code{pi}. If one of the other special
28771 variables, @code{inf}, @code{uinf} or @code{nan}, is given a value, its
28772 original behavior can be restored by voiding it with @kbd{s u}.
28774 @node Recalling Variables, Operations on Variables, Storing Variables, Store and Recall
28775 @section Recalling Variables
28779 @pindex calc-recall
28780 @cindex Recalling variables
28781 The most straightforward way to extract the stored value from a variable
28782 is to use the @kbd{s r} (@code{calc-recall}) command. This command prompts
28783 for a variable name (similarly to @code{calc-store}), looks up the value
28784 of the specified variable, and pushes that value onto the stack. It is
28785 an error to try to recall a void variable.
28787 It is also possible to recall the value from a variable by evaluating a
28788 formula containing that variable. For example, @kbd{' a @key{RET} =} is
28789 the same as @kbd{s r a @key{RET}} except that if the variable is void, the
28790 former will simply leave the formula @samp{a} on the stack whereas the
28791 latter will produce an error message.
28794 The @kbd{r} prefix may be followed by a digit, so that @kbd{r 9} is
28795 equivalent to @kbd{s r 9}.
28797 @node Operations on Variables, Let Command, Recalling Variables, Store and Recall
28798 @section Other Operations on Variables
28802 @pindex calc-edit-variable
28803 The @kbd{s e} (@code{calc-edit-variable}) command edits the stored
28804 value of a variable without ever putting that value on the stack
28805 or simplifying or evaluating the value. It prompts for the name of
28806 the variable to edit. If the variable has no stored value, the
28807 editing buffer will start out empty. If the editing buffer is
28808 empty when you press @kbd{C-c C-c} to finish, the variable will
28809 be made void. @xref{Editing Stack Entries}, for a general
28810 description of editing.
28812 The @kbd{s e} command is especially useful for creating and editing
28813 rewrite rules which are stored in variables. Sometimes these rules
28814 contain formulas which must not be evaluated until the rules are
28815 actually used. (For example, they may refer to @samp{deriv(x,y)},
28816 where @code{x} will someday become some expression involving @code{y};
28817 if you let Calc evaluate the rule while you are defining it, Calc will
28818 replace @samp{deriv(x,y)} with 0 because the formula @code{x} does
28819 not itself refer to @code{y}.) By contrast, recalling the variable,
28820 editing with @kbd{`}, and storing will evaluate the variable's value
28821 as a side effect of putting the value on the stack.
28869 @pindex calc-store-AlgSimpRules
28870 @pindex calc-store-Decls
28871 @pindex calc-store-EvalRules
28872 @pindex calc-store-FitRules
28873 @pindex calc-store-GenCount
28874 @pindex calc-store-Holidays
28875 @pindex calc-store-IntegLimit
28876 @pindex calc-store-LineStyles
28877 @pindex calc-store-PointStyles
28878 @pindex calc-store-PlotRejects
28879 @pindex calc-store-TimeZone
28880 @pindex calc-store-Units
28881 @pindex calc-store-ExtSimpRules
28882 There are several special-purpose variable-editing commands that
28883 use the @kbd{s} prefix followed by a shifted letter:
28887 Edit @code{AlgSimpRules}. @xref{Algebraic Simplifications}.
28889 Edit @code{Decls}. @xref{Declarations}.
28891 Edit @code{EvalRules}. @xref{Basic Simplifications}.
28893 Edit @code{FitRules}. @xref{Curve Fitting}.
28895 Edit @code{GenCount}. @xref{Solving Equations}.
28897 Edit @code{Holidays}. @xref{Business Days}.
28899 Edit @code{IntegLimit}. @xref{Calculus}.
28901 Edit @code{LineStyles}. @xref{Graphics}.
28903 Edit @code{PointStyles}. @xref{Graphics}.
28905 Edit @code{PlotRejects}. @xref{Graphics}.
28907 Edit @code{TimeZone}. @xref{Time Zones}.
28909 Edit @code{Units}. @xref{User-Defined Units}.
28911 Edit @code{ExtSimpRules}. @xref{Unsafe Simplifications}.
28914 These commands are just versions of @kbd{s e} that use fixed variable
28915 names rather than prompting for the variable name.
28918 @pindex calc-permanent-variable
28919 @cindex Storing variables
28920 @cindex Permanent variables
28921 @cindex Calc init file, variables
28922 The @kbd{s p} (@code{calc-permanent-variable}) command saves a
28923 variable's value permanently in your Calc init file (the file given by
28924 the variable @code{calc-settings-file}, typically @file{~/.emacs.d/calc.el}), so
28925 that its value will still be available in future Emacs sessions. You
28926 can re-execute @w{@kbd{s p}} later on to update the saved value, but the
28927 only way to remove a saved variable is to edit your calc init file
28928 by hand. (@xref{General Mode Commands}, for a way to tell Calc to
28929 use a different file for the Calc init file.)
28931 If you do not specify the name of a variable to save (i.e.,
28932 @kbd{s p @key{RET}}), all Calc variables with defined values
28933 are saved except for the special constants @code{pi}, @code{e},
28934 @code{i}, @code{phi}, and @code{gamma}; the variables @code{TimeZone}
28935 and @code{PlotRejects};
28936 @code{FitRules}, @code{DistribRules}, and other built-in rewrite
28937 rules; and @code{PlotData@var{n}} variables generated
28938 by the graphics commands. (You can still save these variables by
28939 explicitly naming them in an @kbd{s p} command.)
28942 @pindex calc-insert-variables
28943 The @kbd{s i} (@code{calc-insert-variables}) command writes
28944 the values of all Calc variables into a specified buffer.
28945 The variables are written with the prefix @code{var-} in the form of
28946 Lisp @code{setq} commands
28947 which store the values in string form. You can place these commands
28948 in your Calc init file (or @file{.emacs}) if you wish, though in this case it
28949 would be easier to use @kbd{s p @key{RET}}. (Note that @kbd{s i}
28950 omits the same set of variables as @w{@kbd{s p @key{RET}}}; the difference
28951 is that @kbd{s i} will store the variables in any buffer, and it also
28952 stores in a more human-readable format.)
28954 @node Let Command, Evaluates-To Operator, Operations on Variables, Store and Recall
28955 @section The Let Command
28960 @cindex Variables, temporary assignment
28961 @cindex Temporary assignment to variables
28962 If you have an expression like @samp{a+b^2} on the stack and you wish to
28963 compute its value where @expr{b=3}, you can simply store 3 in @expr{b} and
28964 then press @kbd{=} to reevaluate the formula. This has the side-effect
28965 of leaving the stored value of 3 in @expr{b} for future operations.
28967 The @kbd{s l} (@code{calc-let}) command evaluates a formula under a
28968 @emph{temporary} assignment of a variable. It stores the value on the
28969 top of the stack into the specified variable, then evaluates the
28970 second-to-top stack entry, then restores the original value (or lack of one)
28971 in the variable. Thus after @kbd{'@w{ }a+b^2 @key{RET} 3 s l b @key{RET}},
28972 the stack will contain the formula @samp{a + 9}. The subsequent command
28973 @kbd{@w{5 s l a} @key{RET}} will replace this formula with the number 14.
28974 The variables @samp{a} and @samp{b} are not permanently affected in any way
28977 The value on the top of the stack may be an equation or assignment, or
28978 a vector of equations or assignments, in which case the default will be
28979 analogous to the case of @kbd{s t @key{RET}}. @xref{Storing Variables}.
28981 Also, you can answer the variable-name prompt with an equation or
28982 assignment: @kbd{s l b=3 @key{RET}} is the same as storing 3 on the stack
28983 and typing @kbd{s l b @key{RET}}.
28985 The @kbd{a b} (@code{calc-substitute}) command is another way to substitute
28986 a variable with a value in a formula. It does an actual substitution
28987 rather than temporarily assigning the variable and evaluating. For
28988 example, letting @expr{n=2} in @samp{f(n pi)} with @kbd{a b} will
28989 produce @samp{f(2 pi)}, whereas @kbd{s l} would give @samp{f(6.28)}
28990 since the evaluation step will also evaluate @code{pi}.
28992 @node Evaluates-To Operator, , Let Command, Store and Recall
28993 @section The Evaluates-To Operator
28998 @cindex Evaluates-to operator
28999 @cindex @samp{=>} operator
29000 The special algebraic symbol @samp{=>} is known as the @dfn{evaluates-to
29001 operator}. (It will show up as an @code{evalto} function call in
29002 other language modes like Pascal and @LaTeX{}.) This is a binary
29003 operator, that is, it has a lefthand and a righthand argument,
29004 although it can be entered with the righthand argument omitted.
29006 A formula like @samp{@var{a} => @var{b}} is evaluated by Calc as
29007 follows: First, @var{a} is not simplified or modified in any
29008 way. The previous value of argument @var{b} is thrown away; the
29009 formula @var{a} is then copied and evaluated as if by the @kbd{=}
29010 command according to all current modes and stored variable values,
29011 and the result is installed as the new value of @var{b}.
29013 For example, suppose you enter the algebraic formula @samp{2 + 3 => 17}.
29014 The number 17 is ignored, and the lefthand argument is left in its
29015 unevaluated form; the result is the formula @samp{2 + 3 => 5}.
29018 @pindex calc-evalto
29019 You can enter an @samp{=>} formula either directly using algebraic
29020 entry (in which case the righthand side may be omitted since it is
29021 going to be replaced right away anyhow), or by using the @kbd{s =}
29022 (@code{calc-evalto}) command, which takes @var{a} from the stack
29023 and replaces it with @samp{@var{a} => @var{b}}.
29025 Calc keeps track of all @samp{=>} operators on the stack, and
29026 recomputes them whenever anything changes that might affect their
29027 values, i.e., a mode setting or variable value. This occurs only
29028 if the @samp{=>} operator is at the top level of the formula, or
29029 if it is part of a top-level vector. In other words, pushing
29030 @samp{2 + (a => 17)} will change the 17 to the actual value of
29031 @samp{a} when you enter the formula, but the result will not be
29032 dynamically updated when @samp{a} is changed later because the
29033 @samp{=>} operator is buried inside a sum. However, a vector
29034 of @samp{=>} operators will be recomputed, since it is convenient
29035 to push a vector like @samp{[a =>, b =>, c =>]} on the stack to
29036 make a concise display of all the variables in your problem.
29037 (Another way to do this would be to use @samp{[a, b, c] =>},
29038 which provides a slightly different format of display. You
29039 can use whichever you find easiest to read.)
29042 @pindex calc-auto-recompute
29043 The @kbd{m C} (@code{calc-auto-recompute}) command allows you to
29044 turn this automatic recomputation on or off. If you turn
29045 recomputation off, you must explicitly recompute an @samp{=>}
29046 operator on the stack in one of the usual ways, such as by
29047 pressing @kbd{=}. Turning recomputation off temporarily can save
29048 a lot of time if you will be changing several modes or variables
29049 before you look at the @samp{=>} entries again.
29051 Most commands are not especially useful with @samp{=>} operators
29052 as arguments. For example, given @samp{x + 2 => 17}, it won't
29053 work to type @kbd{1 +} to get @samp{x + 3 => 18}. If you want
29054 to operate on the lefthand side of the @samp{=>} operator on
29055 the top of the stack, type @kbd{j 1} (that's the digit ``one'')
29056 to select the lefthand side, execute your commands, then type
29057 @kbd{j u} to unselect.
29059 All current modes apply when an @samp{=>} operator is computed,
29060 including the current simplification mode. Recall that the
29061 formula @samp{arcsin(sin(x))} will not be handled by Calc's algebraic
29062 simplifications, but Calc's unsafe simplifications will reduce it to
29063 @samp{x}. If you enter @samp{arcsin(sin(x)) =>} normally, the result
29064 will be @samp{arcsin(sin(x)) => arcsin(sin(x))}. If you change to
29065 Extended Simplification mode, the result will be
29066 @samp{arcsin(sin(x)) => x}. However, just pressing @kbd{a e}
29067 once will have no effect on @samp{arcsin(sin(x)) => arcsin(sin(x))},
29068 because the righthand side depends only on the lefthand side
29069 and the current mode settings, and the lefthand side is not
29070 affected by commands like @kbd{a e}.
29072 The ``let'' command (@kbd{s l}) has an interesting interaction
29073 with the @samp{=>} operator. The @kbd{s l} command evaluates the
29074 second-to-top stack entry with the top stack entry supplying
29075 a temporary value for a given variable. As you might expect,
29076 if that stack entry is an @samp{=>} operator its righthand
29077 side will temporarily show this value for the variable. In
29078 fact, all @samp{=>}s on the stack will be updated if they refer
29079 to that variable. But this change is temporary in the sense
29080 that the next command that causes Calc to look at those stack
29081 entries will make them revert to the old variable value.
29085 2: a => a 2: a => 17 2: a => a
29086 1: a + 1 => a + 1 1: a + 1 => 18 1: a + 1 => a + 1
29089 17 s l a @key{RET} p 8 @key{RET}
29093 Here the @kbd{p 8} command changes the current precision,
29094 thus causing the @samp{=>} forms to be recomputed after the
29095 influence of the ``let'' is gone. The @kbd{d @key{SPC}} command
29096 (@code{calc-refresh}) is a handy way to force the @samp{=>}
29097 operators on the stack to be recomputed without any other
29101 @pindex calc-assign
29104 Embedded mode also uses @samp{=>} operators. In Embedded mode,
29105 the lefthand side of an @samp{=>} operator can refer to variables
29106 assigned elsewhere in the file by @samp{:=} operators. The
29107 assignment operator @samp{a := 17} does not actually do anything
29108 by itself. But Embedded mode recognizes it and marks it as a sort
29109 of file-local definition of the variable. You can enter @samp{:=}
29110 operators in Algebraic mode, or by using the @kbd{s :}
29111 (@code{calc-assign}) [@code{assign}] command which takes a variable
29112 and value from the stack and replaces them with an assignment.
29114 @xref{TeX and LaTeX Language Modes}, for the way @samp{=>} appears in
29115 @TeX{} language output. The @dfn{eqn} mode gives similar
29116 treatment to @samp{=>}.
29118 @node Graphics, Kill and Yank, Store and Recall, Top
29122 The commands for graphing data begin with the @kbd{g} prefix key. Calc
29123 uses GNUPLOT 2.0 or later to do graphics. These commands will only work
29124 if GNUPLOT is available on your system. (While GNUPLOT sounds like
29125 a relative of GNU Emacs, it is actually completely unrelated.
29126 However, it is free software. It can be obtained from
29127 @samp{http://www.gnuplot.info}.)
29129 @vindex calc-gnuplot-name
29130 If you have GNUPLOT installed on your system but Calc is unable to
29131 find it, you may need to set the @code{calc-gnuplot-name} variable in
29132 your Calc init file or @file{.emacs}. You may also need to set some
29133 Lisp variables to show Calc how to run GNUPLOT on your system; these
29134 are described under @kbd{g D} and @kbd{g O} below. If you are using
29135 the X window system or MS-Windows, Calc will configure GNUPLOT for you
29136 automatically. If you have GNUPLOT 3.0 or later and you are using a
29137 Unix or GNU system without X, Calc will configure GNUPLOT to display
29138 graphs using simple character graphics that will work on any
29139 Posix-compatible terminal.
29143 * Three Dimensional Graphics::
29144 * Managing Curves::
29145 * Graphics Options::
29149 @node Basic Graphics, Three Dimensional Graphics, Graphics, Graphics
29150 @section Basic Graphics
29154 @pindex calc-graph-fast
29155 The easiest graphics command is @kbd{g f} (@code{calc-graph-fast}).
29156 This command takes two vectors of equal length from the stack.
29157 The vector at the top of the stack represents the ``y'' values of
29158 the various data points. The vector in the second-to-top position
29159 represents the corresponding ``x'' values. This command runs
29160 GNUPLOT (if it has not already been started by previous graphing
29161 commands) and displays the set of data points. The points will
29162 be connected by lines, and there will also be some kind of symbol
29163 to indicate the points themselves.
29165 The ``x'' entry may instead be an interval form, in which case suitable
29166 ``x'' values are interpolated between the minimum and maximum values of
29167 the interval (whether the interval is open or closed is ignored).
29169 The ``x'' entry may also be a number, in which case Calc uses the
29170 sequence of ``x'' values @expr{x}, @expr{x+1}, @expr{x+2}, etc.
29171 (Generally the number 0 or 1 would be used for @expr{x} in this case.)
29173 The ``y'' entry may be any formula instead of a vector. Calc effectively
29174 uses @kbd{N} (@code{calc-eval-num}) to evaluate variables in the formula;
29175 the result of this must be a formula in a single (unassigned) variable.
29176 The formula is plotted with this variable taking on the various ``x''
29177 values. Graphs of formulas by default use lines without symbols at the
29178 computed data points. Note that if neither ``x'' nor ``y'' is a vector,
29179 Calc guesses at a reasonable number of data points to use. See the
29180 @kbd{g N} command below. (The ``x'' values must be either a vector
29181 or an interval if ``y'' is a formula.)
29187 If ``y'' is (or evaluates to) a formula of the form
29188 @samp{xy(@var{x}, @var{y})} then the result is a
29189 parametric plot. The two arguments of the fictitious @code{xy} function
29190 are used as the ``x'' and ``y'' coordinates of the curve, respectively.
29191 In this case the ``x'' vector or interval you specified is not directly
29192 visible in the graph. For example, if ``x'' is the interval @samp{[0..360]}
29193 and ``y'' is the formula @samp{xy(sin(t), cos(t))}, the resulting graph
29196 Also, ``x'' and ``y'' may each be variable names, in which case Calc
29197 looks for suitable vectors, intervals, or formulas stored in those
29200 The ``x'' and ``y'' values for the data points (as pulled from the vectors,
29201 calculated from the formulas, or interpolated from the intervals) should
29202 be real numbers (integers, fractions, or floats). One exception to this
29203 is that the ``y'' entry can consist of a vector of numbers combined with
29204 error forms, in which case the points will be plotted with the
29205 appropriate error bars. Other than this, if either the ``x''
29206 value or the ``y'' value of a given data point is not a real number, that
29207 data point will be omitted from the graph. The points on either side
29208 of the invalid point will @emph{not} be connected by a line.
29210 See the documentation for @kbd{g a} below for a description of the way
29211 numeric prefix arguments affect @kbd{g f}.
29213 @cindex @code{PlotRejects} variable
29214 @vindex PlotRejects
29215 If you store an empty vector in the variable @code{PlotRejects}
29216 (i.e., @kbd{[ ] s t PlotRejects}), Calc will append information to
29217 this vector for every data point which was rejected because its
29218 ``x'' or ``y'' values were not real numbers. The result will be
29219 a matrix where each row holds the curve number, data point number,
29220 ``x'' value, and ``y'' value for a rejected data point.
29221 @xref{Evaluates-To Operator}, for a handy way to keep tabs on the
29222 current value of @code{PlotRejects}. @xref{Operations on Variables},
29223 for the @kbd{s R} command which is another easy way to examine
29224 @code{PlotRejects}.
29227 @pindex calc-graph-clear
29228 To clear the graphics display, type @kbd{g c} (@code{calc-graph-clear}).
29229 If the GNUPLOT output device is an X window, the window will go away.
29230 Effects on other kinds of output devices will vary. You don't need
29231 to use @kbd{g c} if you don't want to---if you give another @kbd{g f}
29232 or @kbd{g p} command later on, it will reuse the existing graphics
29233 window if there is one.
29235 @node Three Dimensional Graphics, Managing Curves, Basic Graphics, Graphics
29236 @section Three-Dimensional Graphics
29239 @pindex calc-graph-fast-3d
29240 The @kbd{g F} (@code{calc-graph-fast-3d}) command makes a three-dimensional
29241 graph. It works only if you have GNUPLOT 3.0 or later; with GNUPLOT 2.0,
29242 you will see a GNUPLOT error message if you try this command.
29244 The @kbd{g F} command takes three values from the stack, called ``x'',
29245 ``y'', and ``z'', respectively. As was the case for 2D graphs, there
29246 are several options for these values.
29248 In the first case, ``x'' and ``y'' are each vectors (not necessarily of
29249 the same length); either or both may instead be interval forms. The
29250 ``z'' value must be a matrix with the same number of rows as elements
29251 in ``x'', and the same number of columns as elements in ``y''. The
29252 result is a surface plot where
29253 @texline @math{z_{ij}}
29254 @infoline @expr{z_ij}
29255 is the height of the point
29256 at coordinate @expr{(x_i, y_j)} on the surface. The 3D graph will
29257 be displayed from a certain default viewpoint; you can change this
29258 viewpoint by adding a @samp{set view} to the @file{*Gnuplot Commands*}
29259 buffer as described later. See the GNUPLOT documentation for a
29260 description of the @samp{set view} command.
29262 Each point in the matrix will be displayed as a dot in the graph,
29263 and these points will be connected by a grid of lines (@dfn{isolines}).
29265 In the second case, ``x'', ``y'', and ``z'' are all vectors of equal
29266 length. The resulting graph displays a 3D line instead of a surface,
29267 where the coordinates of points along the line are successive triplets
29268 of values from the input vectors.
29270 In the third case, ``x'' and ``y'' are vectors or interval forms, and
29271 ``z'' is any formula involving two variables (not counting variables
29272 with assigned values). These variables are sorted into alphabetical
29273 order; the first takes on values from ``x'' and the second takes on
29274 values from ``y'' to form a matrix of results that are graphed as a
29281 If the ``z'' formula evaluates to a call to the fictitious function
29282 @samp{xyz(@var{x}, @var{y}, @var{z})}, then the result is a
29283 ``parametric surface.'' In this case, the axes of the graph are
29284 taken from the @var{x} and @var{y} values in these calls, and the
29285 ``x'' and ``y'' values from the input vectors or intervals are used only
29286 to specify the range of inputs to the formula. For example, plotting
29287 @samp{[0..360], [0..180], xyz(sin(x)*sin(y), cos(x)*sin(y), cos(y))}
29288 will draw a sphere. (Since the default resolution for 3D plots is
29289 5 steps in each of ``x'' and ``y'', this will draw a very crude
29290 sphere. You could use the @kbd{g N} command, described below, to
29291 increase this resolution, or specify the ``x'' and ``y'' values as
29292 vectors with more than 5 elements.
29294 It is also possible to have a function in a regular @kbd{g f} plot
29295 evaluate to an @code{xyz} call. Since @kbd{g f} plots a line, not
29296 a surface, the result will be a 3D parametric line. For example,
29297 @samp{[[0..720], xyz(sin(x), cos(x), x)]} will plot two turns of a
29298 helix (a three-dimensional spiral).
29300 As for @kbd{g f}, each of ``x'', ``y'', and ``z'' may instead be
29301 variables containing the relevant data.
29303 @node Managing Curves, Graphics Options, Three Dimensional Graphics, Graphics
29304 @section Managing Curves
29307 The @kbd{g f} command is really shorthand for the following commands:
29308 @kbd{C-u g d g a g p}. Likewise, @w{@kbd{g F}} is shorthand for
29309 @kbd{C-u g d g A g p}. You can gain more control over your graph
29310 by using these commands directly.
29313 @pindex calc-graph-add
29314 The @kbd{g a} (@code{calc-graph-add}) command adds the ``curve''
29315 represented by the two values on the top of the stack to the current
29316 graph. You can have any number of curves in the same graph. When
29317 you give the @kbd{g p} command, all the curves will be drawn superimposed
29320 The @kbd{g a} command (and many others that affect the current graph)
29321 will cause a special buffer, @file{*Gnuplot Commands*}, to be displayed
29322 in another window. This buffer is a template of the commands that will
29323 be sent to GNUPLOT when it is time to draw the graph. The first
29324 @kbd{g a} command adds a @code{plot} command to this buffer. Succeeding
29325 @kbd{g a} commands add extra curves onto that @code{plot} command.
29326 Other graph-related commands put other GNUPLOT commands into this
29327 buffer. In normal usage you never need to work with this buffer
29328 directly, but you can if you wish. The only constraint is that there
29329 must be only one @code{plot} command, and it must be the last command
29330 in the buffer. If you want to save and later restore a complete graph
29331 configuration, you can use regular Emacs commands to save and restore
29332 the contents of the @file{*Gnuplot Commands*} buffer.
29336 If the values on the stack are not variable names, @kbd{g a} will invent
29337 variable names for them (of the form @samp{PlotData@var{n}}) and store
29338 the values in those variables. The ``x'' and ``y'' variables are what
29339 go into the @code{plot} command in the template. If you add a curve
29340 that uses a certain variable and then later change that variable, you
29341 can replot the graph without having to delete and re-add the curve.
29342 That's because the variable name, not the vector, interval or formula
29343 itself, is what was added by @kbd{g a}.
29345 A numeric prefix argument on @kbd{g a} or @kbd{g f} changes the way
29346 stack entries are interpreted as curves. With a positive prefix
29347 argument @expr{n}, the top @expr{n} stack entries are ``y'' values
29348 for @expr{n} different curves which share a common ``x'' value in
29349 the @expr{n+1}st stack entry. (Thus @kbd{g a} with no prefix
29350 argument is equivalent to @kbd{C-u 1 g a}.)
29352 A prefix of zero or plain @kbd{C-u} means to take two stack entries,
29353 ``x'' and ``y'' as usual, but to interpret ``y'' as a vector of
29354 ``y'' values for several curves that share a common ``x''.
29356 A negative prefix argument tells Calc to read @expr{n} vectors from
29357 the stack; each vector @expr{[x, y]} describes an independent curve.
29358 This is the only form of @kbd{g a} that creates several curves at once
29359 that don't have common ``x'' values. (Of course, the range of ``x''
29360 values covered by all the curves ought to be roughly the same if
29361 they are to look nice on the same graph.)
29363 For example, to plot
29364 @texline @math{\sin n x}
29365 @infoline @expr{sin(n x)}
29366 for integers @expr{n}
29367 from 1 to 5, you could use @kbd{v x} to create a vector of integers
29368 (@expr{n}), then @kbd{V M '} or @kbd{V M $} to map @samp{sin(n x)}
29369 across this vector. The resulting vector of formulas is suitable
29370 for use as the ``y'' argument to a @kbd{C-u g a} or @kbd{C-u g f}
29374 @pindex calc-graph-add-3d
29375 The @kbd{g A} (@code{calc-graph-add-3d}) command adds a 3D curve
29376 to the graph. It is not valid to intermix 2D and 3D curves in a
29377 single graph. This command takes three arguments, ``x'', ``y'',
29378 and ``z'', from the stack. With a positive prefix @expr{n}, it
29379 takes @expr{n+2} arguments (common ``x'' and ``y'', plus @expr{n}
29380 separate ``z''s). With a zero prefix, it takes three stack entries
29381 but the ``z'' entry is a vector of curve values. With a negative
29382 prefix @expr{-n}, it takes @expr{n} vectors of the form @expr{[x, y, z]}.
29383 The @kbd{g A} command works by adding a @code{splot} (surface-plot)
29384 command to the @file{*Gnuplot Commands*} buffer.
29386 (Although @kbd{g a} adds a 2D @code{plot} command to the
29387 @file{*Gnuplot Commands*} buffer, Calc changes this to @code{splot}
29388 before sending it to GNUPLOT if it notices that the data points are
29389 evaluating to @code{xyz} calls. It will not work to mix 2D and 3D
29390 @kbd{g a} curves in a single graph, although Calc does not currently
29394 @pindex calc-graph-delete
29395 The @kbd{g d} (@code{calc-graph-delete}) command deletes the most
29396 recently added curve from the graph. It has no effect if there are
29397 no curves in the graph. With a numeric prefix argument of any kind,
29398 it deletes all of the curves from the graph.
29401 @pindex calc-graph-hide
29402 The @kbd{g H} (@code{calc-graph-hide}) command ``hides'' or ``unhides''
29403 the most recently added curve. A hidden curve will not appear in
29404 the actual plot, but information about it such as its name and line and
29405 point styles will be retained.
29408 @pindex calc-graph-juggle
29409 The @kbd{g j} (@code{calc-graph-juggle}) command moves the curve
29410 at the end of the list (the ``most recently added curve'') to the
29411 front of the list. The next-most-recent curve is thus exposed for
29412 @w{@kbd{g d}} or similar commands to use. With @kbd{g j} you can work
29413 with any curve in the graph even though curve-related commands only
29414 affect the last curve in the list.
29417 @pindex calc-graph-plot
29418 The @kbd{g p} (@code{calc-graph-plot}) command uses GNUPLOT to draw
29419 the graph described in the @file{*Gnuplot Commands*} buffer. Any
29420 GNUPLOT parameters which are not defined by commands in this buffer
29421 are reset to their default values. The variables named in the @code{plot}
29422 command are written to a temporary data file and the variable names
29423 are then replaced by the file name in the template. The resulting
29424 plotting commands are fed to the GNUPLOT program. See the documentation
29425 for the GNUPLOT program for more specific information. All temporary
29426 files are removed when Emacs or GNUPLOT exits.
29428 If you give a formula for ``y'', Calc will remember all the values that
29429 it calculates for the formula so that later plots can reuse these values.
29430 Calc throws out these saved values when you change any circumstances
29431 that may affect the data, such as switching from Degrees to Radians
29432 mode, or changing the value of a parameter in the formula. You can
29433 force Calc to recompute the data from scratch by giving a negative
29434 numeric prefix argument to @kbd{g p}.
29436 Calc uses a fairly rough step size when graphing formulas over intervals.
29437 This is to ensure quick response. You can ``refine'' a plot by giving
29438 a positive numeric prefix argument to @kbd{g p}. Calc goes through
29439 the data points it has computed and saved from previous plots of the
29440 function, and computes and inserts a new data point midway between
29441 each of the existing points. You can refine a plot any number of times,
29442 but beware that the amount of calculation involved doubles each time.
29444 Calc does not remember computed values for 3D graphs. This means the
29445 numerix prefix argument, if any, to @kbd{g p} is effectively ignored if
29446 the current graph is three-dimensional.
29449 @pindex calc-graph-print
29450 The @kbd{g P} (@code{calc-graph-print}) command is like @kbd{g p},
29451 except that it sends the output to a printer instead of to the
29452 screen. More precisely, @kbd{g p} looks for @samp{set terminal}
29453 or @samp{set output} commands in the @file{*Gnuplot Commands*} buffer;
29454 lacking these it uses the default settings. However, @kbd{g P}
29455 ignores @samp{set terminal} and @samp{set output} commands and
29456 uses a different set of default values. All of these values are
29457 controlled by the @kbd{g D} and @kbd{g O} commands discussed below.
29458 Provided everything is set up properly, @kbd{g p} will plot to
29459 the screen unless you have specified otherwise and @kbd{g P} will
29460 always plot to the printer.
29462 @node Graphics Options, Devices, Managing Curves, Graphics
29463 @section Graphics Options
29467 @pindex calc-graph-grid
29468 The @kbd{g g} (@code{calc-graph-grid}) command turns the ``grid''
29469 on and off. It is off by default; tick marks appear only at the
29470 edges of the graph. With the grid turned on, dotted lines appear
29471 across the graph at each tick mark. Note that this command only
29472 changes the setting in @file{*Gnuplot Commands*}; to see the effects
29473 of the change you must give another @kbd{g p} command.
29476 @pindex calc-graph-border
29477 The @kbd{g b} (@code{calc-graph-border}) command turns the border
29478 (the box that surrounds the graph) on and off. It is on by default.
29479 This command will only work with GNUPLOT 3.0 and later versions.
29482 @pindex calc-graph-key
29483 The @kbd{g k} (@code{calc-graph-key}) command turns the ``key''
29484 on and off. The key is a chart in the corner of the graph that
29485 shows the correspondence between curves and line styles. It is
29486 off by default, and is only really useful if you have several
29487 curves on the same graph.
29490 @pindex calc-graph-num-points
29491 The @kbd{g N} (@code{calc-graph-num-points}) command allows you
29492 to select the number of data points in the graph. This only affects
29493 curves where neither ``x'' nor ``y'' is specified as a vector.
29494 Enter a blank line to revert to the default value (initially 15).
29495 With no prefix argument, this command affects only the current graph.
29496 With a positive prefix argument this command changes or, if you enter
29497 a blank line, displays the default number of points used for all
29498 graphs created by @kbd{g a} that don't specify the resolution explicitly.
29499 With a negative prefix argument, this command changes or displays
29500 the default value (initially 5) used for 3D graphs created by @kbd{g A}.
29501 Note that a 3D setting of 5 means that a total of @expr{5^2 = 25} points
29502 will be computed for the surface.
29504 Data values in the graph of a function are normally computed to a
29505 precision of five digits, regardless of the current precision at the
29506 time. This is usually more than adequate, but there are cases where
29507 it will not be. For example, plotting @expr{1 + x} with @expr{x} in the
29508 interval @samp{[0 ..@: 1e-6]} will round all the data points down
29509 to 1.0! Putting the command @samp{set precision @var{n}} in the
29510 @file{*Gnuplot Commands*} buffer will cause the data to be computed
29511 at precision @var{n} instead of 5. Since this is such a rare case,
29512 there is no keystroke-based command to set the precision.
29515 @pindex calc-graph-header
29516 The @kbd{g h} (@code{calc-graph-header}) command sets the title
29517 for the graph. This will show up centered above the graph.
29518 The default title is blank (no title).
29521 @pindex calc-graph-name
29522 The @kbd{g n} (@code{calc-graph-name}) command sets the title of an
29523 individual curve. Like the other curve-manipulating commands, it
29524 affects the most recently added curve, i.e., the last curve on the
29525 list in the @file{*Gnuplot Commands*} buffer. To set the title of
29526 the other curves you must first juggle them to the end of the list
29527 with @kbd{g j}, or edit the @file{*Gnuplot Commands*} buffer by hand.
29528 Curve titles appear in the key; if the key is turned off they are
29533 @pindex calc-graph-title-x
29534 @pindex calc-graph-title-y
29535 The @kbd{g t} (@code{calc-graph-title-x}) and @kbd{g T}
29536 (@code{calc-graph-title-y}) commands set the titles on the ``x''
29537 and ``y'' axes, respectively. These titles appear next to the
29538 tick marks on the left and bottom edges of the graph, respectively.
29539 Calc does not have commands to control the tick marks themselves,
29540 but you can edit them into the @file{*Gnuplot Commands*} buffer if
29541 you wish. See the GNUPLOT documentation for details.
29545 @pindex calc-graph-range-x
29546 @pindex calc-graph-range-y
29547 The @kbd{g r} (@code{calc-graph-range-x}) and @kbd{g R}
29548 (@code{calc-graph-range-y}) commands set the range of values on the
29549 ``x'' and ``y'' axes, respectively. You are prompted to enter a
29550 suitable range. This should be either a pair of numbers of the
29551 form, @samp{@var{min}:@var{max}}, or a blank line to revert to the
29552 default behavior of setting the range based on the range of values
29553 in the data, or @samp{$} to take the range from the top of the stack.
29554 Ranges on the stack can be represented as either interval forms or
29555 vectors: @samp{[@var{min} ..@: @var{max}]} or @samp{[@var{min}, @var{max}]}.
29559 @pindex calc-graph-log-x
29560 @pindex calc-graph-log-y
29561 The @kbd{g l} (@code{calc-graph-log-x}) and @kbd{g L} (@code{calc-graph-log-y})
29562 commands allow you to set either or both of the axes of the graph to
29563 be logarithmic instead of linear.
29568 @pindex calc-graph-log-z
29569 @pindex calc-graph-range-z
29570 @pindex calc-graph-title-z
29571 For 3D plots, @kbd{g C-t}, @kbd{g C-r}, and @kbd{g C-l} (those are
29572 letters with the Control key held down) are the corresponding commands
29573 for the ``z'' axis.
29577 @pindex calc-graph-zero-x
29578 @pindex calc-graph-zero-y
29579 The @kbd{g z} (@code{calc-graph-zero-x}) and @kbd{g Z}
29580 (@code{calc-graph-zero-y}) commands control whether a dotted line is
29581 drawn to indicate the ``x'' and/or ``y'' zero axes. (These are the same
29582 dotted lines that would be drawn there anyway if you used @kbd{g g} to
29583 turn the ``grid'' feature on.) Zero-axis lines are on by default, and
29584 may be turned off only in GNUPLOT 3.0 and later versions. They are
29585 not available for 3D plots.
29588 @pindex calc-graph-line-style
29589 The @kbd{g s} (@code{calc-graph-line-style}) command turns the connecting
29590 lines on or off for the most recently added curve, and optionally selects
29591 the style of lines to be used for that curve. Plain @kbd{g s} simply
29592 toggles the lines on and off. With a numeric prefix argument, @kbd{g s}
29593 turns lines on and sets a particular line style. Line style numbers
29594 start at one and their meanings vary depending on the output device.
29595 GNUPLOT guarantees that there will be at least six different line styles
29596 available for any device.
29599 @pindex calc-graph-point-style
29600 The @kbd{g S} (@code{calc-graph-point-style}) command similarly turns
29601 the symbols at the data points on or off, or sets the point style.
29602 If you turn both lines and points off, the data points will show as
29603 tiny dots. If the ``y'' values being plotted contain error forms and
29604 the connecting lines are turned off, then this command will also turn
29605 the error bars on or off.
29607 @cindex @code{LineStyles} variable
29608 @cindex @code{PointStyles} variable
29610 @vindex PointStyles
29611 Another way to specify curve styles is with the @code{LineStyles} and
29612 @code{PointStyles} variables. These variables initially have no stored
29613 values, but if you store a vector of integers in one of these variables,
29614 the @kbd{g a} and @kbd{g f} commands will use those style numbers
29615 instead of the defaults for new curves that are added to the graph.
29616 An entry should be a positive integer for a specific style, or 0 to let
29617 the style be chosen automatically, or @mathit{-1} to turn off lines or points
29618 altogether. If there are more curves than elements in the vector, the
29619 last few curves will continue to have the default styles. Of course,
29620 you can later use @kbd{g s} and @kbd{g S} to change any of these styles.
29622 For example, @kbd{'[2 -1 3] @key{RET} s t LineStyles} causes the first curve
29623 to have lines in style number 2, the second curve to have no connecting
29624 lines, and the third curve to have lines in style 3. Point styles will
29625 still be assigned automatically, but you could store another vector in
29626 @code{PointStyles} to define them, too.
29628 @node Devices, , Graphics Options, Graphics
29629 @section Graphical Devices
29633 @pindex calc-graph-device
29634 The @kbd{g D} (@code{calc-graph-device}) command sets the device name
29635 (or ``terminal name'' in GNUPLOT lingo) to be used by @kbd{g p} commands
29636 on this graph. It does not affect the permanent default device name.
29637 If you enter a blank name, the device name reverts to the default.
29638 Enter @samp{?} to see a list of supported devices.
29640 With a positive numeric prefix argument, @kbd{g D} instead sets
29641 the default device name, used by all plots in the future which do
29642 not override it with a plain @kbd{g D} command. If you enter a
29643 blank line this command shows you the current default. The special
29644 name @code{default} signifies that Calc should choose @code{x11} if
29645 the X window system is in use (as indicated by the presence of a
29646 @code{DISPLAY} environment variable), @code{windows} on MS-Windows, or
29647 otherwise @code{dumb} under GNUPLOT 3.0 and later, or
29648 @code{postscript} under GNUPLOT 2.0. This is the initial default
29651 The @code{dumb} device is an interface to ``dumb terminals,'' i.e.,
29652 terminals with no special graphics facilities. It writes a crude
29653 picture of the graph composed of characters like @code{-} and @code{|}
29654 to a buffer called @file{*Gnuplot Trail*}, which Calc then displays.
29655 The graph is made the same size as the Emacs screen, which on most
29656 dumb terminals will be
29657 @texline @math{80\times24}
29659 characters. The graph is displayed in
29660 an Emacs ``recursive edit''; type @kbd{q} or @kbd{C-c C-c} to exit
29661 the recursive edit and return to Calc. Note that the @code{dumb}
29662 device is present only in GNUPLOT 3.0 and later versions.
29664 The word @code{dumb} may be followed by two numbers separated by
29665 spaces. These are the desired width and height of the graph in
29666 characters. Also, the device name @code{big} is like @code{dumb}
29667 but creates a graph four times the width and height of the Emacs
29668 screen. You will then have to scroll around to view the entire
29669 graph. In the @file{*Gnuplot Trail*} buffer, @key{SPC}, @key{DEL},
29670 @kbd{<}, and @kbd{>} are defined to scroll by one screenful in each
29671 of the four directions.
29673 With a negative numeric prefix argument, @kbd{g D} sets or displays
29674 the device name used by @kbd{g P} (@code{calc-graph-print}). This
29675 is initially @code{postscript}. If you don't have a PostScript
29676 printer, you may decide once again to use @code{dumb} to create a
29677 plot on any text-only printer.
29680 @pindex calc-graph-output
29681 The @kbd{g O} (@code{calc-graph-output}) command sets the name of the
29682 output file used by GNUPLOT@. For some devices, notably @code{x11} and
29683 @code{windows}, there is no output file and this information is not
29684 used. Many other ``devices'' are really file formats like
29685 @code{postscript}; in these cases the output in the desired format
29686 goes into the file you name with @kbd{g O}. Type @kbd{g O stdout
29687 @key{RET}} to set GNUPLOT to write to its standard output stream,
29688 i.e., to @file{*Gnuplot Trail*}. This is the default setting.
29690 Another special output name is @code{tty}, which means that GNUPLOT
29691 is going to write graphics commands directly to its standard output,
29692 which you wish Emacs to pass through to your terminal. Tektronix
29693 graphics terminals, among other devices, operate this way. Calc does
29694 this by telling GNUPLOT to write to a temporary file, then running a
29695 sub-shell executing the command @samp{cat tempfile >/dev/tty}. On
29696 typical Unix systems, this will copy the temporary file directly to
29697 the terminal, bypassing Emacs entirely. You will have to type @kbd{C-l}
29698 to Emacs afterwards to refresh the screen.
29700 Once again, @kbd{g O} with a positive or negative prefix argument
29701 sets the default or printer output file names, respectively. In each
29702 case you can specify @code{auto}, which causes Calc to invent a temporary
29703 file name for each @kbd{g p} (or @kbd{g P}) command. This temporary file
29704 will be deleted once it has been displayed or printed. If the output file
29705 name is not @code{auto}, the file is not automatically deleted.
29707 The default and printer devices and output files can be saved
29708 permanently by the @kbd{m m} (@code{calc-save-modes}) command. The
29709 default number of data points (see @kbd{g N}) and the X geometry
29710 (see @kbd{g X}) are also saved. Other graph information is @emph{not}
29711 saved; you can save a graph's configuration simply by saving the contents
29712 of the @file{*Gnuplot Commands*} buffer.
29714 @vindex calc-gnuplot-plot-command
29715 @vindex calc-gnuplot-default-device
29716 @vindex calc-gnuplot-default-output
29717 @vindex calc-gnuplot-print-command
29718 @vindex calc-gnuplot-print-device
29719 @vindex calc-gnuplot-print-output
29720 You may wish to configure the default and
29721 printer devices and output files for the whole system. The relevant
29722 Lisp variables are @code{calc-gnuplot-default-device} and @code{-output},
29723 and @code{calc-gnuplot-print-device} and @code{-output}. The output
29724 file names must be either strings as described above, or Lisp
29725 expressions which are evaluated on the fly to get the output file names.
29727 Other important Lisp variables are @code{calc-gnuplot-plot-command} and
29728 @code{calc-gnuplot-print-command}, which give the system commands to
29729 display or print the output of GNUPLOT, respectively. These may be
29730 @code{nil} if no command is necessary, or strings which can include
29731 @samp{%s} to signify the name of the file to be displayed or printed.
29732 Or, these variables may contain Lisp expressions which are evaluated
29733 to display or print the output. These variables are customizable
29734 (@pxref{Customizing Calc}).
29737 @pindex calc-graph-display
29738 The @kbd{g x} (@code{calc-graph-display}) command lets you specify
29739 on which X window system display your graphs should be drawn. Enter
29740 a blank line to see the current display name. This command has no
29741 effect unless the current device is @code{x11}.
29744 @pindex calc-graph-geometry
29745 The @kbd{g X} (@code{calc-graph-geometry}) command is a similar
29746 command for specifying the position and size of the X window.
29747 The normal value is @code{default}, which generally means your
29748 window manager will let you place the window interactively.
29749 Entering @samp{800x500+0+0} would create an 800-by-500 pixel
29750 window in the upper-left corner of the screen. This command has no
29751 effect if the current device is @code{windows}.
29753 The buffer called @file{*Gnuplot Trail*} holds a transcript of the
29754 session with GNUPLOT@. This shows the commands Calc has ``typed'' to
29755 GNUPLOT and the responses it has received. Calc tries to notice when an
29756 error message has appeared here and display the buffer for you when
29757 this happens. You can check this buffer yourself if you suspect
29758 something has gone wrong@footnote{
29759 On MS-Windows, due to the peculiarities of how the Windows version of
29760 GNUPLOT (called @command{wgnuplot}) works, the GNUPLOT responses are
29761 not communicated back to Calc. Instead, you need to look them up in
29762 the GNUPLOT command window that is displayed as in normal interactive
29767 @pindex calc-graph-command
29768 The @kbd{g C} (@code{calc-graph-command}) command prompts you to
29769 enter any line of text, then simply sends that line to the current
29770 GNUPLOT process. The @file{*Gnuplot Trail*} buffer looks deceptively
29771 like a Shell buffer but you can't type commands in it yourself.
29772 Instead, you must use @kbd{g C} for this purpose.
29776 @pindex calc-graph-view-commands
29777 @pindex calc-graph-view-trail
29778 The @kbd{g v} (@code{calc-graph-view-commands}) and @kbd{g V}
29779 (@code{calc-graph-view-trail}) commands display the @file{*Gnuplot Commands*}
29780 and @file{*Gnuplot Trail*} buffers, respectively, in another window.
29781 This happens automatically when Calc thinks there is something you
29782 will want to see in either of these buffers. If you type @kbd{g v}
29783 or @kbd{g V} when the relevant buffer is already displayed, the
29784 buffer is hidden again. (Note that on MS-Windows, the @file{*Gnuplot
29785 Trail*} buffer will usually show nothing of interest, because
29786 GNUPLOT's responses are not communicated back to Calc.)
29788 One reason to use @kbd{g v} is to add your own commands to the
29789 @file{*Gnuplot Commands*} buffer. Press @kbd{g v}, then use
29790 @kbd{C-x o} to switch into that window. For example, GNUPLOT has
29791 @samp{set label} and @samp{set arrow} commands that allow you to
29792 annotate your plots. Since Calc doesn't understand these commands,
29793 you have to add them to the @file{*Gnuplot Commands*} buffer
29794 yourself, then use @w{@kbd{g p}} to replot using these new commands. Note
29795 that your commands must appear @emph{before} the @code{plot} command.
29796 To get help on any GNUPLOT feature, type, e.g., @kbd{g C help set label}.
29797 You may have to type @kbd{g C @key{RET}} a few times to clear the
29798 ``press return for more'' or ``subtopic of @dots{}'' requests.
29799 Note that Calc always sends commands (like @samp{set nolabel}) to
29800 reset all plotting parameters to the defaults before each plot, so
29801 to delete a label all you need to do is delete the @samp{set label}
29802 line you added (or comment it out with @samp{#}) and then replot
29806 @pindex calc-graph-quit
29807 You can use @kbd{g q} (@code{calc-graph-quit}) to kill the GNUPLOT
29808 process that is running. The next graphing command you give will
29809 start a fresh GNUPLOT process. The word @samp{Graph} appears in
29810 the Calc window's mode line whenever a GNUPLOT process is currently
29811 running. The GNUPLOT process is automatically killed when you
29812 exit Emacs if you haven't killed it manually by then.
29815 @pindex calc-graph-kill
29816 The @kbd{g K} (@code{calc-graph-kill}) command is like @kbd{g q}
29817 except that it also views the @file{*Gnuplot Trail*} buffer so that
29818 you can see the process being killed. This is better if you are
29819 killing GNUPLOT because you think it has gotten stuck.
29821 @node Kill and Yank, Keypad Mode, Graphics, Top
29822 @chapter Kill and Yank Functions
29825 The commands in this chapter move information between the Calculator and
29826 other Emacs editing buffers.
29828 In many cases Embedded mode is an easier and more natural way to
29829 work with Calc from a regular editing buffer. @xref{Embedded Mode}.
29832 * Killing From Stack::
29833 * Yanking Into Stack::
29834 * Saving Into Registers::
29835 * Inserting From Registers::
29836 * Grabbing From Buffers::
29837 * Yanking Into Buffers::
29838 * X Cut and Paste::
29841 @node Killing From Stack, Yanking Into Stack, Kill and Yank, Kill and Yank
29842 @section Killing from the Stack
29848 @pindex calc-copy-as-kill
29850 @pindex calc-kill-region
29852 @pindex calc-copy-region-as-kill
29855 @dfn{Kill} commands are Emacs commands that insert text into the ``kill
29856 ring,'' from which it can later be ``yanked'' by a @kbd{C-y} command.
29857 Three common kill commands in normal Emacs are @kbd{C-k}, which kills
29858 one line, @kbd{C-w}, which kills the region between mark and point, and
29859 @kbd{M-w}, which puts the region into the kill ring without actually
29860 deleting it. All of these commands work in the Calculator, too,
29861 although in the Calculator they operate on whole stack entries, so they
29862 ``round up'' the specified region to encompass full lines. (To copy
29863 only parts of lines, the @kbd{M-C-w} command in the Calculator will copy
29864 the region to the kill ring without any ``rounding up'', just like the
29865 @kbd{M-w} command in normal Emacs.) Also, @kbd{M-k} has been provided
29866 to complete the set; it puts the current line into the kill ring without
29869 The kill commands are unusual in that they pay attention to the location
29870 of the cursor in the Calculator buffer. If the cursor is on or below
29871 the bottom line, the kill commands operate on the top of the stack.
29872 Otherwise, they operate on whatever stack element the cursor is on. The
29873 text is copied into the kill ring exactly as it appears on the screen,
29874 including line numbers if they are enabled.
29876 A numeric prefix argument to @kbd{C-k} or @kbd{M-k} affects the number
29877 of lines killed. A positive argument kills the current line and @expr{n-1}
29878 lines below it. A negative argument kills the @expr{-n} lines above the
29879 current line. Again this mirrors the behavior of the standard Emacs
29880 @kbd{C-k} command. Although a whole line is always deleted, @kbd{C-k}
29881 with no argument copies only the number itself into the kill ring, whereas
29882 @kbd{C-k} with a prefix argument of 1 copies the number with its trailing
29885 @node Yanking Into Stack, Saving Into Registers, Killing From Stack, Kill and Yank
29886 @section Yanking into the Stack
29891 The @kbd{C-y} command yanks the most recently killed text back into the
29892 Calculator. It pushes this value onto the top of the stack regardless of
29893 the cursor position. In general it re-parses the killed text as a number
29894 or formula (or a list of these separated by commas or newlines). However if
29895 the thing being yanked is something that was just killed from the Calculator
29896 itself, its full internal structure is yanked. For example, if you have
29897 set the floating-point display mode to show only four significant digits,
29898 then killing and re-yanking 3.14159 (which displays as 3.142) will yank the
29899 full 3.14159, even though yanking it into any other buffer would yank the
29900 number in its displayed form, 3.142. (Since the default display modes
29901 show all objects to their full precision, this feature normally makes no
29904 @node Saving Into Registers, Inserting From Registers, Yanking Into Stack, Kill and Yank
29905 @section Saving into Registers
29909 @pindex calc-copy-to-register
29910 @pindex calc-prepend-to-register
29911 @pindex calc-append-to-register
29913 An alternative to killing and yanking stack entries is using
29914 registers in Calc. Saving stack entries in registers is like
29915 saving text in normal Emacs registers; although, like Calc's kill
29916 commands, register commands always operate on whole stack
29919 Registers in Calc are places to store stack entries for later use;
29920 each register is indexed by a single character. To store the current
29921 region (rounded up, of course, to include full stack entries) into a
29922 register, use the command @kbd{r s} (@code{calc-copy-to-register}).
29923 You will then be prompted for a register to use, the next character
29924 you type will be the index for the register. To store the region in
29925 register @var{r}, the full command will be @kbd{r s @var{r}}. With an
29926 argument, @kbd{C-u r s @var{r}}, the region being copied to the
29927 register will be deleted from the Calc buffer.
29929 It is possible to add additional stack entries to a register. The
29930 command @kbd{M-x calc-append-to-register} will prompt for a register,
29931 then add the stack entries in the region to the end of the register
29932 contents. The command @kbd{M-x calc-prepend-to-register} will
29933 similarly prompt for a register and add the stack entries in the
29934 region to the beginning of the register contents. Both commands take
29935 @kbd{C-u} arguments, which will cause the region to be deleted after being
29936 added to the register.
29938 @node Inserting From Registers, Grabbing From Buffers, Saving Into Registers, Kill and Yank
29939 @section Inserting from Registers
29942 @pindex calc-insert-register
29943 The command @kbd{r i} (@code{calc-insert-register}) will prompt for a
29944 register, then insert the contents of that register into the
29945 Calculator. If the contents of the register were placed there from
29946 within Calc, then the full internal structure of the contents will be
29947 inserted into the Calculator, otherwise whatever text is in the
29948 register is reparsed and then inserted into the Calculator.
29950 @node Grabbing From Buffers, Yanking Into Buffers, Inserting From Registers, Kill and Yank
29951 @section Grabbing from Other Buffers
29955 @pindex calc-grab-region
29956 The @kbd{C-x * g} (@code{calc-grab-region}) command takes the text between
29957 point and mark in the current buffer and attempts to parse it as a
29958 vector of values. Basically, it wraps the text in vector brackets
29959 @samp{[ ]} unless the text already is enclosed in vector brackets,
29960 then reads the text as if it were an algebraic entry. The contents
29961 of the vector may be numbers, formulas, or any other Calc objects.
29962 If the @kbd{C-x * g} command works successfully, it does an automatic
29963 @kbd{C-x * c} to enter the Calculator buffer.
29965 A numeric prefix argument grabs the specified number of lines around
29966 point, ignoring the mark. A positive prefix grabs from point to the
29967 @expr{n}th following newline (so that @kbd{M-1 C-x * g} grabs from point
29968 to the end of the current line); a negative prefix grabs from point
29969 back to the @expr{n+1}st preceding newline. In these cases the text
29970 that is grabbed is exactly the same as the text that @kbd{C-k} would
29971 delete given that prefix argument.
29973 A prefix of zero grabs the current line; point may be anywhere on the
29976 A plain @kbd{C-u} prefix interprets the region between point and mark
29977 as a single number or formula rather than a vector. For example,
29978 @kbd{C-x * g} on the text @samp{2 a b} produces the vector of three
29979 values @samp{[2, a, b]}, but @kbd{C-u C-x * g} on the same region
29980 reads a formula which is a product of three things: @samp{2 a b}.
29981 (The text @samp{a + b}, on the other hand, will be grabbed as a
29982 vector of one element by plain @kbd{C-x * g} because the interpretation
29983 @samp{[a, +, b]} would be a syntax error.)
29985 If a different language has been specified (@pxref{Language Modes}),
29986 the grabbed text will be interpreted according to that language.
29989 @pindex calc-grab-rectangle
29990 The @kbd{C-x * r} (@code{calc-grab-rectangle}) command takes the text between
29991 point and mark and attempts to parse it as a matrix. If point and mark
29992 are both in the leftmost column, the lines in between are parsed in their
29993 entirety. Otherwise, point and mark define the corners of a rectangle
29994 whose contents are parsed.
29996 Each line of the grabbed area becomes a row of the matrix. The result
29997 will actually be a vector of vectors, which Calc will treat as a matrix
29998 only if every row contains the same number of values.
30000 If a line contains a portion surrounded by square brackets (or curly
30001 braces), that portion is interpreted as a vector which becomes a row
30002 of the matrix. Any text surrounding the bracketed portion on the line
30005 Otherwise, the entire line is interpreted as a row vector as if it
30006 were surrounded by square brackets. Leading line numbers (in the
30007 format used in the Calc stack buffer) are ignored. If you wish to
30008 force this interpretation (even if the line contains bracketed
30009 portions), give a negative numeric prefix argument to the
30010 @kbd{C-x * r} command.
30012 If you give a numeric prefix argument of zero or plain @kbd{C-u}, each
30013 line is instead interpreted as a single formula which is converted into
30014 a one-element vector. Thus the result of @kbd{C-u C-x * r} will be a
30015 one-column matrix. For example, suppose one line of the data is the
30016 expression @samp{2 a}. A plain @w{@kbd{C-x * r}} will interpret this as
30017 @samp{[2 a]}, which in turn is read as a two-element vector that forms
30018 one row of the matrix. But a @kbd{C-u C-x * r} will interpret this row
30021 If you give a positive numeric prefix argument @var{n}, then each line
30022 will be split up into columns of width @var{n}; each column is parsed
30023 separately as a matrix element. If a line contained
30024 @w{@samp{2 +/- 3 4 +/- 5}}, then grabbing with a prefix argument of 8
30025 would correctly split the line into two error forms.
30027 @xref{Matrix Functions}, to see how to pull the matrix apart into its
30028 constituent rows and columns. (If it is a
30029 @texline @math{1\times1}
30031 matrix, just hit @kbd{v u} (@code{calc-unpack}) twice.)
30035 @pindex calc-grab-sum-across
30036 @pindex calc-grab-sum-down
30037 @cindex Summing rows and columns of data
30038 The @kbd{C-x * :} (@code{calc-grab-sum-down}) command is a handy way to
30039 grab a rectangle of data and sum its columns. It is equivalent to
30040 typing @kbd{C-x * r}, followed by @kbd{V R : +} (the vector reduction
30041 command that sums the columns of a matrix; @pxref{Reducing}). The
30042 result of the command will be a vector of numbers, one for each column
30043 in the input data. The @kbd{C-x * _} (@code{calc-grab-sum-across}) command
30044 similarly grabs a rectangle and sums its rows by executing @w{@kbd{V R _ +}}.
30046 As well as being more convenient, @kbd{C-x * :} and @kbd{C-x * _} are also
30047 much faster because they don't actually place the grabbed vector on
30048 the stack. In a @kbd{C-x * r V R : +} sequence, formatting the vector
30049 for display on the stack takes a large fraction of the total time
30050 (unless you have planned ahead and used @kbd{v .} and @kbd{t .} modes).
30052 For example, suppose we have a column of numbers in a file which we
30053 wish to sum. Go to one corner of the column and press @kbd{C-@@} to
30054 set the mark; go to the other corner and type @kbd{C-x * :}. Since there
30055 is only one column, the result will be a vector of one number, the sum.
30056 (You can type @kbd{v u} to unpack this vector into a plain number if
30057 you want to do further arithmetic with it.)
30059 To compute the product of the column of numbers, we would have to do
30060 it ``by hand'' since there's no special grab-and-multiply command.
30061 Use @kbd{C-x * r} to grab the column of numbers into the calculator in
30062 the form of a column matrix. The statistics command @kbd{u *} is a
30063 handy way to find the product of a vector or matrix of numbers.
30064 @xref{Statistical Operations}. Another approach would be to use
30065 an explicit column reduction command, @kbd{V R : *}.
30067 @node Yanking Into Buffers, X Cut and Paste, Grabbing From Buffers, Kill and Yank
30068 @section Yanking into Other Buffers
30072 @pindex calc-copy-to-buffer
30073 The plain @kbd{y} (@code{calc-copy-to-buffer}) command inserts the number
30074 at the top of the stack into the most recently used normal editing buffer.
30075 (More specifically, this is the most recently used buffer which is displayed
30076 in a window and whose name does not begin with @samp{*}. If there is no
30077 such buffer, this is the most recently used buffer except for Calculator
30078 and Calc Trail buffers.) The number is inserted exactly as it appears and
30079 without a newline. (If line-numbering is enabled, the line number is
30080 normally not included.) The number is @emph{not} removed from the stack.
30082 With a prefix argument, @kbd{y} inserts several numbers, one per line.
30083 A positive argument inserts the specified number of values from the top
30084 of the stack. A negative argument inserts the @expr{n}th value from the
30085 top of the stack. An argument of zero inserts the entire stack. Note
30086 that @kbd{y} with an argument of 1 is slightly different from @kbd{y}
30087 with no argument; the former always copies full lines, whereas the
30088 latter strips off the trailing newline.
30090 With a lone @kbd{C-u} as a prefix argument, @kbd{y} @emph{replaces} the
30091 region in the other buffer with the yanked text, then quits the
30092 Calculator, leaving you in that buffer. A typical use would be to use
30093 @kbd{C-x * g} to read a region of data into the Calculator, operate on the
30094 data to produce a new matrix, then type @kbd{C-u y} to replace the
30095 original data with the new data. One might wish to alter the matrix
30096 display style (@pxref{Vector and Matrix Formats}) or change the current
30097 display language (@pxref{Language Modes}) before doing this. Also, note
30098 that this command replaces a linear region of text (as grabbed by
30099 @kbd{C-x * g}), not a rectangle (as grabbed by @kbd{C-x * r}).
30101 If the editing buffer is in overwrite (as opposed to insert) mode,
30102 and the @kbd{C-u} prefix was not used, then the yanked number will
30103 overwrite the characters following point rather than being inserted
30104 before those characters. The usual conventions of overwrite mode
30105 are observed; for example, characters will be inserted at the end of
30106 a line rather than overflowing onto the next line. Yanking a multi-line
30107 object such as a matrix in overwrite mode overwrites the next @var{n}
30108 lines in the buffer, lengthening or shortening each line as necessary.
30109 Finally, if the thing being yanked is a simple integer or floating-point
30110 number (like @samp{-1.2345e-3}) and the characters following point also
30111 make up such a number, then Calc will replace that number with the new
30112 number, lengthening or shortening as necessary. The concept of
30113 ``overwrite mode'' has thus been generalized from overwriting characters
30114 to overwriting one complete number with another.
30117 The @kbd{C-x * y} key sequence is equivalent to @kbd{y} except that
30118 it can be typed anywhere, not just in Calc. This provides an easy
30119 way to guarantee that Calc knows which editing buffer you want to use!
30121 @node X Cut and Paste, , Yanking Into Buffers, Kill and Yank
30122 @section X Cut and Paste
30125 If you are using Emacs with the X window system, there is an easier
30126 way to move small amounts of data into and out of the calculator:
30127 Use the mouse-oriented cut and paste facilities of X.
30129 The default bindings for a three-button mouse cause the left button
30130 to move the Emacs cursor to the given place, the right button to
30131 select the text between the cursor and the clicked location, and
30132 the middle button to yank the selection into the buffer at the
30133 clicked location. So, if you have a Calc window and an editing
30134 window on your Emacs screen, you can use left-click/right-click
30135 to select a number, vector, or formula from one window, then
30136 middle-click to paste that value into the other window. When you
30137 paste text into the Calc window, Calc interprets it as an algebraic
30138 entry. It doesn't matter where you click in the Calc window; the
30139 new value is always pushed onto the top of the stack.
30141 The @code{xterm} program that is typically used for general-purpose
30142 shell windows in X interprets the mouse buttons in the same way.
30143 So you can use the mouse to move data between Calc and any other
30144 Unix program. One nice feature of @code{xterm} is that a double
30145 left-click selects one word, and a triple left-click selects a
30146 whole line. So you can usually transfer a single number into Calc
30147 just by double-clicking on it in the shell, then middle-clicking
30148 in the Calc window.
30150 @node Keypad Mode, Embedded Mode, Kill and Yank, Top
30151 @chapter Keypad Mode
30155 @pindex calc-keypad
30156 The @kbd{C-x * k} (@code{calc-keypad}) command starts the Calculator
30157 and displays a picture of a calculator-style keypad. If you are using
30158 the X window system, you can click on any of the ``keys'' in the
30159 keypad using the left mouse button to operate the calculator.
30160 The original window remains the selected window; in Keypad mode
30161 you can type in your file while simultaneously performing
30162 calculations with the mouse.
30164 @pindex full-calc-keypad
30165 If you have used @kbd{C-x * b} first, @kbd{C-x * k} instead invokes
30166 the @code{full-calc-keypad} command, which takes over the whole
30167 Emacs screen and displays the keypad, the Calc stack, and the Calc
30168 trail all at once. This mode would normally be used when running
30169 Calc standalone (@pxref{Standalone Operation}).
30171 If you aren't using the X window system, you must switch into
30172 the @file{*Calc Keypad*} window, place the cursor on the desired
30173 ``key,'' and type @key{SPC} or @key{RET}. If you think this
30174 is easier than using Calc normally, go right ahead.
30176 Calc commands are more or less the same in Keypad mode. Certain
30177 keypad keys differ slightly from the corresponding normal Calc
30178 keystrokes; all such deviations are described below.
30180 Keypad mode includes many more commands than will fit on the keypad
30181 at once. Click the right mouse button [@code{calc-keypad-menu}]
30182 to switch to the next menu. The bottom five rows of the keypad
30183 stay the same; the top three rows change to a new set of commands.
30184 To return to earlier menus, click the middle mouse button
30185 [@code{calc-keypad-menu-back}] or simply advance through the menus
30186 until you wrap around. Typing @key{TAB} inside the keypad window
30187 is equivalent to clicking the right mouse button there.
30189 You can always click the @key{EXEC} button and type any normal
30190 Calc key sequence. This is equivalent to switching into the
30191 Calc buffer, typing the keys, then switching back to your
30195 * Keypad Main Menu::
30196 * Keypad Functions Menu::
30197 * Keypad Binary Menu::
30198 * Keypad Vectors Menu::
30199 * Keypad Modes Menu::
30202 @node Keypad Main Menu, Keypad Functions Menu, Keypad Mode, Keypad Mode
30207 |----+----+--Calc---+----+----1
30208 |FLR |CEIL|RND |TRNC|CLN2|FLT |
30209 |----+----+----+----+----+----|
30210 | LN |EXP | |ABS |IDIV|MOD |
30211 |----+----+----+----+----+----|
30212 |SIN |COS |TAN |SQRT|y^x |1/x |
30213 |----+----+----+----+----+----|
30214 | ENTER |+/- |EEX |UNDO| <- |
30215 |-----+---+-+--+--+-+---++----|
30216 | INV | 7 | 8 | 9 | / |
30217 |-----+-----+-----+-----+-----|
30218 | HYP | 4 | 5 | 6 | * |
30219 |-----+-----+-----+-----+-----|
30220 |EXEC | 1 | 2 | 3 | - |
30221 |-----+-----+-----+-----+-----|
30222 | OFF | 0 | . | PI | + |
30223 |-----+-----+-----+-----+-----+
30228 This is the menu that appears the first time you start Keypad mode.
30229 It will show up in a vertical window on the right side of your screen.
30230 Above this menu is the traditional Calc stack display. On a 24-line
30231 screen you will be able to see the top three stack entries.
30233 The ten digit keys, decimal point, and @key{EEX} key are used for
30234 entering numbers in the obvious way. @key{EEX} begins entry of an
30235 exponent in scientific notation. Just as with regular Calc, the
30236 number is pushed onto the stack as soon as you press @key{ENTER}
30237 or any other function key.
30239 The @key{+/-} key corresponds to normal Calc's @kbd{n} key. During
30240 numeric entry it changes the sign of the number or of the exponent.
30241 At other times it changes the sign of the number on the top of the
30244 The @key{INV} and @key{HYP} keys modify other keys. As well as
30245 having the effects described elsewhere in this manual, Keypad mode
30246 defines several other ``inverse'' operations. These are described
30247 below and in the following sections.
30249 The @key{ENTER} key finishes the current numeric entry, or otherwise
30250 duplicates the top entry on the stack.
30252 The @key{UNDO} key undoes the most recent Calc operation.
30253 @kbd{INV UNDO} is the ``redo'' command, and @kbd{HYP UNDO} is
30254 ``last arguments'' (@kbd{M-@key{RET}}).
30256 The @key{<-} key acts as a ``backspace'' during numeric entry.
30257 At other times it removes the top stack entry. @kbd{INV <-}
30258 clears the entire stack. @kbd{HYP <-} takes an integer from
30259 the stack, then removes that many additional stack elements.
30261 The @key{EXEC} key prompts you to enter any keystroke sequence
30262 that would normally work in Calc mode. This can include a
30263 numeric prefix if you wish. It is also possible simply to
30264 switch into the Calc window and type commands in it; there is
30265 nothing ``magic'' about this window when Keypad mode is active.
30267 The other keys in this display perform their obvious calculator
30268 functions. @key{CLN2} rounds the top-of-stack by temporarily
30269 reducing the precision by 2 digits. @key{FLT} converts an
30270 integer or fraction on the top of the stack to floating-point.
30272 The @key{INV} and @key{HYP} keys combined with several of these keys
30273 give you access to some common functions even if the appropriate menu
30274 is not displayed. Obviously you don't need to learn these keys
30275 unless you find yourself wasting time switching among the menus.
30279 is the same as @key{1/x}.
30281 is the same as @key{SQRT}.
30283 is the same as @key{CONJ}.
30285 is the same as @key{y^x}.
30287 is the same as @key{INV y^x} (the @expr{x}th root of @expr{y}).
30289 are the same as @key{SIN} / @kbd{INV SIN}.
30291 are the same as @key{COS} / @kbd{INV COS}.
30293 are the same as @key{TAN} / @kbd{INV TAN}.
30295 are the same as @key{LN} / @kbd{HYP LN}.
30297 are the same as @key{EXP} / @kbd{HYP EXP}.
30299 is the same as @key{ABS}.
30301 is the same as @key{RND} (@code{calc-round}).
30303 is the same as @key{CLN2}.
30305 is the same as @key{FLT} (@code{calc-float}).
30307 is the same as @key{IMAG}.
30309 is the same as @key{PREC}.
30311 is the same as @key{SWAP}.
30313 is the same as @key{RLL3}.
30314 @item INV HYP ENTER
30315 is the same as @key{OVER}.
30317 packs the top two stack entries as an error form.
30319 packs the top two stack entries as a modulo form.
30321 creates an interval form; this removes an integer which is one
30322 of 0 @samp{[]}, 1 @samp{[)}, 2 @samp{(]} or 3 @samp{()}, followed
30323 by the two limits of the interval.
30326 The @kbd{OFF} key turns Calc off; typing @kbd{C-x * k} or @kbd{C-x * *}
30327 again has the same effect. This is analogous to typing @kbd{q} or
30328 hitting @kbd{C-x * c} again in the normal calculator. If Calc is
30329 running standalone (the @code{full-calc-keypad} command appeared in the
30330 command line that started Emacs), then @kbd{OFF} is replaced with
30331 @kbd{EXIT}; clicking on this actually exits Emacs itself.
30333 @node Keypad Functions Menu, Keypad Binary Menu, Keypad Main Menu, Keypad Mode
30334 @section Functions Menu
30338 |----+----+----+----+----+----2
30339 |IGAM|BETA|IBET|ERF |BESJ|BESY|
30340 |----+----+----+----+----+----|
30341 |IMAG|CONJ| RE |ATN2|RAND|RAGN|
30342 |----+----+----+----+----+----|
30343 |GCD |FACT|DFCT|BNOM|PERM|NXTP|
30344 |----+----+----+----+----+----|
30349 This menu provides various operations from the @kbd{f} and @kbd{k}
30352 @key{IMAG} multiplies the number on the stack by the imaginary
30353 number @expr{i = (0, 1)}.
30355 @key{RE} extracts the real part a complex number. @kbd{INV RE}
30356 extracts the imaginary part.
30358 @key{RAND} takes a number from the top of the stack and computes
30359 a random number greater than or equal to zero but less than that
30360 number. (@xref{Random Numbers}.) @key{RAGN} is the ``random
30361 again'' command; it computes another random number using the
30362 same limit as last time.
30364 @key{INV GCD} computes the LCM (least common multiple) function.
30366 @key{INV FACT} is the gamma function.
30367 @texline @math{\Gamma(x) = (x-1)!}.
30368 @infoline @expr{gamma(x) = (x-1)!}.
30370 @key{PERM} is the number-of-permutations function, which is on the
30371 @kbd{H k c} key in normal Calc.
30373 @key{NXTP} finds the next prime after a number. @kbd{INV NXTP}
30374 finds the previous prime.
30376 @node Keypad Binary Menu, Keypad Vectors Menu, Keypad Functions Menu, Keypad Mode
30377 @section Binary Menu
30381 |----+----+----+----+----+----3
30382 |AND | OR |XOR |NOT |LSH |RSH |
30383 |----+----+----+----+----+----|
30384 |DEC |HEX |OCT |BIN |WSIZ|ARSH|
30385 |----+----+----+----+----+----|
30386 | A | B | C | D | E | F |
30387 |----+----+----+----+----+----|
30392 The keys in this menu perform operations on binary integers.
30393 Note that both logical and arithmetic right-shifts are provided.
30394 @key{INV LSH} rotates one bit to the left.
30396 The ``difference'' function (normally on @kbd{b d}) is on @key{INV AND}.
30397 The ``clip'' function (normally on @w{@kbd{b c}}) is on @key{INV NOT}.
30399 The @key{DEC}, @key{HEX}, @key{OCT}, and @key{BIN} keys select the
30400 current radix for display and entry of numbers: Decimal, hexadecimal,
30401 octal, or binary. The six letter keys @key{A} through @key{F} are used
30402 for entering hexadecimal numbers.
30404 The @key{WSIZ} key displays the current word size for binary operations
30405 and allows you to enter a new word size. You can respond to the prompt
30406 using either the keyboard or the digits and @key{ENTER} from the keypad.
30407 The initial word size is 32 bits.
30409 @node Keypad Vectors Menu, Keypad Modes Menu, Keypad Binary Menu, Keypad Mode
30410 @section Vectors Menu
30414 |----+----+----+----+----+----4
30415 |SUM |PROD|MAX |MAP*|MAP^|MAP$|
30416 |----+----+----+----+----+----|
30417 |MINV|MDET|MTRN|IDNT|CRSS|"x" |
30418 |----+----+----+----+----+----|
30419 |PACK|UNPK|INDX|BLD |LEN |... |
30420 |----+----+----+----+----+----|
30425 The keys in this menu operate on vectors and matrices.
30427 @key{PACK} removes an integer @var{n} from the top of the stack;
30428 the next @var{n} stack elements are removed and packed into a vector,
30429 which is replaced onto the stack. Thus the sequence
30430 @kbd{1 ENTER 3 ENTER 5 ENTER 3 PACK} enters the vector
30431 @samp{[1, 3, 5]} onto the stack. To enter a matrix, build each row
30432 on the stack as a vector, then use a final @key{PACK} to collect the
30433 rows into a matrix.
30435 @key{UNPK} unpacks the vector on the stack, pushing each of its
30436 components separately.
30438 @key{INDX} removes an integer @var{n}, then builds a vector of
30439 integers from 1 to @var{n}. @kbd{INV INDX} takes three numbers
30440 from the stack: The vector size @var{n}, the starting number,
30441 and the increment. @kbd{BLD} takes an integer @var{n} and any
30442 value @var{x} and builds a vector of @var{n} copies of @var{x}.
30444 @key{IDNT} removes an integer @var{n}, then builds an @var{n}-by-@var{n}
30447 @key{LEN} replaces a vector by its length, an integer.
30449 @key{...} turns on or off ``abbreviated'' display mode for large vectors.
30451 @key{MINV}, @key{MDET}, @key{MTRN}, and @key{CROSS} are the matrix
30452 inverse, determinant, and transpose, and vector cross product.
30454 @key{SUM} replaces a vector by the sum of its elements. It is
30455 equivalent to @kbd{u +} in normal Calc (@pxref{Statistical Operations}).
30456 @key{PROD} computes the product of the elements of a vector, and
30457 @key{MAX} computes the maximum of all the elements of a vector.
30459 @key{INV SUM} computes the alternating sum of the first element
30460 minus the second, plus the third, minus the fourth, and so on.
30461 @key{INV MAX} computes the minimum of the vector elements.
30463 @key{HYP SUM} computes the mean of the vector elements.
30464 @key{HYP PROD} computes the sample standard deviation.
30465 @key{HYP MAX} computes the median.
30467 @key{MAP*} multiplies two vectors elementwise. It is equivalent
30468 to the @kbd{V M *} command. @key{MAP^} computes powers elementwise.
30469 The arguments must be vectors of equal length, or one must be a vector
30470 and the other must be a plain number. For example, @kbd{2 MAP^} squares
30471 all the elements of a vector.
30473 @key{MAP$} maps the formula on the top of the stack across the
30474 vector in the second-to-top position. If the formula contains
30475 several variables, Calc takes that many vectors starting at the
30476 second-to-top position and matches them to the variables in
30477 alphabetical order. The result is a vector of the same size as
30478 the input vectors, whose elements are the formula evaluated with
30479 the variables set to the various sets of numbers in those vectors.
30480 For example, you could simulate @key{MAP^} using @key{MAP$} with
30481 the formula @samp{x^y}.
30483 The @kbd{"x"} key pushes the variable name @expr{x} onto the
30484 stack. To build the formula @expr{x^2 + 6}, you would use the
30485 key sequence @kbd{"x" 2 y^x 6 +}. This formula would then be
30486 suitable for use with the @key{MAP$} key described above.
30487 With @key{INV}, @key{HYP}, or @key{INV} and @key{HYP}, the
30488 @kbd{"x"} key pushes the variable names @expr{y}, @expr{z}, and
30489 @expr{t}, respectively.
30491 @node Keypad Modes Menu, , Keypad Vectors Menu, Keypad Mode
30492 @section Modes Menu
30496 |----+----+----+----+----+----5
30497 |FLT |FIX |SCI |ENG |GRP | |
30498 |----+----+----+----+----+----|
30499 |RAD |DEG |FRAC|POLR|SYMB|PREC|
30500 |----+----+----+----+----+----|
30501 |SWAP|RLL3|RLL4|OVER|STO |RCL |
30502 |----+----+----+----+----+----|
30507 The keys in this menu manipulate modes, variables, and the stack.
30509 The @key{FLT}, @key{FIX}, @key{SCI}, and @key{ENG} keys select
30510 floating-point, fixed-point, scientific, or engineering notation.
30511 @key{FIX} displays two digits after the decimal by default; the
30512 others display full precision. With the @key{INV} prefix, these
30513 keys pop a number-of-digits argument from the stack.
30515 The @key{GRP} key turns grouping of digits with commas on or off.
30516 @kbd{INV GRP} enables grouping to the right of the decimal point as
30517 well as to the left.
30519 The @key{RAD} and @key{DEG} keys switch between radians and degrees
30520 for trigonometric functions.
30522 The @key{FRAC} key turns Fraction mode on or off. This affects
30523 whether commands like @kbd{/} with integer arguments produce
30524 fractional or floating-point results.
30526 The @key{POLR} key turns Polar mode on or off, determining whether
30527 polar or rectangular complex numbers are used by default.
30529 The @key{SYMB} key turns Symbolic mode on or off, in which
30530 operations that would produce inexact floating-point results
30531 are left unevaluated as algebraic formulas.
30533 The @key{PREC} key selects the current precision. Answer with
30534 the keyboard or with the keypad digit and @key{ENTER} keys.
30536 The @key{SWAP} key exchanges the top two stack elements.
30537 The @key{RLL3} key rotates the top three stack elements upwards.
30538 The @key{RLL4} key rotates the top four stack elements upwards.
30539 The @key{OVER} key duplicates the second-to-top stack element.
30541 The @key{STO} and @key{RCL} keys are analogous to @kbd{s t} and
30542 @kbd{s r} in regular Calc. @xref{Store and Recall}. Click the
30543 @key{STO} or @key{RCL} key, then one of the ten digits. (Named
30544 variables are not available in Keypad mode.) You can also use,
30545 for example, @kbd{STO + 3} to add to register 3.
30547 @node Embedded Mode, Programming, Keypad Mode, Top
30548 @chapter Embedded Mode
30551 Embedded mode in Calc provides an alternative to copying numbers
30552 and formulas back and forth between editing buffers and the Calc
30553 stack. In Embedded mode, your editing buffer becomes temporarily
30554 linked to the stack and this copying is taken care of automatically.
30557 * Basic Embedded Mode::
30558 * More About Embedded Mode::
30559 * Assignments in Embedded Mode::
30560 * Mode Settings in Embedded Mode::
30561 * Customizing Embedded Mode::
30564 @node Basic Embedded Mode, More About Embedded Mode, Embedded Mode, Embedded Mode
30565 @section Basic Embedded Mode
30569 @pindex calc-embedded
30570 To enter Embedded mode, position the Emacs point (cursor) on a
30571 formula in any buffer and press @kbd{C-x * e} (@code{calc-embedded}).
30572 Note that @kbd{C-x * e} is not to be used in the Calc stack buffer
30573 like most Calc commands, but rather in regular editing buffers that
30574 are visiting your own files.
30576 Calc will try to guess an appropriate language based on the major mode
30577 of the editing buffer. (@xref{Language Modes}.) If the current buffer is
30578 in @code{latex-mode}, for example, Calc will set its language to @LaTeX{}.
30579 Similarly, Calc will use @TeX{} language for @code{tex-mode},
30580 @code{plain-tex-mode} and @code{context-mode}, C language for
30581 @code{c-mode} and @code{c++-mode}, FORTRAN language for
30582 @code{fortran-mode} and @code{f90-mode}, Pascal for @code{pascal-mode},
30583 and eqn for @code{nroff-mode} (@pxref{Customizing Calc}).
30584 These can be overridden with Calc's mode
30585 changing commands (@pxref{Mode Settings in Embedded Mode}). If no
30586 suitable language is available, Calc will continue with its current language.
30588 Calc normally scans backward and forward in the buffer for the
30589 nearest opening and closing @dfn{formula delimiters}. The simplest
30590 delimiters are blank lines. Other delimiters that Embedded mode
30595 The @TeX{} and @LaTeX{} math delimiters @samp{$ $}, @samp{$$ $$},
30596 @samp{\[ \]}, and @samp{\( \)};
30598 Lines beginning with @samp{\begin} and @samp{\end} (except matrix delimiters);
30600 Lines beginning with @samp{@@} (Texinfo delimiters).
30602 Lines beginning with @samp{.EQ} and @samp{.EN} (@dfn{eqn} delimiters);
30604 Lines containing a single @samp{%} or @samp{.\"} symbol and nothing else.
30607 @xref{Customizing Embedded Mode}, to see how to make Calc recognize
30608 your own favorite delimiters. Delimiters like @samp{$ $} can appear
30609 on their own separate lines or in-line with the formula.
30611 If you give a positive or negative numeric prefix argument, Calc
30612 instead uses the current point as one end of the formula, and includes
30613 that many lines forward or backward (respectively, including the current
30614 line). Explicit delimiters are not necessary in this case.
30616 With a prefix argument of zero, Calc uses the current region (delimited
30617 by point and mark) instead of formula delimiters. With a prefix
30618 argument of @kbd{C-u} only, Calc uses the current line as the formula.
30621 @pindex calc-embedded-word
30622 The @kbd{C-x * w} (@code{calc-embedded-word}) command will start Embedded
30623 mode on the current ``word''; in this case Calc will scan for the first
30624 non-numeric character (i.e., the first character that is not a digit,
30625 sign, decimal point, or upper- or lower-case @samp{e}) forward and
30626 backward to delimit the formula.
30628 When you enable Embedded mode for a formula, Calc reads the text
30629 between the delimiters and tries to interpret it as a Calc formula.
30630 Calc can generally identify @TeX{} formulas and
30631 Big-style formulas even if the language mode is wrong. If Calc
30632 can't make sense of the formula, it beeps and refuses to enter
30633 Embedded mode. But if the current language is wrong, Calc can
30634 sometimes parse the formula successfully (but incorrectly);
30635 for example, the C expression @samp{atan(a[1])} can be parsed
30636 in Normal language mode, but the @code{atan} won't correspond to
30637 the built-in @code{arctan} function, and the @samp{a[1]} will be
30638 interpreted as @samp{a} times the vector @samp{[1]}!
30640 If you press @kbd{C-x * e} or @kbd{C-x * w} to activate an embedded
30641 formula which is blank, say with the cursor on the space between
30642 the two delimiters @samp{$ $}, Calc will immediately prompt for
30643 an algebraic entry.
30645 Only one formula in one buffer can be enabled at a time. If you
30646 move to another area of the current buffer and give Calc commands,
30647 Calc turns Embedded mode off for the old formula and then tries
30648 to restart Embedded mode at the new position. Other buffers are
30649 not affected by Embedded mode.
30651 When Embedded mode begins, Calc pushes the current formula onto
30652 the stack. No Calc stack window is created; however, Calc copies
30653 the top-of-stack position into the original buffer at all times.
30654 You can create a Calc window by hand with @kbd{C-x * o} if you
30655 find you need to see the entire stack.
30657 For example, typing @kbd{C-x * e} while somewhere in the formula
30658 @samp{n>2} in the following line enables Embedded mode on that
30662 We define $F_n = F_(n-1)+F_(n-2)$ for all $n>2$.
30666 The formula @expr{n>2} will be pushed onto the Calc stack, and
30667 the top of stack will be copied back into the editing buffer.
30668 This means that spaces will appear around the @samp{>} symbol
30669 to match Calc's usual display style:
30672 We define $F_n = F_(n-1)+F_(n-2)$ for all $n > 2$.
30676 No spaces have appeared around the @samp{+} sign because it's
30677 in a different formula, one which we have not yet touched with
30680 Now that Embedded mode is enabled, keys you type in this buffer
30681 are interpreted as Calc commands. At this point we might use
30682 the ``commute'' command @kbd{j C} to reverse the inequality.
30683 This is a selection-based command for which we first need to
30684 move the cursor onto the operator (@samp{>} in this case) that
30685 needs to be commuted.
30688 We define $F_n = F_(n-1)+F_(n-2)$ for all $2 < n$.
30691 The @kbd{C-x * o} command is a useful way to open a Calc window
30692 without actually selecting that window. Giving this command
30693 verifies that @samp{2 < n} is also on the Calc stack. Typing
30694 @kbd{17 @key{RET}} would produce:
30697 We define $F_n = F_(n-1)+F_(n-2)$ for all $17$.
30701 with @samp{2 < n} and @samp{17} on the stack; typing @key{TAB}
30702 at this point will exchange the two stack values and restore
30703 @samp{2 < n} to the embedded formula. Even though you can't
30704 normally see the stack in Embedded mode, it is still there and
30705 it still operates in the same way. But, as with old-fashioned
30706 RPN calculators, you can only see the value at the top of the
30707 stack at any given time (unless you use @kbd{C-x * o}).
30709 Typing @kbd{C-x * e} again turns Embedded mode off. The Calc
30710 window reveals that the formula @w{@samp{2 < n}} is automatically
30711 removed from the stack, but the @samp{17} is not. Entering
30712 Embedded mode always pushes one thing onto the stack, and
30713 leaving Embedded mode always removes one thing. Anything else
30714 that happens on the stack is entirely your business as far as
30715 Embedded mode is concerned.
30717 If you press @kbd{C-x * e} in the wrong place by accident, it is
30718 possible that Calc will be able to parse the nearby text as a
30719 formula and will mangle that text in an attempt to redisplay it
30720 ``properly'' in the current language mode. If this happens,
30721 press @kbd{C-x * e} again to exit Embedded mode, then give the
30722 regular Emacs ``undo'' command (@kbd{C-_} or @kbd{C-x u}) to put
30723 the text back the way it was before Calc edited it. Note that Calc's
30724 own Undo command (typed before you turn Embedded mode back off)
30725 will not do you any good, because as far as Calc is concerned
30726 you haven't done anything with this formula yet.
30728 @node More About Embedded Mode, Assignments in Embedded Mode, Basic Embedded Mode, Embedded Mode
30729 @section More About Embedded Mode
30732 When Embedded mode ``activates'' a formula, i.e., when it examines
30733 the formula for the first time since the buffer was created or
30734 loaded, Calc tries to sense the language in which the formula was
30735 written. If the formula contains any @LaTeX{}-like @samp{\} sequences,
30736 it is parsed (i.e., read) in @LaTeX{} mode. If the formula appears to
30737 be written in multi-line Big mode, it is parsed in Big mode. Otherwise,
30738 it is parsed according to the current language mode.
30740 Note that Calc does not change the current language mode according
30741 the formula it reads in. Even though it can read a @LaTeX{} formula when
30742 not in @LaTeX{} mode, it will immediately rewrite this formula using
30743 whatever language mode is in effect.
30750 @pindex calc-show-plain
30751 Calc's parser is unable to read certain kinds of formulas. For
30752 example, with @kbd{v ]} (@code{calc-matrix-brackets}) you can
30753 specify matrix display styles which the parser is unable to
30754 recognize as matrices. The @kbd{d p} (@code{calc-show-plain})
30755 command turns on a mode in which a ``plain'' version of a
30756 formula is placed in front of the fully-formatted version.
30757 When Calc reads a formula that has such a plain version in
30758 front, it reads the plain version and ignores the formatted
30761 Plain formulas are preceded and followed by @samp{%%%} signs
30762 by default. This notation has the advantage that the @samp{%}
30763 character begins a comment in @TeX{} and @LaTeX{}, so if your formula is
30764 embedded in a @TeX{} or @LaTeX{} document its plain version will be
30765 invisible in the final printed copy. Certain major modes have different
30766 delimiters to ensure that the ``plain'' version will be
30767 in a comment for those modes, also.
30768 See @ref{Customizing Embedded Mode} to see how to change the ``plain''
30769 formula delimiters.
30771 There are several notations which Calc's parser for ``big''
30772 formatted formulas can't yet recognize. In particular, it can't
30773 read the large symbols for @code{sum}, @code{prod}, and @code{integ},
30774 and it can't handle @samp{=>} with the righthand argument omitted.
30775 Also, Calc won't recognize special formats you have defined with
30776 the @kbd{Z C} command (@pxref{User-Defined Compositions}). In
30777 these cases it is important to use ``plain'' mode to make sure
30778 Calc will be able to read your formula later.
30780 Another example where ``plain'' mode is important is if you have
30781 specified a float mode with few digits of precision. Normally
30782 any digits that are computed but not displayed will simply be
30783 lost when you save and re-load your embedded buffer, but ``plain''
30784 mode allows you to make sure that the complete number is present
30785 in the file as well as the rounded-down number.
30791 Embedded buffers remember active formulas for as long as they
30792 exist in Emacs memory. Suppose you have an embedded formula
30793 which is @cpi{} to the normal 12 decimal places, and then
30794 type @w{@kbd{C-u 5 d n}} to display only five decimal places.
30795 If you then type @kbd{d n}, all 12 places reappear because the
30796 full number is still there on the Calc stack. More surprisingly,
30797 even if you exit Embedded mode and later re-enter it for that
30798 formula, typing @kbd{d n} will restore all 12 places because
30799 each buffer remembers all its active formulas. However, if you
30800 save the buffer in a file and reload it in a new Emacs session,
30801 all non-displayed digits will have been lost unless you used
30808 In some applications of Embedded mode, you will want to have a
30809 sequence of copies of a formula that show its evolution as you
30810 work on it. For example, you might want to have a sequence
30811 like this in your file (elaborating here on the example from
30812 the ``Getting Started'' chapter):
30821 @r{(the derivative of }ln(ln(x))@r{)}
30823 whose value at x = 2 is
30833 @pindex calc-embedded-duplicate
30834 The @kbd{C-x * d} (@code{calc-embedded-duplicate}) command is a
30835 handy way to make sequences like this. If you type @kbd{C-x * d},
30836 the formula under the cursor (which may or may not have Embedded
30837 mode enabled for it at the time) is copied immediately below and
30838 Embedded mode is then enabled for that copy.
30840 For this example, you would start with just
30849 and press @kbd{C-x * d} with the cursor on this formula. The result
30862 with the second copy of the formula enabled in Embedded mode.
30863 You can now press @kbd{a d x @key{RET}} to take the derivative, and
30864 @kbd{C-x * d C-x * d} to make two more copies of the derivative.
30865 To complete the computations, type @kbd{3 s l x @key{RET}} to evaluate
30866 the last formula, then move up to the second-to-last formula
30867 and type @kbd{2 s l x @key{RET}}.
30869 Finally, you would want to press @kbd{C-x * e} to exit Embedded
30870 mode, then go up and insert the necessary text in between the
30871 various formulas and numbers.
30879 @pindex calc-embedded-new-formula
30880 The @kbd{C-x * f} (@code{calc-embedded-new-formula}) command
30881 creates a new embedded formula at the current point. It inserts
30882 some default delimiters, which are usually just blank lines,
30883 and then does an algebraic entry to get the formula (which is
30884 then enabled for Embedded mode). This is just shorthand for
30885 typing the delimiters yourself, positioning the cursor between
30886 the new delimiters, and pressing @kbd{C-x * e}. The key sequence
30887 @kbd{C-x * '} is equivalent to @kbd{C-x * f}.
30891 @pindex calc-embedded-next
30892 @pindex calc-embedded-previous
30893 The @kbd{C-x * n} (@code{calc-embedded-next}) and @kbd{C-x * p}
30894 (@code{calc-embedded-previous}) commands move the cursor to the
30895 next or previous active embedded formula in the buffer. They
30896 can take positive or negative prefix arguments to move by several
30897 formulas. Note that these commands do not actually examine the
30898 text of the buffer looking for formulas; they only see formulas
30899 which have previously been activated in Embedded mode. In fact,
30900 @kbd{C-x * n} and @kbd{C-x * p} are a useful way to tell which
30901 embedded formulas are currently active. Also, note that these
30902 commands do not enable Embedded mode on the next or previous
30903 formula, they just move the cursor.
30906 @pindex calc-embedded-edit
30907 The @kbd{C-x * `} (@code{calc-embedded-edit}) command edits the
30908 embedded formula at the current point as if by @kbd{`} (@code{calc-edit}).
30909 Embedded mode does not have to be enabled for this to work. Press
30910 @kbd{C-c C-c} to finish the edit, or @kbd{C-x k} to cancel.
30912 @node Assignments in Embedded Mode, Mode Settings in Embedded Mode, More About Embedded Mode, Embedded Mode
30913 @section Assignments in Embedded Mode
30916 The @samp{:=} (assignment) and @samp{=>} (``evaluates-to'') operators
30917 are especially useful in Embedded mode. They allow you to make
30918 a definition in one formula, then refer to that definition in
30919 other formulas embedded in the same buffer.
30921 An embedded formula which is an assignment to a variable, as in
30928 records @expr{5} as the stored value of @code{foo} for the
30929 purposes of Embedded mode operations in the current buffer. It
30930 does @emph{not} actually store @expr{5} as the ``global'' value
30931 of @code{foo}, however. Regular Calc operations, and Embedded
30932 formulas in other buffers, will not see this assignment.
30934 One way to use this assigned value is simply to create an
30935 Embedded formula elsewhere that refers to @code{foo}, and to press
30936 @kbd{=} in that formula. However, this permanently replaces the
30937 @code{foo} in the formula with its current value. More interesting
30938 is to use @samp{=>} elsewhere:
30944 @xref{Evaluates-To Operator}, for a general discussion of @samp{=>}.
30946 If you move back and change the assignment to @code{foo}, any
30947 @samp{=>} formulas which refer to it are automatically updated.
30955 The obvious question then is, @emph{how} can one easily change the
30956 assignment to @code{foo}? If you simply select the formula in
30957 Embedded mode and type 17, the assignment itself will be replaced
30958 by the 17. The effect on the other formula will be that the
30959 variable @code{foo} becomes unassigned:
30967 The right thing to do is first to use a selection command (@kbd{j 2}
30968 will do the trick) to select the righthand side of the assignment.
30969 Then, @kbd{17 @key{TAB} @key{DEL}} will swap the 17 into place (@pxref{Selecting
30970 Subformulas}, to see how this works).
30973 @pindex calc-embedded-select
30974 The @kbd{C-x * j} (@code{calc-embedded-select}) command provides an
30975 easy way to operate on assignments. It is just like @kbd{C-x * e},
30976 except that if the enabled formula is an assignment, it uses
30977 @kbd{j 2} to select the righthand side. If the enabled formula
30978 is an evaluates-to, it uses @kbd{j 1} to select the lefthand side.
30979 A formula can also be a combination of both:
30982 bar := foo + 3 => 20
30986 in which case @kbd{C-x * j} will select the middle part (@samp{foo + 3}).
30988 The formula is automatically deselected when you leave Embedded
30992 @pindex calc-embedded-update-formula
30993 Another way to change the assignment to @code{foo} would simply be
30994 to edit the number using regular Emacs editing rather than Embedded
30995 mode. Then, we have to find a way to get Embedded mode to notice
30996 the change. The @kbd{C-x * u} (@code{calc-embedded-update-formula})
30997 command is a convenient way to do this.
31005 Pressing @kbd{C-x * u} is much like pressing @kbd{C-x * e = C-x * e}, that
31006 is, temporarily enabling Embedded mode for the formula under the
31007 cursor and then evaluating it with @kbd{=}. But @kbd{C-x * u} does
31008 not actually use @kbd{C-x * e}, and in fact another formula somewhere
31009 else can be enabled in Embedded mode while you use @kbd{C-x * u} and
31010 that formula will not be disturbed.
31012 With a numeric prefix argument, @kbd{C-x * u} updates all active
31013 @samp{=>} formulas in the buffer. Formulas which have not yet
31014 been activated in Embedded mode, and formulas which do not have
31015 @samp{=>} as their top-level operator, are not affected by this.
31016 (This is useful only if you have used @kbd{m C}; see below.)
31018 With a plain @kbd{C-u} prefix, @kbd{C-u C-x * u} updates only in the
31019 region between mark and point rather than in the whole buffer.
31021 @kbd{C-x * u} is also a handy way to activate a formula, such as an
31022 @samp{=>} formula that has freshly been typed in or loaded from a
31026 @pindex calc-embedded-activate
31027 The @kbd{C-x * a} (@code{calc-embedded-activate}) command scans
31028 through the current buffer and activates all embedded formulas
31029 that contain @samp{:=} or @samp{=>} symbols. This does not mean
31030 that Embedded mode is actually turned on, but only that the
31031 formulas' positions are registered with Embedded mode so that
31032 the @samp{=>} values can be properly updated as assignments are
31035 It is a good idea to type @kbd{C-x * a} right after loading a file
31036 that uses embedded @samp{=>} operators. Emacs includes a nifty
31037 ``buffer-local variables'' feature that you can use to do this
31038 automatically. The idea is to place near the end of your file
31039 a few lines that look like this:
31042 --- Local Variables: ---
31043 --- eval:(calc-embedded-activate) ---
31048 where the leading and trailing @samp{---} can be replaced by
31049 any suitable strings (which must be the same on all three lines)
31050 or omitted altogether; in a @TeX{} or @LaTeX{} file, @samp{%} would be a good
31051 leading string and no trailing string would be necessary. In a
31052 C program, @samp{/*} and @samp{*/} would be good leading and
31055 When Emacs loads a file into memory, it checks for a Local Variables
31056 section like this one at the end of the file. If it finds this
31057 section, it does the specified things (in this case, running
31058 @kbd{C-x * a} automatically) before editing of the file begins.
31059 The Local Variables section must be within 3000 characters of the
31060 end of the file for Emacs to find it, and it must be in the last
31061 page of the file if the file has any page separators.
31062 @xref{File Variables, , Local Variables in Files, emacs, the
31065 Note that @kbd{C-x * a} does not update the formulas it finds.
31066 To do this, type, say, @kbd{M-1 C-x * u} after @w{@kbd{C-x * a}}.
31067 Generally this should not be a problem, though, because the
31068 formulas will have been up-to-date already when the file was
31071 Normally, @kbd{C-x * a} activates all the formulas it finds, but
31072 any previous active formulas remain active as well. With a
31073 positive numeric prefix argument, @kbd{C-x * a} first deactivates
31074 all current active formulas, then actives the ones it finds in
31075 its scan of the buffer. With a negative prefix argument,
31076 @kbd{C-x * a} simply deactivates all formulas.
31078 Embedded mode has two symbols, @samp{Active} and @samp{~Active},
31079 which it puts next to the major mode name in a buffer's mode line.
31080 It puts @samp{Active} if it has reason to believe that all
31081 formulas in the buffer are active, because you have typed @kbd{C-x * a}
31082 and Calc has not since had to deactivate any formulas (which can
31083 happen if Calc goes to update an @samp{=>} formula somewhere because
31084 a variable changed, and finds that the formula is no longer there
31085 due to some kind of editing outside of Embedded mode). Calc puts
31086 @samp{~Active} in the mode line if some, but probably not all,
31087 formulas in the buffer are active. This happens if you activate
31088 a few formulas one at a time but never use @kbd{C-x * a}, or if you
31089 used @kbd{C-x * a} but then Calc had to deactivate a formula
31090 because it lost track of it. If neither of these symbols appears
31091 in the mode line, no embedded formulas are active in the buffer
31092 (e.g., before Embedded mode has been used, or after a @kbd{M-- C-x * a}).
31094 Embedded formulas can refer to assignments both before and after them
31095 in the buffer. If there are several assignments to a variable, the
31096 nearest preceding assignment is used if there is one, otherwise the
31097 following assignment is used.
31111 As well as simple variables, you can also assign to subscript
31112 expressions of the form @samp{@var{var}_@var{number}} (as in
31113 @code{x_0}), or @samp{@var{var}_@var{var}} (as in @code{x_max}).
31114 Assignments to other kinds of objects can be represented by Calc,
31115 but the automatic linkage between assignments and references works
31116 only for plain variables and these two kinds of subscript expressions.
31118 If there are no assignments to a given variable, the global
31119 stored value for the variable is used (@pxref{Storing Variables}),
31120 or, if no value is stored, the variable is left in symbolic form.
31121 Note that global stored values will be lost when the file is saved
31122 and loaded in a later Emacs session, unless you have used the
31123 @kbd{s p} (@code{calc-permanent-variable}) command to save them;
31124 @pxref{Operations on Variables}.
31126 The @kbd{m C} (@code{calc-auto-recompute}) command turns automatic
31127 recomputation of @samp{=>} forms on and off. If you turn automatic
31128 recomputation off, you will have to use @kbd{C-x * u} to update these
31129 formulas manually after an assignment has been changed. If you
31130 plan to change several assignments at once, it may be more efficient
31131 to type @kbd{m C}, change all the assignments, then use @kbd{M-1 C-x * u}
31132 to update the entire buffer afterwards. The @kbd{m C} command also
31133 controls @samp{=>} formulas on the stack; @pxref{Evaluates-To
31134 Operator}. When you turn automatic recomputation back on, the
31135 stack will be updated but the Embedded buffer will not; you must
31136 use @kbd{C-x * u} to update the buffer by hand.
31138 @node Mode Settings in Embedded Mode, Customizing Embedded Mode, Assignments in Embedded Mode, Embedded Mode
31139 @section Mode Settings in Embedded Mode
31142 @pindex calc-embedded-preserve-modes
31144 The mode settings can be changed while Calc is in embedded mode, but
31145 by default they will revert to their original values when embedded mode
31146 is ended. However, the modes saved when the mode-recording mode is
31147 @code{Save} (see below) and the modes in effect when the @kbd{m e}
31148 (@code{calc-embedded-preserve-modes}) command is given
31149 will be preserved when embedded mode is ended.
31151 Embedded mode has a rather complicated mechanism for handling mode
31152 settings in Embedded formulas. It is possible to put annotations
31153 in the file that specify mode settings either global to the entire
31154 file or local to a particular formula or formulas. In the latter
31155 case, different modes can be specified for use when a formula
31156 is the enabled Embedded mode formula.
31158 When you give any mode-setting command, like @kbd{m f} (for Fraction
31159 mode) or @kbd{d s} (for scientific notation), Embedded mode adds
31160 a line like the following one to the file just before the opening
31161 delimiter of the formula.
31164 % [calc-mode: fractions: t]
31165 % [calc-mode: float-format: (sci 0)]
31168 When Calc interprets an embedded formula, it scans the text before
31169 the formula for mode-setting annotations like these and sets the
31170 Calc buffer to match these modes. Modes not explicitly described
31171 in the file are not changed. Calc scans all the way to the top of
31172 the file, or up to a line of the form
31179 which you can insert at strategic places in the file if this backward
31180 scan is getting too slow, or just to provide a barrier between one
31181 ``zone'' of mode settings and another.
31183 If the file contains several annotations for the same mode, the
31184 closest one before the formula is used. Annotations after the
31185 formula are never used (except for global annotations, described
31188 The scan does not look for the leading @samp{% }, only for the
31189 square brackets and the text they enclose. In fact, the leading
31190 characters are different for different major modes. You can edit the
31191 mode annotations to a style that works better in context if you wish.
31192 @xref{Customizing Embedded Mode}, to see how to change the style
31193 that Calc uses when it generates the annotations. You can write
31194 mode annotations into the file yourself if you know the syntax;
31195 the easiest way to find the syntax for a given mode is to let
31196 Calc write the annotation for it once and see what it does.
31198 If you give a mode-changing command for a mode that already has
31199 a suitable annotation just above the current formula, Calc will
31200 modify that annotation rather than generating a new, conflicting
31203 Mode annotations have three parts, separated by colons. (Spaces
31204 after the colons are optional.) The first identifies the kind
31205 of mode setting, the second is a name for the mode itself, and
31206 the third is the value in the form of a Lisp symbol, number,
31207 or list. Annotations with unrecognizable text in the first or
31208 second parts are ignored. The third part is not checked to make
31209 sure the value is of a valid type or range; if you write an
31210 annotation by hand, be sure to give a proper value or results
31211 will be unpredictable. Mode-setting annotations are case-sensitive.
31213 While Embedded mode is enabled, the word @code{Local} appears in
31214 the mode line. This is to show that mode setting commands generate
31215 annotations that are ``local'' to the current formula or set of
31216 formulas. The @kbd{m R} (@code{calc-mode-record-mode}) command
31217 causes Calc to generate different kinds of annotations. Pressing
31218 @kbd{m R} repeatedly cycles through the possible modes.
31220 @code{LocEdit} and @code{LocPerm} modes generate annotations
31221 that look like this, respectively:
31224 % [calc-edit-mode: float-format: (sci 0)]
31225 % [calc-perm-mode: float-format: (sci 5)]
31228 The first kind of annotation will be used only while a formula
31229 is enabled in Embedded mode. The second kind will be used only
31230 when the formula is @emph{not} enabled. (Whether the formula
31231 is ``active'' or not, i.e., whether Calc has seen this formula
31232 yet, is not relevant here.)
31234 @code{Global} mode generates an annotation like this at the end
31238 % [calc-global-mode: fractions t]
31241 Global mode annotations affect all formulas throughout the file,
31242 and may appear anywhere in the file. This allows you to tuck your
31243 mode annotations somewhere out of the way, say, on a new page of
31244 the file, as long as those mode settings are suitable for all
31245 formulas in the file.
31247 Enabling a formula with @kbd{C-x * e} causes a fresh scan for local
31248 mode annotations; you will have to use this after adding annotations
31249 above a formula by hand to get the formula to notice them. Updating
31250 a formula with @kbd{C-x * u} will also re-scan the local modes, but
31251 global modes are only re-scanned by @kbd{C-x * a}.
31253 Another way that modes can get out of date is if you add a local
31254 mode annotation to a formula that has another formula after it.
31255 In this example, we have used the @kbd{d s} command while the
31256 first of the two embedded formulas is active. But the second
31257 formula has not changed its style to match, even though by the
31258 rules of reading annotations the @samp{(sci 0)} applies to it, too.
31261 % [calc-mode: float-format: (sci 0)]
31267 We would have to go down to the other formula and press @kbd{C-x * u}
31268 on it in order to get it to notice the new annotation.
31270 Two more mode-recording modes selectable by @kbd{m R} are available
31271 which are also available outside of Embedded mode.
31272 (@pxref{General Mode Commands}.) They are @code{Save}, in which mode
31273 settings are recorded permanently in your Calc init file (the file given
31274 by the variable @code{calc-settings-file}, typically @file{~/.emacs.d/calc.el})
31275 rather than by annotating the current document, and no-recording
31276 mode (where there is no symbol like @code{Save} or @code{Local} in
31277 the mode line), in which mode-changing commands do not leave any
31278 annotations at all.
31280 When Embedded mode is not enabled, mode-recording modes except
31281 for @code{Save} have no effect.
31283 @node Customizing Embedded Mode, , Mode Settings in Embedded Mode, Embedded Mode
31284 @section Customizing Embedded Mode
31287 You can modify Embedded mode's behavior by setting various Lisp
31288 variables described here. These variables are customizable
31289 (@pxref{Customizing Calc}), or you can use @kbd{M-x set-variable}
31290 or @kbd{M-x edit-options} to adjust a variable on the fly.
31291 (Another possibility would be to use a file-local variable annotation at
31292 the end of the file;
31293 @pxref{File Variables, , Local Variables in Files, emacs, the Emacs manual}.)
31294 Many of the variables given mentioned here can be set to depend on the
31295 major mode of the editing buffer (@pxref{Customizing Calc}).
31297 @vindex calc-embedded-open-formula
31298 The @code{calc-embedded-open-formula} variable holds a regular
31299 expression for the opening delimiter of a formula. @xref{Regexp Search,
31300 , Regular Expression Search, emacs, the Emacs manual}, to see
31301 how regular expressions work. Basically, a regular expression is a
31302 pattern that Calc can search for. A regular expression that considers
31303 blank lines, @samp{$}, and @samp{$$} to be opening delimiters is
31304 @code{"\\`\\|^\n\\|\\$\\$?"}. Just in case the meaning of this
31305 regular expression is not completely plain, let's go through it
31308 The surrounding @samp{" "} marks quote the text between them as a
31309 Lisp string. If you left them off, @code{set-variable} or
31310 @code{edit-options} would try to read the regular expression as a
31313 The most obvious property of this regular expression is that it
31314 contains indecently many backslashes. There are actually two levels
31315 of backslash usage going on here. First, when Lisp reads a quoted
31316 string, all pairs of characters beginning with a backslash are
31317 interpreted as special characters. Here, @code{\n} changes to a
31318 new-line character, and @code{\\} changes to a single backslash.
31319 So the actual regular expression seen by Calc is
31320 @samp{\`\|^ @r{(newline)} \|\$\$?}.
31322 Regular expressions also consider pairs beginning with backslash
31323 to have special meanings. Sometimes the backslash is used to quote
31324 a character that otherwise would have a special meaning in a regular
31325 expression, like @samp{$}, which normally means ``end-of-line,''
31326 or @samp{?}, which means that the preceding item is optional. So
31327 @samp{\$\$?} matches either one or two dollar signs.
31329 The other codes in this regular expression are @samp{^}, which matches
31330 ``beginning-of-line,'' @samp{\|}, which means ``or,'' and @samp{\`},
31331 which matches ``beginning-of-buffer.'' So the whole pattern means
31332 that a formula begins at the beginning of the buffer, or on a newline
31333 that occurs at the beginning of a line (i.e., a blank line), or at
31334 one or two dollar signs.
31336 The default value of @code{calc-embedded-open-formula} looks just
31337 like this example, with several more alternatives added on to
31338 recognize various other common kinds of delimiters.
31340 By the way, the reason to use @samp{^\n} rather than @samp{^$}
31341 or @samp{\n\n}, which also would appear to match blank lines,
31342 is that the former expression actually ``consumes'' only one
31343 newline character as @emph{part of} the delimiter, whereas the
31344 latter expressions consume zero or two newlines, respectively.
31345 The former choice gives the most natural behavior when Calc
31346 must operate on a whole formula including its delimiters.
31348 See the Emacs manual for complete details on regular expressions.
31349 But just for your convenience, here is a list of all characters
31350 which must be quoted with backslash (like @samp{\$}) to avoid
31351 some special interpretation: @samp{. * + ? [ ] ^ $ \}. (Note
31352 the backslash in this list; for example, to match @samp{\[} you
31353 must use @code{"\\\\\\["}. An exercise for the reader is to
31354 account for each of these six backslashes!)
31356 @vindex calc-embedded-close-formula
31357 The @code{calc-embedded-close-formula} variable holds a regular
31358 expression for the closing delimiter of a formula. A closing
31359 regular expression to match the above example would be
31360 @code{"\\'\\|\n$\\|\\$\\$?"}. This is almost the same as the
31361 other one, except it now uses @samp{\'} (``end-of-buffer'') and
31362 @samp{\n$} (newline occurring at end of line, yet another way
31363 of describing a blank line that is more appropriate for this
31366 @vindex calc-embedded-word-regexp
31367 The @code{calc-embedded-word-regexp} variable holds a regular expression
31368 used to define an expression to look for (a ``word'') when you type
31369 @kbd{C-x * w} to enable Embedded mode.
31371 @vindex calc-embedded-open-plain
31372 The @code{calc-embedded-open-plain} variable is a string which
31373 begins a ``plain'' formula written in front of the formatted
31374 formula when @kbd{d p} mode is turned on. Note that this is an
31375 actual string, not a regular expression, because Calc must be able
31376 to write this string into a buffer as well as to recognize it.
31377 The default string is @code{"%%% "} (note the trailing space), but may
31378 be different for certain major modes.
31380 @vindex calc-embedded-close-plain
31381 The @code{calc-embedded-close-plain} variable is a string which
31382 ends a ``plain'' formula. The default is @code{" %%%\n"}, but may be
31383 different for different major modes. Without
31384 the trailing newline here, the first line of a Big mode formula
31385 that followed might be shifted over with respect to the other lines.
31387 @vindex calc-embedded-open-new-formula
31388 The @code{calc-embedded-open-new-formula} variable is a string
31389 which is inserted at the front of a new formula when you type
31390 @kbd{C-x * f}. Its default value is @code{"\n\n"}. If this
31391 string begins with a newline character and the @kbd{C-x * f} is
31392 typed at the beginning of a line, @kbd{C-x * f} will skip this
31393 first newline to avoid introducing unnecessary blank lines in
31396 @vindex calc-embedded-close-new-formula
31397 The @code{calc-embedded-close-new-formula} variable is the corresponding
31398 string which is inserted at the end of a new formula. Its default
31399 value is also @code{"\n\n"}. The final newline is omitted by
31400 @w{@kbd{C-x * f}} if typed at the end of a line. (It follows that if
31401 @kbd{C-x * f} is typed on a blank line, both a leading opening
31402 newline and a trailing closing newline are omitted.)
31404 @vindex calc-embedded-announce-formula
31405 The @code{calc-embedded-announce-formula} variable is a regular
31406 expression which is sure to be followed by an embedded formula.
31407 The @kbd{C-x * a} command searches for this pattern as well as for
31408 @samp{=>} and @samp{:=} operators. Note that @kbd{C-x * a} will
31409 not activate just anything surrounded by formula delimiters; after
31410 all, blank lines are considered formula delimiters by default!
31411 But if your language includes a delimiter which can only occur
31412 actually in front of a formula, you can take advantage of it here.
31413 The default pattern is @code{"%Embed\n\\(% .*\n\\)*"}, but may be
31414 different for different major modes.
31415 This pattern will check for @samp{%Embed} followed by any number of
31416 lines beginning with @samp{%} and a space. This last is important to
31417 make Calc consider mode annotations part of the pattern, so that the
31418 formula's opening delimiter really is sure to follow the pattern.
31420 @vindex calc-embedded-open-mode
31421 The @code{calc-embedded-open-mode} variable is a string (not a
31422 regular expression) which should precede a mode annotation.
31423 Calc never scans for this string; Calc always looks for the
31424 annotation itself. But this is the string that is inserted before
31425 the opening bracket when Calc adds an annotation on its own.
31426 The default is @code{"% "}, but may be different for different major
31429 @vindex calc-embedded-close-mode
31430 The @code{calc-embedded-close-mode} variable is a string which
31431 follows a mode annotation written by Calc. Its default value
31432 is simply a newline, @code{"\n"}, but may be different for different
31433 major modes. If you change this, it is a good idea still to end with a
31434 newline so that mode annotations will appear on lines by themselves.
31436 @node Programming, Copying, Embedded Mode, Top
31437 @chapter Programming
31440 There are several ways to ``program'' the Emacs Calculator, depending
31441 on the nature of the problem you need to solve.
31445 @dfn{Keyboard macros} allow you to record a sequence of keystrokes
31446 and play them back at a later time. This is just the standard Emacs
31447 keyboard macro mechanism, dressed up with a few more features such
31448 as loops and conditionals.
31451 @dfn{Algebraic definitions} allow you to use any formula to define a
31452 new function. This function can then be used in algebraic formulas or
31453 as an interactive command.
31456 @dfn{Rewrite rules} are discussed in the section on algebra commands.
31457 @xref{Rewrite Rules}. If you put your rewrite rules in the variable
31458 @code{EvalRules}, they will be applied automatically to all Calc
31459 results in just the same way as an internal ``rule'' is applied to
31460 evaluate @samp{sqrt(9)} to 3 and so on. @xref{Automatic Rewrites}.
31463 @dfn{Lisp} is the programming language that Calc (and most of Emacs)
31464 is written in. If the above techniques aren't powerful enough, you
31465 can write Lisp functions to do anything that built-in Calc commands
31466 can do. Lisp code is also somewhat faster than keyboard macros or
31471 Programming features are available through the @kbd{z} and @kbd{Z}
31472 prefix keys. New commands that you define are two-key sequences
31473 beginning with @kbd{z}. Commands for managing these definitions
31474 use the shift-@kbd{Z} prefix. (The @kbd{Z T} (@code{calc-timing})
31475 command is described elsewhere; @pxref{Troubleshooting Commands}.
31476 The @kbd{Z C} (@code{calc-user-define-composition}) command is also
31477 described elsewhere; @pxref{User-Defined Compositions}.)
31480 * Creating User Keys::
31481 * Keyboard Macros::
31482 * Invocation Macros::
31483 * Algebraic Definitions::
31484 * Lisp Definitions::
31487 @node Creating User Keys, Keyboard Macros, Programming, Programming
31488 @section Creating User Keys
31492 @pindex calc-user-define
31493 Any Calculator command may be bound to a key using the @kbd{Z D}
31494 (@code{calc-user-define}) command. Actually, it is bound to a two-key
31495 sequence beginning with the lower-case @kbd{z} prefix.
31497 The @kbd{Z D} command first prompts for the key to define. For example,
31498 press @kbd{Z D a} to define the new key sequence @kbd{z a}. You are then
31499 prompted for the name of the Calculator command that this key should
31500 run. For example, the @code{calc-sincos} command is not normally
31501 available on a key. Typing @kbd{Z D s sincos @key{RET}} programs the
31502 @kbd{z s} key sequence to run @code{calc-sincos}. This definition will remain
31503 in effect for the rest of this Emacs session, or until you redefine
31504 @kbd{z s} to be something else.
31506 You can actually bind any Emacs command to a @kbd{z} key sequence by
31507 backspacing over the @samp{calc-} when you are prompted for the command name.
31509 As with any other prefix key, you can type @kbd{z ?} to see a list of
31510 all the two-key sequences you have defined that start with @kbd{z}.
31511 Initially, no @kbd{z} sequences (except @kbd{z ?} itself) are defined.
31513 User keys are typically letters, but may in fact be any key.
31514 (@key{META}-keys are not permitted, nor are a terminal's special
31515 function keys which generate multi-character sequences when pressed.)
31516 You can define different commands on the shifted and unshifted versions
31517 of a letter if you wish.
31520 @pindex calc-user-undefine
31521 The @kbd{Z U} (@code{calc-user-undefine}) command unbinds a user key.
31522 For example, the key sequence @kbd{Z U s} will undefine the @code{sincos}
31523 key we defined above.
31526 @pindex calc-user-define-permanent
31527 @cindex Storing user definitions
31528 @cindex Permanent user definitions
31529 @cindex Calc init file, user-defined commands
31530 The @kbd{Z P} (@code{calc-user-define-permanent}) command makes a key
31531 binding permanent so that it will remain in effect even in future Emacs
31532 sessions. (It does this by adding a suitable bit of Lisp code into
31533 your Calc init file; that is, the file given by the variable
31534 @code{calc-settings-file}, typically @file{~/.emacs.d/calc.el}.) For example,
31535 @kbd{Z P s} would register our @code{sincos} command permanently. If
31536 you later wish to unregister this command you must edit your Calc init
31537 file by hand. (@xref{General Mode Commands}, for a way to tell Calc to
31538 use a different file for the Calc init file.)
31540 The @kbd{Z P} command also saves the user definition, if any, for the
31541 command bound to the key. After @kbd{Z F} and @kbd{Z C}, a given user
31542 key could invoke a command, which in turn calls an algebraic function,
31543 which might have one or more special display formats. A single @kbd{Z P}
31544 command will save all of these definitions.
31545 To save an algebraic function, type @kbd{'} (the apostrophe)
31546 when prompted for a key, and type the function name. To save a command
31547 without its key binding, type @kbd{M-x} and enter a function name. (The
31548 @samp{calc-} prefix will automatically be inserted for you.)
31549 (If the command you give implies a function, the function will be saved,
31550 and if the function has any display formats, those will be saved, but
31551 not the other way around: Saving a function will not save any commands
31552 or key bindings associated with the function.)
31555 @pindex calc-user-define-edit
31556 @cindex Editing user definitions
31557 The @kbd{Z E} (@code{calc-user-define-edit}) command edits the definition
31558 of a user key. This works for keys that have been defined by either
31559 keyboard macros or formulas; further details are contained in the relevant
31560 following sections.
31562 @node Keyboard Macros, Invocation Macros, Creating User Keys, Programming
31563 @section Programming with Keyboard Macros
31567 @cindex Programming with keyboard macros
31568 @cindex Keyboard macros
31569 The easiest way to ``program'' the Emacs Calculator is to use standard
31570 keyboard macros. Press @w{@kbd{C-x (}} to begin recording a macro. From
31571 this point on, keystrokes you type will be saved away as well as
31572 performing their usual functions. Press @kbd{C-x )} to end recording.
31573 Press shift-@kbd{X} (or the standard Emacs key sequence @kbd{C-x e}) to
31574 execute your keyboard macro by replaying the recorded keystrokes.
31575 @xref{Keyboard Macros, , , emacs, the Emacs Manual}, for further
31578 When you use @kbd{X} to invoke a keyboard macro, the entire macro is
31579 treated as a single command by the undo and trail features. The stack
31580 display buffer is not updated during macro execution, but is instead
31581 fixed up once the macro completes. Thus, commands defined with keyboard
31582 macros are convenient and efficient. The @kbd{C-x e} command, on the
31583 other hand, invokes the keyboard macro with no special treatment: Each
31584 command in the macro will record its own undo information and trail entry,
31585 and update the stack buffer accordingly. If your macro uses features
31586 outside of Calc's control to operate on the contents of the Calc stack
31587 buffer, or if it includes Undo, Redo, or last-arguments commands, you
31588 must use @kbd{C-x e} to make sure the buffer and undo list are up-to-date
31589 at all times. You could also consider using @kbd{K} (@code{calc-keep-args})
31590 instead of @kbd{M-@key{RET}} (@code{calc-last-args}).
31592 Calc extends the standard Emacs keyboard macros in several ways.
31593 Keyboard macros can be used to create user-defined commands. Keyboard
31594 macros can include conditional and iteration structures, somewhat
31595 analogous to those provided by a traditional programmable calculator.
31598 * Naming Keyboard Macros::
31599 * Conditionals in Macros::
31600 * Loops in Macros::
31601 * Local Values in Macros::
31602 * Queries in Macros::
31605 @node Naming Keyboard Macros, Conditionals in Macros, Keyboard Macros, Keyboard Macros
31606 @subsection Naming Keyboard Macros
31610 @pindex calc-user-define-kbd-macro
31611 Once you have defined a keyboard macro, you can bind it to a @kbd{z}
31612 key sequence with the @kbd{Z K} (@code{calc-user-define-kbd-macro}) command.
31613 This command prompts first for a key, then for a command name. For
31614 example, if you type @kbd{C-x ( n @key{TAB} n @key{TAB} C-x )} you will
31615 define a keyboard macro which negates the top two numbers on the stack
31616 (@key{TAB} swaps the top two stack elements). Now you can type
31617 @kbd{Z K n @key{RET}} to define this keyboard macro onto the @kbd{z n} key
31618 sequence. The default command name (if you answer the second prompt with
31619 just the @key{RET} key as in this example) will be something like
31620 @samp{calc-User-n}. The keyboard macro will now be available as both
31621 @kbd{z n} and @kbd{M-x calc-User-n}. You can backspace and enter a more
31622 descriptive command name if you wish.
31624 Macros defined by @kbd{Z K} act like single commands; they are executed
31625 in the same way as by the @kbd{X} key. If you wish to define the macro
31626 as a standard no-frills Emacs macro (to be executed as if by @kbd{C-x e}),
31627 give a negative prefix argument to @kbd{Z K}.
31629 Once you have bound your keyboard macro to a key, you can use
31630 @kbd{Z P} to register it permanently with Emacs. @xref{Creating User Keys}.
31632 @cindex Keyboard macros, editing
31633 The @kbd{Z E} (@code{calc-user-define-edit}) command on a key that has
31634 been defined by a keyboard macro tries to use the @code{edmacro} package
31635 edit the macro. Type @kbd{C-c C-c} to finish editing and update
31636 the definition stored on the key, or, to cancel the edit, kill the
31637 buffer with @kbd{C-x k}.
31638 The special characters @code{RET}, @code{LFD}, @code{TAB}, @code{SPC},
31639 @code{DEL}, and @code{NUL} must be entered as these three character
31640 sequences, written in all uppercase, as must the prefixes @code{C-} and
31641 @code{M-}. Spaces and line breaks are ignored. Other characters are
31642 copied verbatim into the keyboard macro. Basically, the notation is the
31643 same as is used in all of this manual's examples, except that the manual
31644 takes some liberties with spaces: When we say @kbd{' [1 2 3] @key{RET}},
31645 we take it for granted that it is clear we really mean
31646 @kbd{' [1 @key{SPC} 2 @key{SPC} 3] @key{RET}}.
31649 @pindex read-kbd-macro
31650 The @kbd{C-x * m} (@code{read-kbd-macro}) command reads an Emacs ``region''
31651 of spelled-out keystrokes and defines it as the current keyboard macro.
31652 It is a convenient way to define a keyboard macro that has been stored
31653 in a file, or to define a macro without executing it at the same time.
31655 @node Conditionals in Macros, Loops in Macros, Naming Keyboard Macros, Keyboard Macros
31656 @subsection Conditionals in Keyboard Macros
31661 @pindex calc-kbd-if
31662 @pindex calc-kbd-else
31663 @pindex calc-kbd-else-if
31664 @pindex calc-kbd-end-if
31665 @cindex Conditional structures
31666 The @kbd{Z [} (@code{calc-kbd-if}) and @kbd{Z ]} (@code{calc-kbd-end-if})
31667 commands allow you to put simple tests in a keyboard macro. When Calc
31668 sees the @kbd{Z [}, it pops an object from the stack and, if the object is
31669 a non-zero value, continues executing keystrokes. But if the object is
31670 zero, or if it is not provably nonzero, Calc skips ahead to the matching
31671 @kbd{Z ]} keystroke. @xref{Logical Operations}, for a set of commands for
31672 performing tests which conveniently produce 1 for true and 0 for false.
31674 For example, @kbd{@key{RET} 0 a < Z [ n Z ]} implements an absolute-value
31675 function in the form of a keyboard macro. This macro duplicates the
31676 number on the top of the stack, pushes zero and compares using @kbd{a <}
31677 (@code{calc-less-than}), then, if the number was less than zero,
31678 executes @kbd{n} (@code{calc-change-sign}). Otherwise, the change-sign
31679 command is skipped.
31681 To program this macro, type @kbd{C-x (}, type the above sequence of
31682 keystrokes, then type @kbd{C-x )}. Note that the keystrokes will be
31683 executed while you are making the definition as well as when you later
31684 re-execute the macro by typing @kbd{X}. Thus you should make sure a
31685 suitable number is on the stack before defining the macro so that you
31686 don't get a stack-underflow error during the definition process.
31688 Conditionals can be nested arbitrarily. However, there should be exactly
31689 one @kbd{Z ]} for each @kbd{Z [} in a keyboard macro.
31692 The @kbd{Z :} (@code{calc-kbd-else}) command allows you to choose between
31693 two keystroke sequences. The general format is @kbd{@var{cond} Z [
31694 @var{then-part} Z : @var{else-part} Z ]}. If @var{cond} is true
31695 (i.e., if the top of stack contains a non-zero number after @var{cond}
31696 has been executed), the @var{then-part} will be executed and the
31697 @var{else-part} will be skipped. Otherwise, the @var{then-part} will
31698 be skipped and the @var{else-part} will be executed.
31701 The @kbd{Z |} (@code{calc-kbd-else-if}) command allows you to choose
31702 between any number of alternatives. For example,
31703 @kbd{@var{cond1} Z [ @var{part1} Z : @var{cond2} Z | @var{part2} Z :
31704 @var{part3} Z ]} will execute @var{part1} if @var{cond1} is true,
31705 otherwise it will execute @var{part2} if @var{cond2} is true, otherwise
31706 it will execute @var{part3}.
31708 More precisely, @kbd{Z [} pops a number and conditionally skips to the
31709 next matching @kbd{Z :} or @kbd{Z ]} key. @w{@kbd{Z ]}} has no effect when
31710 actually executed. @kbd{Z :} skips to the next matching @kbd{Z ]}.
31711 @kbd{Z |} pops a number and conditionally skips to the next matching
31712 @kbd{Z :} or @kbd{Z ]}; thus, @kbd{Z [} and @kbd{Z |} are functionally
31713 equivalent except that @kbd{Z [} participates in nesting but @kbd{Z |}
31716 Calc's conditional and looping constructs work by scanning the
31717 keyboard macro for occurrences of character sequences like @samp{Z:}
31718 and @samp{Z]}. One side-effect of this is that if you use these
31719 constructs you must be careful that these character pairs do not
31720 occur by accident in other parts of the macros. Since Calc rarely
31721 uses shift-@kbd{Z} for any purpose except as a prefix character, this
31722 is not likely to be a problem. Another side-effect is that it will
31723 not work to define your own custom key bindings for these commands.
31724 Only the standard shift-@kbd{Z} bindings will work correctly.
31727 If Calc gets stuck while skipping characters during the definition of a
31728 macro, type @kbd{Z C-g} to cancel the definition. (Typing plain @kbd{C-g}
31729 actually adds a @kbd{C-g} keystroke to the macro.)
31731 @node Loops in Macros, Local Values in Macros, Conditionals in Macros, Keyboard Macros
31732 @subsection Loops in Keyboard Macros
31737 @pindex calc-kbd-repeat
31738 @pindex calc-kbd-end-repeat
31739 @cindex Looping structures
31740 @cindex Iterative structures
31741 The @kbd{Z <} (@code{calc-kbd-repeat}) and @kbd{Z >}
31742 (@code{calc-kbd-end-repeat}) commands pop a number from the stack,
31743 which must be an integer, then repeat the keystrokes between the brackets
31744 the specified number of times. If the integer is zero or negative, the
31745 body is skipped altogether. For example, @kbd{1 @key{TAB} Z < 2 * Z >}
31746 computes two to a nonnegative integer power. First, we push 1 on the
31747 stack and then swap the integer argument back to the top. The @kbd{Z <}
31748 pops that argument leaving the 1 back on top of the stack. Then, we
31749 repeat a multiply-by-two step however many times.
31751 Once again, the keyboard macro is executed as it is being entered.
31752 In this case it is especially important to set up reasonable initial
31753 conditions before making the definition: Suppose the integer 1000 just
31754 happened to be sitting on the stack before we typed the above definition!
31755 Another approach is to enter a harmless dummy definition for the macro,
31756 then go back and edit in the real one with a @kbd{Z E} command. Yet
31757 another approach is to type the macro as written-out keystroke names
31758 in a buffer, then use @kbd{C-x * m} (@code{read-kbd-macro}) to read the
31763 The @kbd{Z /} (@code{calc-kbd-break}) command allows you to break out
31764 of a keyboard macro loop prematurely. It pops an object from the stack;
31765 if that object is true (a non-zero number), control jumps out of the
31766 innermost enclosing @kbd{Z <} @dots{} @kbd{Z >} loop and continues
31767 after the @kbd{Z >}. If the object is false, the @kbd{Z /} has no
31768 effect. Thus @kbd{@var{cond} Z /} is similar to @samp{if (@var{cond}) break;}
31773 @pindex calc-kbd-for
31774 @pindex calc-kbd-end-for
31775 The @kbd{Z (} (@code{calc-kbd-for}) and @kbd{Z )} (@code{calc-kbd-end-for})
31776 commands are similar to @kbd{Z <} and @kbd{Z >}, except that they make the
31777 value of the counter available inside the loop. The general layout is
31778 @kbd{@var{init} @var{final} Z ( @var{body} @var{step} Z )}. The @kbd{Z (}
31779 command pops initial and final values from the stack. It then creates
31780 a temporary internal counter and initializes it with the value @var{init}.
31781 The @kbd{Z (} command then repeatedly pushes the counter value onto the
31782 stack and executes @var{body} and @var{step}, adding @var{step} to the
31783 counter each time until the loop finishes.
31785 @cindex Summations (by keyboard macros)
31786 By default, the loop finishes when the counter becomes greater than (or
31787 less than) @var{final}, assuming @var{initial} is less than (greater
31788 than) @var{final}. If @var{initial} is equal to @var{final}, the body
31789 executes exactly once. The body of the loop always executes at least
31790 once. For example, @kbd{0 1 10 Z ( 2 ^ + 1 Z )} computes the sum of the
31791 squares of the integers from 1 to 10, in steps of 1.
31793 If you give a numeric prefix argument of 1 to @kbd{Z (}, the loop is
31794 forced to use upward-counting conventions. In this case, if @var{initial}
31795 is greater than @var{final} the body will not be executed at all.
31796 Note that @var{step} may still be negative in this loop; the prefix
31797 argument merely constrains the loop-finished test. Likewise, a prefix
31798 argument of @mathit{-1} forces downward-counting conventions.
31802 @pindex calc-kbd-loop
31803 @pindex calc-kbd-end-loop
31804 The @kbd{Z @{} (@code{calc-kbd-loop}) and @kbd{Z @}}
31805 (@code{calc-kbd-end-loop}) commands are similar to @kbd{Z <} and
31806 @kbd{Z >}, except that they do not pop a count from the stack---they
31807 effectively create an infinite loop. Every @kbd{Z @{} @dots{} @kbd{Z @}}
31808 loop ought to include at least one @kbd{Z /} to make sure the loop
31809 doesn't run forever. (If any error message occurs which causes Emacs
31810 to beep, the keyboard macro will also be halted; this is a standard
31811 feature of Emacs. You can also generally press @kbd{C-g} to halt a
31812 running keyboard macro, although not all versions of Unix support
31815 The conditional and looping constructs are not actually tied to
31816 keyboard macros, but they are most often used in that context.
31817 For example, the keystrokes @kbd{10 Z < 23 @key{RET} Z >} push
31818 ten copies of 23 onto the stack. This can be typed ``live'' just
31819 as easily as in a macro definition.
31821 @xref{Conditionals in Macros}, for some additional notes about
31822 conditional and looping commands.
31824 @node Local Values in Macros, Queries in Macros, Loops in Macros, Keyboard Macros
31825 @subsection Local Values in Macros
31828 @cindex Local variables
31829 @cindex Restoring saved modes
31830 Keyboard macros sometimes want to operate under known conditions
31831 without affecting surrounding conditions. For example, a keyboard
31832 macro may wish to turn on Fraction mode, or set a particular
31833 precision, independent of the user's normal setting for those
31838 @pindex calc-kbd-push
31839 @pindex calc-kbd-pop
31840 Macros also sometimes need to use local variables. Assignments to
31841 local variables inside the macro should not affect any variables
31842 outside the macro. The @kbd{Z `} (@code{calc-kbd-push}) and @kbd{Z '}
31843 (@code{calc-kbd-pop}) commands give you both of these capabilities.
31845 When you type @kbd{Z `} (with a backquote or accent grave character),
31846 the values of various mode settings are saved away. The ten ``quick''
31847 variables @code{q0} through @code{q9} are also saved. When
31848 you type @w{@kbd{Z '}} (with an apostrophe), these values are restored.
31849 Pairs of @kbd{Z `} and @kbd{Z '} commands may be nested.
31851 If a keyboard macro halts due to an error in between a @kbd{Z `} and
31852 a @kbd{Z '}, the saved values will be restored correctly even though
31853 the macro never reaches the @kbd{Z '} command. Thus you can use
31854 @kbd{Z `} and @kbd{Z '} without having to worry about what happens
31855 in exceptional conditions.
31857 If you type @kbd{Z `} ``live'' (not in a keyboard macro), Calc puts
31858 you into a ``recursive edit.'' You can tell you are in a recursive
31859 edit because there will be extra square brackets in the mode line,
31860 as in @samp{[(Calculator)]}. These brackets will go away when you
31861 type the matching @kbd{Z '} command. The modes and quick variables
31862 will be saved and restored in just the same way as if actual keyboard
31863 macros were involved.
31865 The modes saved by @kbd{Z `} and @kbd{Z '} are the current precision
31866 and binary word size, the angular mode (Deg, Rad, or HMS), the
31867 simplification mode, Algebraic mode, Symbolic mode, Infinite mode,
31868 Matrix or Scalar mode, Fraction mode, and the current complex mode
31869 (Polar or Rectangular). The ten ``quick'' variables' values (or lack
31870 thereof) are also saved.
31872 Most mode-setting commands act as toggles, but with a numeric prefix
31873 they force the mode either on (positive prefix) or off (negative
31874 or zero prefix). Since you don't know what the environment might
31875 be when you invoke your macro, it's best to use prefix arguments
31876 for all mode-setting commands inside the macro.
31878 In fact, @kbd{C-u Z `} is like @kbd{Z `} except that it sets the modes
31879 listed above to their default values. As usual, the matching @kbd{Z '}
31880 will restore the modes to their settings from before the @kbd{C-u Z `}.
31881 Also, @w{@kbd{Z `}} with a negative prefix argument resets the algebraic mode
31882 to its default (off) but leaves the other modes the same as they were
31883 outside the construct.
31885 The contents of the stack and trail, values of non-quick variables, and
31886 other settings such as the language mode and the various display modes,
31887 are @emph{not} affected by @kbd{Z `} and @kbd{Z '}.
31889 @node Queries in Macros, , Local Values in Macros, Keyboard Macros
31890 @subsection Queries in Keyboard Macros
31894 @c @pindex calc-kbd-report
31895 @c The @kbd{Z =} (@code{calc-kbd-report}) command displays an informative
31896 @c message including the value on the top of the stack. You are prompted
31897 @c to enter a string. That string, along with the top-of-stack value,
31898 @c is displayed unless @kbd{m w} (@code{calc-working}) has been used
31899 @c to turn such messages off.
31903 @pindex calc-kbd-query
31904 The @kbd{Z #} (@code{calc-kbd-query}) command prompts for an algebraic
31905 entry which takes its input from the keyboard, even during macro
31906 execution. All the normal conventions of algebraic input, including the
31907 use of @kbd{$} characters, are supported. The prompt message itself is
31908 taken from the top of the stack, and so must be entered (as a string)
31909 before the @kbd{Z #} command. (Recall, as a string it can be entered by
31910 pressing the @kbd{"} key and will appear as a vector when it is put on
31911 the stack. The prompt message is only put on the stack to provide a
31912 prompt for the @kbd{Z #} command; it will not play any role in any
31913 subsequent calculations.) This command allows your keyboard macros to
31914 accept numbers or formulas as interactive input.
31917 @kbd{2 @key{RET} "Power: " @key{RET} Z # 3 @key{RET} ^} will prompt for
31918 input with ``Power: '' in the minibuffer, then return 2 to the provided
31919 power. (The response to the prompt that's given, 3 in this example,
31920 will not be part of the macro.)
31922 @xref{Keyboard Macro Query, , , emacs, the Emacs Manual}, for a description of
31923 @kbd{C-x q} (@code{kbd-macro-query}), the standard Emacs way to accept
31924 keyboard input during a keyboard macro. In particular, you can use
31925 @kbd{C-x q} to enter a recursive edit, which allows the user to perform
31926 any Calculator operations interactively before pressing @kbd{C-M-c} to
31927 return control to the keyboard macro.
31929 @node Invocation Macros, Algebraic Definitions, Keyboard Macros, Programming
31930 @section Invocation Macros
31934 @pindex calc-user-invocation
31935 @pindex calc-user-define-invocation
31936 Calc provides one special keyboard macro, called up by @kbd{C-x * z}
31937 (@code{calc-user-invocation}), that is intended to allow you to define
31938 your own special way of starting Calc. To define this ``invocation
31939 macro,'' create the macro in the usual way with @kbd{C-x (} and
31940 @kbd{C-x )}, then type @kbd{Z I} (@code{calc-user-define-invocation}).
31941 There is only one invocation macro, so you don't need to type any
31942 additional letters after @kbd{Z I}. From now on, you can type
31943 @kbd{C-x * z} at any time to execute your invocation macro.
31945 For example, suppose you find yourself often grabbing rectangles of
31946 numbers into Calc and multiplying their columns. You can do this
31947 by typing @kbd{C-x * r} to grab, and @kbd{V R : *} to multiply columns.
31948 To make this into an invocation macro, just type @kbd{C-x ( C-x * r
31949 V R : * C-x )}, then @kbd{Z I}. Then, to multiply a rectangle of data,
31950 just mark the data in its buffer in the usual way and type @kbd{C-x * z}.
31952 Invocation macros are treated like regular Emacs keyboard macros;
31953 all the special features described above for @kbd{Z K}-style macros
31954 do not apply. @kbd{C-x * z} is just like @kbd{C-x e}, except that it
31955 uses the macro that was last stored by @kbd{Z I}. (In fact, the
31956 macro does not even have to have anything to do with Calc!)
31958 The @kbd{m m} command saves the last invocation macro defined by
31959 @kbd{Z I} along with all the other Calc mode settings.
31960 @xref{General Mode Commands}.
31962 @node Algebraic Definitions, Lisp Definitions, Invocation Macros, Programming
31963 @section Programming with Formulas
31967 @pindex calc-user-define-formula
31968 @cindex Programming with algebraic formulas
31969 Another way to create a new Calculator command uses algebraic formulas.
31970 The @kbd{Z F} (@code{calc-user-define-formula}) command stores the
31971 formula at the top of the stack as the definition for a key. This
31972 command prompts for five things: The key, the command name, the function
31973 name, the argument list, and the behavior of the command when given
31974 non-numeric arguments.
31976 For example, suppose we type @kbd{' a+2b @key{RET}} to push the formula
31977 @samp{a + 2*b} onto the stack. We now type @kbd{Z F m} to define this
31978 formula on the @kbd{z m} key sequence. The next prompt is for a command
31979 name, beginning with @samp{calc-}, which should be the long (@kbd{M-x}) form
31980 for the new command. If you simply press @key{RET}, a default name like
31981 @code{calc-User-m} will be constructed. In our example, suppose we enter
31982 @kbd{spam @key{RET}} to define the new command as @code{calc-spam}.
31984 If you want to give the formula a long-style name only, you can press
31985 @key{SPC} or @key{RET} when asked which single key to use. For example
31986 @kbd{Z F @key{RET} spam @key{RET}} defines the new command as
31987 @kbd{M-x calc-spam}, with no keyboard equivalent.
31989 The third prompt is for an algebraic function name. The default is to
31990 use the same name as the command name but without the @samp{calc-}
31991 prefix. (If this is of the form @samp{User-m}, the hyphen is removed so
31992 it won't be taken for a minus sign in algebraic formulas.)
31993 This is the name you will use if you want to enter your
31994 new function in an algebraic formula. Suppose we enter @kbd{yow @key{RET}}.
31995 Then the new function can be invoked by pushing two numbers on the
31996 stack and typing @kbd{z m} or @kbd{x spam}, or by entering the algebraic
31997 formula @samp{yow(x,y)}.
31999 The fourth prompt is for the function's argument list. This is used to
32000 associate values on the stack with the variables that appear in the formula.
32001 The default is a list of all variables which appear in the formula, sorted
32002 into alphabetical order. In our case, the default would be @samp{(a b)}.
32003 This means that, when the user types @kbd{z m}, the Calculator will remove
32004 two numbers from the stack, substitute these numbers for @samp{a} and
32005 @samp{b} (respectively) in the formula, then simplify the formula and
32006 push the result on the stack. In other words, @kbd{10 @key{RET} 100 z m}
32007 would replace the 10 and 100 on the stack with the number 210, which is
32008 @expr{a + 2 b} with @expr{a=10} and @expr{b=100}. Likewise, the formula
32009 @samp{yow(10, 100)} will be evaluated by substituting @expr{a=10} and
32010 @expr{b=100} in the definition.
32012 You can rearrange the order of the names before pressing @key{RET} to
32013 control which stack positions go to which variables in the formula. If
32014 you remove a variable from the argument list, that variable will be left
32015 in symbolic form by the command. Thus using an argument list of @samp{(b)}
32016 for our function would cause @kbd{10 z m} to replace the 10 on the stack
32017 with the formula @samp{a + 20}. If we had used an argument list of
32018 @samp{(b a)}, the result with inputs 10 and 100 would have been 120.
32020 You can also put a nameless function on the stack instead of just a
32021 formula, as in @samp{<a, b : a + 2 b>}. @xref{Specifying Operators}.
32022 In this example, the command will be defined by the formula @samp{a + 2 b}
32023 using the argument list @samp{(a b)}.
32025 The final prompt is a y-or-n question concerning what to do if symbolic
32026 arguments are given to your function. If you answer @kbd{y}, then
32027 executing @kbd{z m} (using the original argument list @samp{(a b)}) with
32028 arguments @expr{10} and @expr{x} will leave the function in symbolic
32029 form, i.e., @samp{yow(10,x)}. On the other hand, if you answer @kbd{n},
32030 then the formula will always be expanded, even for non-constant
32031 arguments: @samp{10 + 2 x}. If you never plan to feed algebraic
32032 formulas to your new function, it doesn't matter how you answer this
32035 If you answered @kbd{y} to this question you can still cause a function
32036 call to be expanded by typing @kbd{a "} (@code{calc-expand-formula}).
32037 Also, Calc will expand the function if necessary when you take a
32038 derivative or integral or solve an equation involving the function.
32041 @pindex calc-get-user-defn
32042 Once you have defined a formula on a key, you can retrieve this formula
32043 with the @kbd{Z G} (@code{calc-user-define-get-defn}) command. Press a
32044 key, and this command pushes the formula that was used to define that
32045 key onto the stack. Actually, it pushes a nameless function that
32046 specifies both the argument list and the defining formula. You will get
32047 an error message if the key is undefined, or if the key was not defined
32048 by a @kbd{Z F} command.
32050 The @kbd{Z E} (@code{calc-user-define-edit}) command on a key that has
32051 been defined by a formula uses a variant of the @code{calc-edit} command
32052 to edit the defining formula. Press @kbd{C-c C-c} to finish editing and
32053 store the new formula back in the definition, or kill the buffer with
32055 cancel the edit. (The argument list and other properties of the
32056 definition are unchanged; to adjust the argument list, you can use
32057 @kbd{Z G} to grab the function onto the stack, edit with @kbd{`}, and
32058 then re-execute the @kbd{Z F} command.)
32060 As usual, the @kbd{Z P} command records your definition permanently.
32061 In this case it will permanently record all three of the relevant
32062 definitions: the key, the command, and the function.
32064 You may find it useful to turn off the default simplifications with
32065 @kbd{m O} (@code{calc-no-simplify-mode}) when entering a formula to be
32066 used as a function definition. For example, the formula @samp{deriv(a^2,v)}
32067 which might be used to define a new function @samp{dsqr(a,v)} will be
32068 ``simplified'' to 0 immediately upon entry since @code{deriv} considers
32069 @expr{a} to be constant with respect to @expr{v}. Turning off
32070 default simplifications cures this problem: The definition will be stored
32071 in symbolic form without ever activating the @code{deriv} function. Press
32072 @kbd{m D} to turn the default simplifications back on afterwards.
32074 @node Lisp Definitions, , Algebraic Definitions, Programming
32075 @section Programming with Lisp
32078 The Calculator can be programmed quite extensively in Lisp. All you
32079 do is write a normal Lisp function definition, but with @code{defmath}
32080 in place of @code{defun}. This has the same form as @code{defun}, but it
32081 automagically replaces calls to standard Lisp functions like @code{+} and
32082 @code{zerop} with calls to the corresponding functions in Calc's own library.
32083 Thus you can write natural-looking Lisp code which operates on all of the
32084 standard Calculator data types. You can then use @kbd{Z D} if you wish to
32085 bind your new command to a @kbd{z}-prefix key sequence. The @kbd{Z E} command
32086 will not edit a Lisp-based definition.
32088 Emacs Lisp is described in the GNU Emacs Lisp Reference Manual. This section
32089 assumes a familiarity with Lisp programming concepts; if you do not know
32090 Lisp, you may find keyboard macros or rewrite rules to be an easier way
32091 to program the Calculator.
32093 This section first discusses ways to write commands, functions, or
32094 small programs to be executed inside of Calc. Then it discusses how
32095 your own separate programs are able to call Calc from the outside.
32096 Finally, there is a list of internal Calc functions and data structures
32097 for the true Lisp enthusiast.
32100 * Defining Functions::
32101 * Defining Simple Commands::
32102 * Defining Stack Commands::
32103 * Argument Qualifiers::
32104 * Example Definitions::
32106 * Calling Calc from Your Programs::
32110 @node Defining Functions, Defining Simple Commands, Lisp Definitions, Lisp Definitions
32111 @subsection Defining New Functions
32115 The @code{defmath} function (actually a Lisp macro) is like @code{defun}
32116 except that code in the body of the definition can make use of the full
32117 range of Calculator data types. The prefix @samp{calcFunc-} is added
32118 to the specified name to get the actual Lisp function name. As a simple
32122 (defmath myfact (n)
32124 (* n (myfact (1- n)))
32129 This actually expands to the code,
32132 (defun calcFunc-myfact (n)
32134 (math-mul n (calcFunc-myfact (math-add n -1)))
32139 This function can be used in algebraic expressions, e.g., @samp{myfact(5)}.
32141 The @samp{myfact} function as it is defined above has the bug that an
32142 expression @samp{myfact(a+b)} will be simplified to 1 because the
32143 formula @samp{a+b} is not considered to be @code{posp}. A robust
32144 factorial function would be written along the following lines:
32147 (defmath myfact (n)
32149 (* n (myfact (1- n)))
32152 nil))) ; this could be simplified as: (and (= n 0) 1)
32155 If a function returns @code{nil}, it is left unsimplified by the Calculator
32156 (except that its arguments will be simplified). Thus, @samp{myfact(a+1+2)}
32157 will be simplified to @samp{myfact(a+3)} but no further. Beware that every
32158 time the Calculator reexamines this formula it will attempt to resimplify
32159 it, so your function ought to detect the returning-@code{nil} case as
32160 efficiently as possible.
32162 The following standard Lisp functions are treated by @code{defmath}:
32163 @code{+}, @code{-}, @code{*}, @code{/}, @code{%}, @code{^} or
32164 @code{expt}, @code{=}, @code{<}, @code{>}, @code{<=}, @code{>=},
32165 @code{/=}, @code{1+}, @code{1-}, @code{logand}, @code{logior}, @code{logxor},
32166 @code{logandc2}, @code{lognot}. Also, @code{~=} is an abbreviation for
32167 @code{math-nearly-equal}, which is useful in implementing Taylor series.
32169 For other functions @var{func}, if a function by the name
32170 @samp{calcFunc-@var{func}} exists it is used, otherwise if a function by the
32171 name @samp{math-@var{func}} exists it is used, otherwise if @var{func} itself
32172 is defined as a function it is used, otherwise @samp{calcFunc-@var{func}} is
32173 used on the assumption that this is a to-be-defined math function. Also, if
32174 the function name is quoted as in @samp{('integerp a)} the function name is
32175 always used exactly as written (but not quoted).
32177 Variable names have @samp{var-} prepended to them unless they appear in
32178 the function's argument list or in an enclosing @code{let}, @code{let*},
32179 @code{for}, or @code{foreach} form,
32180 or their names already contain a @samp{-} character. Thus a reference to
32181 @samp{foo} is the same as a reference to @samp{var-foo}.
32183 A few other Lisp extensions are available in @code{defmath} definitions:
32187 The @code{elt} function accepts any number of index variables.
32188 Note that Calc vectors are stored as Lisp lists whose first
32189 element is the symbol @code{vec}; thus, @samp{(elt v 2)} yields
32190 the second element of vector @code{v}, and @samp{(elt m i j)}
32191 yields one element of a Calc matrix.
32194 The @code{setq} function has been extended to act like the Common
32195 Lisp @code{setf} function. (The name @code{setf} is recognized as
32196 a synonym of @code{setq}.) Specifically, the first argument of
32197 @code{setq} can be an @code{nth}, @code{elt}, @code{car}, or @code{cdr} form,
32198 in which case the effect is to store into the specified
32199 element of a list. Thus, @samp{(setq (elt m i j) x)} stores @expr{x}
32200 into one element of a matrix.
32203 A @code{for} looping construct is available. For example,
32204 @samp{(for ((i 0 10)) body)} executes @code{body} once for each
32205 binding of @expr{i} from zero to 10. This is like a @code{let}
32206 form in that @expr{i} is temporarily bound to the loop count
32207 without disturbing its value outside the @code{for} construct.
32208 Nested loops, as in @samp{(for ((i 0 10) (j 0 (1- i) 2)) body)},
32209 are also available. For each value of @expr{i} from zero to 10,
32210 @expr{j} counts from 0 to @expr{i-1} in steps of two. Note that
32211 @code{for} has the same general outline as @code{let*}, except
32212 that each element of the header is a list of three or four
32213 things, not just two.
32216 The @code{foreach} construct loops over elements of a list.
32217 For example, @samp{(foreach ((x (cdr v))) body)} executes
32218 @code{body} with @expr{x} bound to each element of Calc vector
32219 @expr{v} in turn. The purpose of @code{cdr} here is to skip over
32220 the initial @code{vec} symbol in the vector.
32223 The @code{break} function breaks out of the innermost enclosing
32224 @code{while}, @code{for}, or @code{foreach} loop. If given a
32225 value, as in @samp{(break x)}, this value is returned by the
32226 loop. (Lisp loops otherwise always return @code{nil}.)
32229 The @code{return} function prematurely returns from the enclosing
32230 function. For example, @samp{(return (+ x y))} returns @expr{x+y}
32231 as the value of a function. You can use @code{return} anywhere
32232 inside the body of the function.
32235 Non-integer numbers (and extremely large integers) cannot be included
32236 directly into a @code{defmath} definition. This is because the Lisp
32237 reader will fail to parse them long before @code{defmath} ever gets control.
32238 Instead, use the notation, @samp{:"3.1415"}. In fact, any algebraic
32239 formula can go between the quotes. For example,
32242 (defmath sqexp (x) ; sqexp(x) == sqrt(exp(x)) == exp(x*0.5)
32250 (defun calcFunc-sqexp (x)
32251 (and (math-numberp x)
32252 (calcFunc-exp (math-mul x '(float 5 -1)))))
32255 Note the use of @code{numberp} as a guard to ensure that the argument is
32256 a number first, returning @code{nil} if not. The exponential function
32257 could itself have been included in the expression, if we had preferred:
32258 @samp{:"exp(x * 0.5)"}. As another example, the multiplication-and-recursion
32259 step of @code{myfact} could have been written
32265 A good place to put your @code{defmath} commands is your Calc init file
32266 (the file given by @code{calc-settings-file}, typically
32267 @file{~/.emacs.d/calc.el}), which will not be loaded until Calc starts.
32268 If a file named @file{.emacs} exists in your home directory, Emacs reads
32269 and executes the Lisp forms in this file as it starts up. While it may
32270 seem reasonable to put your favorite @code{defmath} commands there,
32271 this has the unfortunate side-effect that parts of the Calculator must be
32272 loaded in to process the @code{defmath} commands whether or not you will
32273 actually use the Calculator! If you want to put the @code{defmath}
32274 commands there (for example, if you redefine @code{calc-settings-file}
32275 to be @file{.emacs}), a better effect can be had by writing
32278 (put 'calc-define 'thing '(progn
32285 @vindex calc-define
32286 The @code{put} function adds a @dfn{property} to a symbol. Each Lisp
32287 symbol has a list of properties associated with it. Here we add a
32288 property with a name of @code{thing} and a @samp{(progn ...)} form as
32289 its value. When Calc starts up, and at the start of every Calc command,
32290 the property list for the symbol @code{calc-define} is checked and the
32291 values of any properties found are evaluated as Lisp forms. The
32292 properties are removed as they are evaluated. The property names
32293 (like @code{thing}) are not used; you should choose something like the
32294 name of your project so as not to conflict with other properties.
32296 The net effect is that you can put the above code in your @file{.emacs}
32297 file and it will not be executed until Calc is loaded. Or, you can put
32298 that same code in another file which you load by hand either before or
32299 after Calc itself is loaded.
32301 The properties of @code{calc-define} are evaluated in the same order
32302 that they were added. They can assume that the Calc modules @file{calc.el},
32303 @file{calc-ext.el}, and @file{calc-macs.el} have been fully loaded, and
32304 that the @file{*Calculator*} buffer will be the current buffer.
32306 If your @code{calc-define} property only defines algebraic functions,
32307 you can be sure that it will have been evaluated before Calc tries to
32308 call your function, even if the file defining the property is loaded
32309 after Calc is loaded. But if the property defines commands or key
32310 sequences, it may not be evaluated soon enough. (Suppose it defines the
32311 new command @code{tweak-calc}; the user can load your file, then type
32312 @kbd{M-x tweak-calc} before Calc has had chance to do anything.) To
32313 protect against this situation, you can put
32316 (run-hooks 'calc-check-defines)
32319 @findex calc-check-defines
32321 at the end of your file. The @code{calc-check-defines} function is what
32322 looks for and evaluates properties on @code{calc-define}; @code{run-hooks}
32323 has the advantage that it is quietly ignored if @code{calc-check-defines}
32324 is not yet defined because Calc has not yet been loaded.
32326 Examples of things that ought to be enclosed in a @code{calc-define}
32327 property are @code{defmath} calls, @code{define-key} calls that modify
32328 the Calc key map, and any calls that redefine things defined inside Calc.
32329 Ordinary @code{defun}s need not be enclosed with @code{calc-define}.
32331 @node Defining Simple Commands, Defining Stack Commands, Defining Functions, Lisp Definitions
32332 @subsection Defining New Simple Commands
32335 @findex interactive
32336 If a @code{defmath} form contains an @code{interactive} clause, it defines
32337 a Calculator command. Actually such a @code{defmath} results in @emph{two}
32338 function definitions: One, a @samp{calcFunc-} function as was just described,
32339 with the @code{interactive} clause removed. Two, a @samp{calc-} function
32340 with a suitable @code{interactive} clause and some sort of wrapper to make
32341 the command work in the Calc environment.
32343 In the simple case, the @code{interactive} clause has the same form as
32344 for normal Emacs Lisp commands:
32347 (defmath increase-precision (delta)
32348 "Increase precision by DELTA." ; This is the "documentation string"
32349 (interactive "p") ; Register this as a M-x-able command
32350 (setq calc-internal-prec (+ calc-internal-prec delta)))
32353 This expands to the pair of definitions,
32356 (defun calc-increase-precision (delta)
32357 "Increase precision by DELTA."
32360 (setq calc-internal-prec (math-add calc-internal-prec delta))))
32362 (defun calcFunc-increase-precision (delta)
32363 "Increase precision by DELTA."
32364 (setq calc-internal-prec (math-add calc-internal-prec delta)))
32368 where in this case the latter function would never really be used! Note
32369 that since the Calculator stores small integers as plain Lisp integers,
32370 the @code{math-add} function will work just as well as the native
32371 @code{+} even when the intent is to operate on native Lisp integers.
32373 @findex calc-wrapper
32374 The @samp{calc-wrapper} call invokes a macro which surrounds the body of
32375 the function with code that looks roughly like this:
32378 (let ((calc-command-flags nil))
32380 (save-current-buffer
32381 (calc-select-buffer)
32382 @emph{body of function}
32383 @emph{renumber stack}
32384 @emph{clear} Working @emph{message})
32385 @emph{realign cursor and window}
32386 @emph{clear Inverse, Hyperbolic, and Keep Args flags}
32387 @emph{update Emacs mode line}))
32390 @findex calc-select-buffer
32391 The @code{calc-select-buffer} function selects the @file{*Calculator*}
32392 buffer if necessary, say, because the command was invoked from inside
32393 the @file{*Calc Trail*} window.
32395 @findex calc-set-command-flag
32396 You can call, for example, @code{(calc-set-command-flag 'no-align)} to
32397 set the above-mentioned command flags. Calc routines recognize the
32398 following command flags:
32402 Stack line numbers @samp{1:}, @samp{2:}, and so on must be renumbered
32403 after this command completes. This is set by routines like
32406 @item clear-message
32407 Calc should call @samp{(message "")} if this command completes normally
32408 (to clear a ``Working@dots{}'' message out of the echo area).
32411 Do not move the cursor back to the @samp{.} top-of-stack marker.
32413 @item position-point
32414 Use the variables @code{calc-position-point-line} and
32415 @code{calc-position-point-column} to position the cursor after
32416 this command finishes.
32419 Do not clear @code{calc-inverse-flag}, @code{calc-hyperbolic-flag},
32420 and @code{calc-keep-args-flag} at the end of this command.
32423 Switch to buffer @file{*Calc Edit*} after this command.
32426 Do not move trail pointer to end of trail when something is recorded
32432 @vindex calc-Y-help-msgs
32433 Calc reserves a special prefix key, shift-@kbd{Y}, for user-written
32434 extensions to Calc. There are no built-in commands that work with
32435 this prefix key; you must call @code{define-key} from Lisp (probably
32436 from inside a @code{calc-define} property) to add to it. Initially only
32437 @kbd{Y ?} is defined; it takes help messages from a list of strings
32438 (initially @code{nil}) in the variable @code{calc-Y-help-msgs}. All
32439 other undefined keys except for @kbd{Y} are reserved for use by
32440 future versions of Calc.
32442 If you are writing a Calc enhancement which you expect to give to
32443 others, it is best to minimize the number of @kbd{Y}-key sequences
32444 you use. In fact, if you have more than one key sequence you should
32445 consider defining three-key sequences with a @kbd{Y}, then a key that
32446 stands for your package, then a third key for the particular command
32447 within your package.
32449 Users may wish to install several Calc enhancements, and it is possible
32450 that several enhancements will choose to use the same key. In the
32451 example below, a variable @code{inc-prec-base-key} has been defined
32452 to contain the key that identifies the @code{inc-prec} package. Its
32453 value is initially @code{"P"}, but a user can change this variable
32454 if necessary without having to modify the file.
32456 Here is a complete file, @file{inc-prec.el}, which makes a @kbd{Y P I}
32457 command that increases the precision, and a @kbd{Y P D} command that
32458 decreases the precision.
32461 ;;; Increase and decrease Calc precision. Dave Gillespie, 5/31/91.
32462 ;; (Include copyright or copyleft stuff here.)
32464 (defvar inc-prec-base-key "P"
32465 "Base key for inc-prec.el commands.")
32467 (put 'calc-define 'inc-prec '(progn
32469 (define-key calc-mode-map (format "Y%sI" inc-prec-base-key)
32470 'increase-precision)
32471 (define-key calc-mode-map (format "Y%sD" inc-prec-base-key)
32472 'decrease-precision)
32474 (setq calc-Y-help-msgs
32475 (cons (format "%s + Inc-prec, Dec-prec" inc-prec-base-key)
32478 (defmath increase-precision (delta)
32479 "Increase precision by DELTA."
32481 (setq calc-internal-prec (+ calc-internal-prec delta)))
32483 (defmath decrease-precision (delta)
32484 "Decrease precision by DELTA."
32486 (setq calc-internal-prec (- calc-internal-prec delta)))
32488 )) ; end of calc-define property
32490 (run-hooks 'calc-check-defines)
32493 @node Defining Stack Commands, Argument Qualifiers, Defining Simple Commands, Lisp Definitions
32494 @subsection Defining New Stack-Based Commands
32497 To define a new computational command which takes and/or leaves arguments
32498 on the stack, a special form of @code{interactive} clause is used.
32501 (interactive @var{num} @var{tag})
32505 where @var{num} is an integer, and @var{tag} is a string. The effect is
32506 to pop @var{num} values off the stack, resimplify them by calling
32507 @code{calc-normalize}, and hand them to your function according to the
32508 function's argument list. Your function may include @code{&optional} and
32509 @code{&rest} parameters, so long as calling the function with @var{num}
32510 parameters is valid.
32512 Your function must return either a number or a formula in a form
32513 acceptable to Calc, or a list of such numbers or formulas. These value(s)
32514 are pushed onto the stack when the function completes. They are also
32515 recorded in the Calc Trail buffer on a line beginning with @var{tag},
32516 a string of (normally) four characters or less. If you omit @var{tag}
32517 or use @code{nil} as a tag, the result is not recorded in the trail.
32519 As an example, the definition
32522 (defmath myfact (n)
32523 "Compute the factorial of the integer at the top of the stack."
32524 (interactive 1 "fact")
32526 (* n (myfact (1- n)))
32531 is a version of the factorial function shown previously which can be used
32532 as a command as well as an algebraic function. It expands to
32535 (defun calc-myfact ()
32536 "Compute the factorial of the integer at the top of the stack."
32539 (calc-enter-result 1 "fact"
32540 (cons 'calcFunc-myfact (calc-top-list-n 1)))))
32542 (defun calcFunc-myfact (n)
32543 "Compute the factorial of the integer at the top of the stack."
32545 (math-mul n (calcFunc-myfact (math-add n -1)))
32546 (and (math-zerop n) 1)))
32549 @findex calc-slow-wrapper
32550 The @code{calc-slow-wrapper} function is a version of @code{calc-wrapper}
32551 that automatically puts up a @samp{Working...} message before the
32552 computation begins. (This message can be turned off by the user
32553 with an @kbd{m w} (@code{calc-working}) command.)
32555 @findex calc-top-list-n
32556 The @code{calc-top-list-n} function returns a list of the specified number
32557 of values from the top of the stack. It resimplifies each value by
32558 calling @code{calc-normalize}. If its argument is zero it returns an
32559 empty list. It does not actually remove these values from the stack.
32561 @findex calc-enter-result
32562 The @code{calc-enter-result} function takes an integer @var{num} and string
32563 @var{tag} as described above, plus a third argument which is either a
32564 Calculator data object or a list of such objects. These objects are
32565 resimplified and pushed onto the stack after popping the specified number
32566 of values from the stack. If @var{tag} is non-@code{nil}, the values
32567 being pushed are also recorded in the trail.
32569 Note that if @code{calcFunc-myfact} returns @code{nil} this represents
32570 ``leave the function in symbolic form.'' To return an actual empty list,
32571 in the sense that @code{calc-enter-result} will push zero elements back
32572 onto the stack, you should return the special value @samp{'(nil)}, a list
32573 containing the single symbol @code{nil}.
32575 The @code{interactive} declaration can actually contain a limited
32576 Emacs-style code string as well which comes just before @var{num} and
32577 @var{tag}. Currently the only Emacs code supported is @samp{"p"}, as in
32580 (defmath foo (a b &optional c)
32581 (interactive "p" 2 "foo")
32585 In this example, the command @code{calc-foo} will evaluate the expression
32586 @samp{foo(a,b)} if executed with no argument, or @samp{foo(a,b,n)} if
32587 executed with a numeric prefix argument of @expr{n}.
32589 The other code string allowed is @samp{"m"} (unrelated to the usual @samp{"m"}
32590 code as used with @code{defun}). It uses the numeric prefix argument as the
32591 number of objects to remove from the stack and pass to the function.
32592 In this case, the integer @var{num} serves as a default number of
32593 arguments to be used when no prefix is supplied.
32595 @node Argument Qualifiers, Example Definitions, Defining Stack Commands, Lisp Definitions
32596 @subsection Argument Qualifiers
32599 Anywhere a parameter name can appear in the parameter list you can also use
32600 an @dfn{argument qualifier}. Thus the general form of a definition is:
32603 (defmath @var{name} (@var{param} @var{param...}
32604 &optional @var{param} @var{param...}
32610 where each @var{param} is either a symbol or a list of the form
32613 (@var{qual} @var{param})
32616 The following qualifiers are recognized:
32621 The argument must not be an incomplete vector, interval, or complex number.
32622 (This is rarely needed since the Calculator itself will never call your
32623 function with an incomplete argument. But there is nothing stopping your
32624 own Lisp code from calling your function with an incomplete argument.)
32628 The argument must be an integer. If it is an integer-valued float
32629 it will be accepted but converted to integer form. Non-integers and
32630 formulas are rejected.
32634 Like @samp{integer}, but the argument must be non-negative.
32638 Like @samp{integer}, but the argument must fit into a native Lisp integer,
32639 which on most systems means less than 2^23 in absolute value. The
32640 argument is converted into Lisp-integer form if necessary.
32644 The argument is converted to floating-point format if it is a number or
32645 vector. If it is a formula it is left alone. (The argument is never
32646 actually rejected by this qualifier.)
32649 The argument must satisfy predicate @var{pred}, which is one of the
32650 standard Calculator predicates. @xref{Predicates}.
32652 @item not-@var{pred}
32653 The argument must @emph{not} satisfy predicate @var{pred}.
32659 (defmath foo (a (constp (not-matrixp b)) &optional (float c)
32668 (defun calcFunc-foo (a b &optional c &rest d)
32669 (and (math-matrixp b)
32670 (math-reject-arg b 'not-matrixp))
32671 (or (math-constp b)
32672 (math-reject-arg b 'constp))
32673 (and c (setq c (math-check-float c)))
32674 (setq d (mapcar 'math-check-integer d))
32679 which performs the necessary checks and conversions before executing the
32680 body of the function.
32682 @node Example Definitions, Calling Calc from Your Programs, Argument Qualifiers, Lisp Definitions
32683 @subsection Example Definitions
32686 This section includes some Lisp programming examples on a larger scale.
32687 These programs make use of some of the Calculator's internal functions;
32691 * Bit Counting Example::
32695 @node Bit Counting Example, Sine Example, Example Definitions, Example Definitions
32696 @subsubsection Bit-Counting
32703 Calc does not include a built-in function for counting the number of
32704 ``one'' bits in a binary integer. It's easy to invent one using @kbd{b u}
32705 to convert the integer to a set, and @kbd{V #} to count the elements of
32706 that set; let's write a function that counts the bits without having to
32707 create an intermediate set.
32710 (defmath bcount ((natnum n))
32711 (interactive 1 "bcnt")
32715 (setq count (1+ count)))
32716 (setq n (lsh n -1)))
32721 When this is expanded by @code{defmath}, it will become the following
32722 Emacs Lisp function:
32725 (defun calcFunc-bcount (n)
32726 (setq n (math-check-natnum n))
32728 (while (math-posp n)
32730 (setq count (math-add count 1)))
32731 (setq n (calcFunc-lsh n -1)))
32735 If the input numbers are large, this function involves a fair amount
32736 of arithmetic. A binary right shift is essentially a division by two;
32737 recall that Calc stores integers in decimal form so bit shifts must
32738 involve actual division.
32740 To gain a bit more efficiency, we could divide the integer into
32741 @var{n}-bit chunks, each of which can be handled quickly because
32742 they fit into Lisp integers. It turns out that Calc's arithmetic
32743 routines are especially fast when dividing by an integer less than
32744 1000, so we can set @var{n = 9} bits and use repeated division by 512:
32747 (defmath bcount ((natnum n))
32748 (interactive 1 "bcnt")
32750 (while (not (fixnump n))
32751 (let ((qr (idivmod n 512)))
32752 (setq count (+ count (bcount-fixnum (cdr qr)))
32754 (+ count (bcount-fixnum n))))
32756 (defun bcount-fixnum (n)
32759 (setq count (+ count (logand n 1))
32765 Note that the second function uses @code{defun}, not @code{defmath}.
32766 Because this function deals only with native Lisp integers (``fixnums''),
32767 it can use the actual Emacs @code{+} and related functions rather
32768 than the slower but more general Calc equivalents which @code{defmath}
32771 The @code{idivmod} function does an integer division, returning both
32772 the quotient and the remainder at once. Again, note that while it
32773 might seem that @samp{(logand n 511)} and @samp{(lsh n -9)} are
32774 more efficient ways to split off the bottom nine bits of @code{n},
32775 actually they are less efficient because each operation is really
32776 a division by 512 in disguise; @code{idivmod} allows us to do the
32777 same thing with a single division by 512.
32779 @node Sine Example, , Bit Counting Example, Example Definitions
32780 @subsubsection The Sine Function
32787 A somewhat limited sine function could be defined as follows, using the
32788 well-known Taylor series expansion for
32789 @texline @math{\sin x}:
32790 @infoline @samp{sin(x)}:
32793 (defmath mysin ((float (anglep x)))
32794 (interactive 1 "mysn")
32795 (setq x (to-radians x)) ; Convert from current angular mode.
32796 (let ((sum x) ; Initial term of Taylor expansion of sin.
32798 (nfact 1) ; "nfact" equals "n" factorial at all times.
32799 (xnegsqr :"-(x^2)")) ; "xnegsqr" equals -x^2.
32800 (for ((n 3 100 2)) ; Upper limit of 100 is a good precaution.
32801 (working "mysin" sum) ; Display "Working" message, if enabled.
32802 (setq nfact (* nfact (1- n) n)
32804 newsum (+ sum (/ x nfact)))
32805 (if (~= newsum sum) ; If newsum is "nearly equal to" sum,
32806 (break)) ; then we are done.
32811 The actual @code{sin} function in Calc works by first reducing the problem
32812 to a sine or cosine of a nonnegative number less than @cpiover{4}. This
32813 ensures that the Taylor series will converge quickly. Also, the calculation
32814 is carried out with two extra digits of precision to guard against cumulative
32815 round-off in @samp{sum}. Finally, complex arguments are allowed and handled
32816 by a separate algorithm.
32819 (defmath mysin ((float (scalarp x)))
32820 (interactive 1 "mysn")
32821 (setq x (to-radians x)) ; Convert from current angular mode.
32822 (with-extra-prec 2 ; Evaluate with extra precision.
32823 (cond ((complexp x)
32826 (- (mysin-raw (- x))) ; Always call mysin-raw with x >= 0.
32827 (t (mysin-raw x))))))
32829 (defmath mysin-raw (x)
32831 (mysin-raw (% x (two-pi)))) ; Now x < 7.
32833 (- (mysin-raw (- x (pi))))) ; Now -pi/2 <= x <= pi/2.
32835 (mycos-raw (- x (pi-over-2)))) ; Now -pi/2 <= x <= pi/4.
32836 ((< x (- (pi-over-4)))
32837 (- (mycos-raw (+ x (pi-over-2))))) ; Now -pi/4 <= x <= pi/4,
32838 (t (mysin-series x)))) ; so the series will be efficient.
32842 where @code{mysin-complex} is an appropriate function to handle complex
32843 numbers, @code{mysin-series} is the routine to compute the sine Taylor
32844 series as before, and @code{mycos-raw} is a function analogous to
32845 @code{mysin-raw} for cosines.
32847 The strategy is to ensure that @expr{x} is nonnegative before calling
32848 @code{mysin-raw}. This function then recursively reduces its argument
32849 to a suitable range, namely, plus-or-minus @cpiover{4}. Note that each
32850 test, and particularly the first comparison against 7, is designed so
32851 that small roundoff errors cannot produce an infinite loop. (Suppose
32852 we compared with @samp{(two-pi)} instead; if due to roundoff problems
32853 the modulo operator ever returned @samp{(two-pi)} exactly, an infinite
32854 recursion could result!) We use modulo only for arguments that will
32855 clearly get reduced, knowing that the next rule will catch any reductions
32856 that this rule misses.
32858 If a program is being written for general use, it is important to code
32859 it carefully as shown in this second example. For quick-and-dirty programs,
32860 when you know that your own use of the sine function will never encounter
32861 a large argument, a simpler program like the first one shown is fine.
32863 @node Calling Calc from Your Programs, Internals, Example Definitions, Lisp Definitions
32864 @subsection Calling Calc from Your Lisp Programs
32867 A later section (@pxref{Internals}) gives a full description of
32868 Calc's internal Lisp functions. It's not hard to call Calc from
32869 inside your programs, but the number of these functions can be daunting.
32870 So Calc provides one special ``programmer-friendly'' function called
32871 @code{calc-eval} that can be made to do just about everything you
32872 need. It's not as fast as the low-level Calc functions, but it's
32873 much simpler to use!
32875 It may seem that @code{calc-eval} itself has a daunting number of
32876 options, but they all stem from one simple operation.
32878 In its simplest manifestation, @samp{(calc-eval "1+2")} parses the
32879 string @code{"1+2"} as if it were a Calc algebraic entry and returns
32880 the result formatted as a string: @code{"3"}.
32882 Since @code{calc-eval} is on the list of recommended @code{autoload}
32883 functions, you don't need to make any special preparations to load
32884 Calc before calling @code{calc-eval} the first time. Calc will be
32885 loaded and initialized for you.
32887 All the Calc modes that are currently in effect will be used when
32888 evaluating the expression and formatting the result.
32895 @subsubsection Additional Arguments to @code{calc-eval}
32898 If the input string parses to a list of expressions, Calc returns
32899 the results separated by @code{", "}. You can specify a different
32900 separator by giving a second string argument to @code{calc-eval}:
32901 @samp{(calc-eval "1+2,3+4" ";")} returns @code{"3;7"}.
32903 The ``separator'' can also be any of several Lisp symbols which
32904 request other behaviors from @code{calc-eval}. These are discussed
32907 You can give additional arguments to be substituted for
32908 @samp{$}, @samp{$$}, and so on in the main expression. For
32909 example, @samp{(calc-eval "$/$$" nil "7" "1+1")} evaluates the
32910 expression @code{"7/(1+1)"} to yield the result @code{"3.5"}
32911 (assuming Fraction mode is not in effect). Note the @code{nil}
32912 used as a placeholder for the item-separator argument.
32919 @subsubsection Error Handling
32922 If @code{calc-eval} encounters an error, it returns a list containing
32923 the character position of the error, plus a suitable message as a
32924 string. Note that @samp{1 / 0} is @emph{not} an error by Calc's
32925 standards; it simply returns the string @code{"1 / 0"} which is the
32926 division left in symbolic form. But @samp{(calc-eval "1/")} will
32927 return the list @samp{(2 "Expected a number")}.
32929 If you bind the variable @code{calc-eval-error} to @code{t}
32930 using a @code{let} form surrounding the call to @code{calc-eval},
32931 errors instead call the Emacs @code{error} function which aborts
32932 to the Emacs command loop with a beep and an error message.
32934 If you bind this variable to the symbol @code{string}, error messages
32935 are returned as strings instead of lists. The character position is
32938 As a courtesy to other Lisp code which may be using Calc, be sure
32939 to bind @code{calc-eval-error} using @code{let} rather than changing
32940 it permanently with @code{setq}.
32947 @subsubsection Numbers Only
32950 Sometimes it is preferable to treat @samp{1 / 0} as an error
32951 rather than returning a symbolic result. If you pass the symbol
32952 @code{num} as the second argument to @code{calc-eval}, results
32953 that are not constants are treated as errors. The error message
32954 reported is the first @code{calc-why} message if there is one,
32955 or otherwise ``Number expected.''
32957 A result is ``constant'' if it is a number, vector, or other
32958 object that does not include variables or function calls. If it
32959 is a vector, the components must themselves be constants.
32966 @subsubsection Default Modes
32969 If the first argument to @code{calc-eval} is a list whose first
32970 element is a formula string, then @code{calc-eval} sets all the
32971 various Calc modes to their default values while the formula is
32972 evaluated and formatted. For example, the precision is set to 12
32973 digits, digit grouping is turned off, and the Normal language
32976 This same principle applies to the other options discussed below.
32977 If the first argument would normally be @var{x}, then it can also
32978 be the list @samp{(@var{x})} to use the default mode settings.
32980 If there are other elements in the list, they are taken as
32981 variable-name/value pairs which override the default mode
32982 settings. Look at the documentation at the front of the
32983 @file{calc.el} file to find the names of the Lisp variables for
32984 the various modes. The mode settings are restored to their
32985 original values when @code{calc-eval} is done.
32987 For example, @samp{(calc-eval '("$+$$" calc-internal-prec 8) 'num a b)}
32988 computes the sum of two numbers, requiring a numeric result, and
32989 using default mode settings except that the precision is 8 instead
32990 of the default of 12.
32992 It's usually best to use this form of @code{calc-eval} unless your
32993 program actually considers the interaction with Calc's mode settings
32994 to be a feature. This will avoid all sorts of potential ``gotchas'';
32995 consider what happens with @samp{(calc-eval "sqrt(2)" 'num)}
32996 when the user has left Calc in Symbolic mode or No-Simplify mode.
32998 As another example, @samp{(equal (calc-eval '("$<$$") nil a b) "1")}
32999 checks if the number in string @expr{a} is less than the one in
33000 string @expr{b}. Without using a list, the integer 1 might
33001 come out in a variety of formats which would be hard to test for
33002 conveniently: @code{"1"}, @code{"8#1"}, @code{"00001"}. (But
33003 see ``Predicates'' mode, below.)
33010 @subsubsection Raw Numbers
33013 Normally all input and output for @code{calc-eval} is done with strings.
33014 You can do arithmetic with, say, @samp{(calc-eval "$+$$" nil a b)}
33015 in place of @samp{(+ a b)}, but this is very inefficient since the
33016 numbers must be converted to and from string format as they are passed
33017 from one @code{calc-eval} to the next.
33019 If the separator is the symbol @code{raw}, the result will be returned
33020 as a raw Calc data structure rather than a string. You can read about
33021 how these objects look in the following sections, but usually you can
33022 treat them as ``black box'' objects with no important internal
33025 There is also a @code{rawnum} symbol, which is a combination of
33026 @code{raw} (returning a raw Calc object) and @code{num} (signaling
33027 an error if that object is not a constant).
33029 You can pass a raw Calc object to @code{calc-eval} in place of a
33030 string, either as the formula itself or as one of the @samp{$}
33031 arguments. Thus @samp{(calc-eval "$+$$" 'raw a b)} is an
33032 addition function that operates on raw Calc objects. Of course
33033 in this case it would be easier to call the low-level @code{math-add}
33034 function in Calc, if you can remember its name.
33036 In particular, note that a plain Lisp integer is acceptable to Calc
33037 as a raw object. (All Lisp integers are accepted on input, but
33038 integers of more than six decimal digits are converted to ``big-integer''
33039 form for output. @xref{Data Type Formats}.)
33041 When it comes time to display the object, just use @samp{(calc-eval a)}
33042 to format it as a string.
33044 It is an error if the input expression evaluates to a list of
33045 values. The separator symbol @code{list} is like @code{raw}
33046 except that it returns a list of one or more raw Calc objects.
33048 Note that a Lisp string is not a valid Calc object, nor is a list
33049 containing a string. Thus you can still safely distinguish all the
33050 various kinds of error returns discussed above.
33057 @subsubsection Predicates
33060 If the separator symbol is @code{pred}, the result of the formula is
33061 treated as a true/false value; @code{calc-eval} returns @code{t} or
33062 @code{nil}, respectively. A value is considered ``true'' if it is a
33063 non-zero number, or false if it is zero or if it is not a number.
33065 For example, @samp{(calc-eval "$<$$" 'pred a b)} tests whether
33066 one value is less than another.
33068 As usual, it is also possible for @code{calc-eval} to return one of
33069 the error indicators described above. Lisp will interpret such an
33070 indicator as ``true'' if you don't check for it explicitly. If you
33071 wish to have an error register as ``false'', use something like
33072 @samp{(eq (calc-eval ...) t)}.
33079 @subsubsection Variable Values
33082 Variables in the formula passed to @code{calc-eval} are not normally
33083 replaced by their values. If you wish this, you can use the
33084 @code{evalv} function (@pxref{Algebraic Manipulation}). For example,
33085 if 4 is stored in Calc variable @code{a} (i.e., in Lisp variable
33086 @code{var-a}), then @samp{(calc-eval "a+pi")} will return the
33087 formula @code{"a + pi"}, but @samp{(calc-eval "evalv(a+pi)")}
33088 will return @code{"7.14159265359"}.
33090 To store in a Calc variable, just use @code{setq} to store in the
33091 corresponding Lisp variable. (This is obtained by prepending
33092 @samp{var-} to the Calc variable name.) Calc routines will
33093 understand either string or raw form values stored in variables,
33094 although raw data objects are much more efficient. For example,
33095 to increment the Calc variable @code{a}:
33098 (setq var-a (calc-eval "evalv(a+1)" 'raw))
33106 @subsubsection Stack Access
33109 If the separator symbol is @code{push}, the formula argument is
33110 evaluated (with possible @samp{$} expansions, as usual). The
33111 result is pushed onto the Calc stack. The return value is @code{nil}
33112 (unless there is an error from evaluating the formula, in which
33113 case the return value depends on @code{calc-eval-error} in the
33116 If the separator symbol is @code{pop}, the first argument to
33117 @code{calc-eval} must be an integer instead of a string. That
33118 many values are popped from the stack and thrown away. A negative
33119 argument deletes the entry at that stack level. The return value
33120 is the number of elements remaining in the stack after popping;
33121 @samp{(calc-eval 0 'pop)} is a good way to measure the size of
33124 If the separator symbol is @code{top}, the first argument to
33125 @code{calc-eval} must again be an integer. The value at that
33126 stack level is formatted as a string and returned. Thus
33127 @samp{(calc-eval 1 'top)} returns the top-of-stack value. If the
33128 integer is out of range, @code{nil} is returned.
33130 The separator symbol @code{rawtop} is just like @code{top} except
33131 that the stack entry is returned as a raw Calc object instead of
33134 In all of these cases the first argument can be made a list in
33135 order to force the default mode settings, as described above.
33136 Thus @samp{(calc-eval '(2 calc-number-radix 16) 'top)} returns the
33137 second-to-top stack entry, formatted as a string using the default
33138 instead of current display modes, except that the radix is
33139 hexadecimal instead of decimal.
33141 It is, of course, polite to put the Calc stack back the way you
33142 found it when you are done, unless the user of your program is
33143 actually expecting it to affect the stack.
33145 Note that you do not actually have to switch into the @file{*Calculator*}
33146 buffer in order to use @code{calc-eval}; it temporarily switches into
33147 the stack buffer if necessary.
33154 @subsubsection Keyboard Macros
33157 If the separator symbol is @code{macro}, the first argument must be a
33158 string of characters which Calc can execute as a sequence of keystrokes.
33159 This switches into the Calc buffer for the duration of the macro.
33160 For example, @samp{(calc-eval "vx5\rVR+" 'macro)} pushes the
33161 vector @samp{[1,2,3,4,5]} on the stack and then replaces it
33162 with the sum of those numbers. Note that @samp{\r} is the Lisp
33163 notation for the carriage-return, @key{RET}, character.
33165 If your keyboard macro wishes to pop the stack, @samp{\C-d} is
33166 safer than @samp{\177} (the @key{DEL} character) because some
33167 installations may have switched the meanings of @key{DEL} and
33168 @kbd{C-h}. Calc always interprets @kbd{C-d} as a synonym for
33169 ``pop-stack'' regardless of key mapping.
33171 If you provide a third argument to @code{calc-eval}, evaluation
33172 of the keyboard macro will leave a record in the Trail using
33173 that argument as a tag string. Normally the Trail is unaffected.
33175 The return value in this case is always @code{nil}.
33182 @subsubsection Lisp Evaluation
33185 Finally, if the separator symbol is @code{eval}, then the Lisp
33186 @code{eval} function is called on the first argument, which must
33187 be a Lisp expression rather than a Calc formula. Remember to
33188 quote the expression so that it is not evaluated until inside
33191 The difference from plain @code{eval} is that @code{calc-eval}
33192 switches to the Calc buffer before evaluating the expression.
33193 For example, @samp{(calc-eval '(setq calc-internal-prec 17) 'eval)}
33194 will correctly affect the buffer-local Calc precision variable.
33196 An alternative would be @samp{(calc-eval '(calc-precision 17) 'eval)}.
33197 This is evaluating a call to the function that is normally invoked
33198 by the @kbd{p} key, giving it 17 as its ``numeric prefix argument.''
33199 Note that this function will leave a message in the echo area as
33200 a side effect. Also, all Calc functions switch to the Calc buffer
33201 automatically if not invoked from there, so the above call is
33202 also equivalent to @samp{(calc-precision 17)} by itself.
33203 In all cases, Calc uses @code{save-excursion} to switch back to
33204 your original buffer when it is done.
33206 As usual the first argument can be a list that begins with a Lisp
33207 expression to use default instead of current mode settings.
33209 The result of @code{calc-eval} in this usage is just the result
33210 returned by the evaluated Lisp expression.
33217 @subsubsection Example
33220 @findex convert-temp
33221 Here is a sample Emacs command that uses @code{calc-eval}. Suppose
33222 you have a document with lots of references to temperatures on the
33223 Fahrenheit scale, say ``98.6 F'', and you wish to convert these
33224 references to Centigrade. The following command does this conversion.
33225 Place the Emacs cursor right after the letter ``F'' and invoke the
33226 command to change ``98.6 F'' to ``37 C''. Or, if the temperature is
33227 already in Centigrade form, the command changes it back to Fahrenheit.
33230 (defun convert-temp ()
33233 (re-search-backward "[^-.0-9]\\([-.0-9]+\\) *\\([FC]\\)")
33234 (let* ((top1 (match-beginning 1))
33235 (bot1 (match-end 1))
33236 (number (buffer-substring top1 bot1))
33237 (top2 (match-beginning 2))
33238 (bot2 (match-end 2))
33239 (type (buffer-substring top2 bot2)))
33240 (if (equal type "F")
33242 number (calc-eval "($ - 32)*5/9" nil number))
33244 number (calc-eval "$*9/5 + 32" nil number)))
33246 (delete-region top2 bot2)
33247 (insert-before-markers type)
33249 (delete-region top1 bot1)
33250 (if (string-match "\\.$" number) ; change "37." to "37"
33251 (setq number (substring number 0 -1)))
33255 Note the use of @code{insert-before-markers} when changing between
33256 ``F'' and ``C'', so that the character winds up before the cursor
33257 instead of after it.
33259 @node Internals, , Calling Calc from Your Programs, Lisp Definitions
33260 @subsection Calculator Internals
33263 This section describes the Lisp functions defined by the Calculator that
33264 may be of use to user-written Calculator programs (as described in the
33265 rest of this chapter). These functions are shown by their names as they
33266 conventionally appear in @code{defmath}. Their full Lisp names are
33267 generally gotten by prepending @samp{calcFunc-} or @samp{math-} to their
33268 apparent names. (Names that begin with @samp{calc-} are already in
33269 their full Lisp form.) You can use the actual full names instead if you
33270 prefer them, or if you are calling these functions from regular Lisp.
33272 The functions described here are scattered throughout the various
33273 Calc component files. Note that @file{calc.el} includes @code{autoload}s
33274 for only a few component files; when Calc wants to call an advanced
33275 function it calls @samp{(calc-extensions)} first; this function
33276 autoloads @file{calc-ext.el}, which in turn autoloads all the functions
33277 in the remaining component files.
33279 Because @code{defmath} itself uses the extensions, user-written code
33280 generally always executes with the extensions already loaded, so
33281 normally you can use any Calc function and be confident that it will
33282 be autoloaded for you when necessary. If you are doing something
33283 special, check carefully to make sure each function you are using is
33284 from @file{calc.el} or its components, and call @samp{(calc-extensions)}
33285 before using any function based in @file{calc-ext.el} if you can't
33286 prove this file will already be loaded.
33289 * Data Type Formats::
33290 * Interactive Lisp Functions::
33291 * Stack Lisp Functions::
33293 * Computational Lisp Functions::
33294 * Vector Lisp Functions::
33295 * Symbolic Lisp Functions::
33296 * Formatting Lisp Functions::
33300 @node Data Type Formats, Interactive Lisp Functions, Internals, Internals
33301 @subsubsection Data Type Formats
33304 Integers are stored in either of two ways, depending on their magnitude.
33305 Integers less than one million in absolute value are stored as standard
33306 Lisp integers. This is the only storage format for Calc data objects
33307 which is not a Lisp list.
33309 Large integers are stored as lists of the form @samp{(bigpos @var{d0}
33310 @var{d1} @var{d2} @dots{})} for sufficiently large positive integers
33311 (where ``sufficiently large'' depends on the machine), or
33312 @samp{(bigneg @var{d0} @var{d1} @var{d2} @dots{})} for negative
33313 integers. Each @var{d} is a base-@expr{10^n} ``digit'' (where again,
33314 @expr{n} depends on the machine), a Lisp integer from 0 to
33315 99@dots{}9. The least significant digit is @var{d0}; the last digit,
33316 @var{dn}, which is always nonzero, is the most significant digit. For
33317 example, the integer @mathit{-12345678} might be stored as
33318 @samp{(bigneg 678 345 12)}.
33320 The distinction between small and large integers is entirely hidden from
33321 the user. In @code{defmath} definitions, the Lisp predicate @code{integerp}
33322 returns true for either kind of integer, and in general both big and small
33323 integers are accepted anywhere the word ``integer'' is used in this manual.
33324 If the distinction must be made, native Lisp integers are called @dfn{fixnums}
33325 and large integers are called @dfn{bignums}.
33327 Fractions are stored as a list of the form, @samp{(frac @var{n} @var{d})}
33328 where @var{n} is an integer (big or small) numerator, @var{d} is an
33329 integer denominator greater than one, and @var{n} and @var{d} are relatively
33330 prime. Note that fractions where @var{d} is one are automatically converted
33331 to plain integers by all math routines; fractions where @var{d} is negative
33332 are normalized by negating the numerator and denominator.
33334 Floating-point numbers are stored in the form, @samp{(float @var{mant}
33335 @var{exp})}, where @var{mant} (the ``mantissa'') is an integer less than
33336 @samp{10^@var{p}} in absolute value (@var{p} represents the current
33337 precision), and @var{exp} (the ``exponent'') is a fixnum. The value of
33338 the float is @samp{@var{mant} * 10^@var{exp}}. For example, the number
33339 @mathit{-3.14} is stored as @samp{(float -314 -2) = -314*10^-2}. Other constraints
33340 are that the number 0.0 is always stored as @samp{(float 0 0)}, and,
33341 except for the 0.0 case, the rightmost base-10 digit of @var{mant} is
33342 always nonzero. (If the rightmost digit is zero, the number is
33343 rearranged by dividing @var{mant} by ten and incrementing @var{exp}.)
33345 Rectangular complex numbers are stored in the form @samp{(cplx @var{re}
33346 @var{im})}, where @var{re} and @var{im} are each real numbers, either
33347 integers, fractions, or floats. The value is @samp{@var{re} + @var{im}i}.
33348 The @var{im} part is nonzero; complex numbers with zero imaginary
33349 components are converted to real numbers automatically.
33351 Polar complex numbers are stored in the form @samp{(polar @var{r}
33352 @var{theta})}, where @var{r} is a positive real value and @var{theta}
33353 is a real value or HMS form representing an angle. This angle is
33354 usually normalized to lie in the interval @samp{(-180 ..@: 180)} degrees,
33355 or @samp{(-pi ..@: pi)} radians, according to the current angular mode.
33356 If the angle is 0 the value is converted to a real number automatically.
33357 (If the angle is 180 degrees, the value is usually also converted to a
33358 negative real number.)
33360 Hours-minutes-seconds forms are stored as @samp{(hms @var{h} @var{m}
33361 @var{s})}, where @var{h} is an integer or an integer-valued float (i.e.,
33362 a float with @samp{@var{exp} >= 0}), @var{m} is an integer or integer-valued
33363 float in the range @w{@samp{[0 ..@: 60)}}, and @var{s} is any real number
33364 in the range @samp{[0 ..@: 60)}.
33366 Date forms are stored as @samp{(date @var{n})}, where @var{n} is
33367 a real number that counts days since midnight on the morning of
33368 January 1, 1 AD@. If @var{n} is an integer, this is a pure date
33369 form. If @var{n} is a fraction or float, this is a date/time form.
33371 Modulo forms are stored as @samp{(mod @var{n} @var{m})}, where @var{m} is a
33372 positive real number or HMS form, and @var{n} is a real number or HMS
33373 form in the range @samp{[0 ..@: @var{m})}.
33375 Error forms are stored as @samp{(sdev @var{x} @var{sigma})}, where @var{x}
33376 is the mean value and @var{sigma} is the standard deviation. Each
33377 component is either a number, an HMS form, or a symbolic object
33378 (a variable or function call). If @var{sigma} is zero, the value is
33379 converted to a plain real number. If @var{sigma} is negative or
33380 complex, it is automatically normalized to be a positive real.
33382 Interval forms are stored as @samp{(intv @var{mask} @var{lo} @var{hi})},
33383 where @var{mask} is one of the integers 0, 1, 2, or 3, and @var{lo} and
33384 @var{hi} are real numbers, HMS forms, or symbolic objects. The @var{mask}
33385 is a binary integer where 1 represents the fact that the interval is
33386 closed on the high end, and 2 represents the fact that it is closed on
33387 the low end. (Thus 3 represents a fully closed interval.) The interval
33388 @w{@samp{(intv 3 @var{x} @var{x})}} is converted to the plain number @var{x};
33389 intervals @samp{(intv @var{mask} @var{x} @var{x})} for any other @var{mask}
33390 represent empty intervals. If @var{hi} is less than @var{lo}, the interval
33391 is converted to a standard empty interval by replacing @var{hi} with @var{lo}.
33393 Vectors are stored as @samp{(vec @var{v1} @var{v2} @dots{})}, where @var{v1}
33394 is the first element of the vector, @var{v2} is the second, and so on.
33395 An empty vector is stored as @samp{(vec)}. A matrix is simply a vector
33396 where all @var{v}'s are themselves vectors of equal lengths. Note that
33397 Calc vectors are unrelated to the Emacs Lisp ``vector'' type, which is
33398 generally unused by Calc data structures.
33400 Variables are stored as @samp{(var @var{name} @var{sym})}, where
33401 @var{name} is a Lisp symbol whose print name is used as the visible name
33402 of the variable, and @var{sym} is a Lisp symbol in which the variable's
33403 value is actually stored. Thus, @samp{(var pi var-pi)} represents the
33404 special constant @samp{pi}. Almost always, the form is @samp{(var
33405 @var{v} var-@var{v})}. If the variable name was entered with @code{#}
33406 signs (which are converted to hyphens internally), the form is
33407 @samp{(var @var{u} @var{v})}, where @var{u} is a symbol whose name
33408 contains @code{#} characters, and @var{v} is a symbol that contains
33409 @code{-} characters instead. The value of a variable is the Calc
33410 object stored in its @var{sym} symbol's value cell. If the symbol's
33411 value cell is void or if it contains @code{nil}, the variable has no
33412 value. Special constants have the form @samp{(special-const
33413 @var{value})} stored in their value cell, where @var{value} is a formula
33414 which is evaluated when the constant's value is requested. Variables
33415 which represent units are not stored in any special way; they are units
33416 only because their names appear in the units table. If the value
33417 cell contains a string, it is parsed to get the variable's value when
33418 the variable is used.
33420 A Lisp list with any other symbol as the first element is a function call.
33421 The symbols @code{+}, @code{-}, @code{*}, @code{/}, @code{%}, @code{^},
33422 and @code{|} represent special binary operators; these lists are always
33423 of the form @samp{(@var{op} @var{lhs} @var{rhs})} where @var{lhs} is the
33424 sub-formula on the lefthand side and @var{rhs} is the sub-formula on the
33425 right. The symbol @code{neg} represents unary negation; this list is always
33426 of the form @samp{(neg @var{arg})}. Any other symbol @var{func} represents a
33427 function that would be displayed in function-call notation; the symbol
33428 @var{func} is in general always of the form @samp{calcFunc-@var{name}}.
33429 The function cell of the symbol @var{func} should contain a Lisp function
33430 for evaluating a call to @var{func}. This function is passed the remaining
33431 elements of the list (themselves already evaluated) as arguments; such
33432 functions should return @code{nil} or call @code{reject-arg} to signify
33433 that they should be left in symbolic form, or they should return a Calc
33434 object which represents their value, or a list of such objects if they
33435 wish to return multiple values. (The latter case is allowed only for
33436 functions which are the outer-level call in an expression whose value is
33437 about to be pushed on the stack; this feature is considered obsolete
33438 and is not used by any built-in Calc functions.)
33440 @node Interactive Lisp Functions, Stack Lisp Functions, Data Type Formats, Internals
33441 @subsubsection Interactive Functions
33444 The functions described here are used in implementing interactive Calc
33445 commands. Note that this list is not exhaustive! If there is an
33446 existing command that behaves similarly to the one you want to define,
33447 you may find helpful tricks by checking the source code for that command.
33449 @defun calc-set-command-flag flag
33450 Set the command flag @var{flag}. This is generally a Lisp symbol, but
33451 may in fact be anything. The effect is to add @var{flag} to the list
33452 stored in the variable @code{calc-command-flags}, unless it is already
33453 there. @xref{Defining Simple Commands}.
33456 @defun calc-clear-command-flag flag
33457 If @var{flag} appears among the list of currently-set command flags,
33458 remove it from that list.
33461 @defun calc-record-undo rec
33462 Add the ``undo record'' @var{rec} to the list of steps to take if the
33463 current operation should need to be undone. Stack push and pop functions
33464 automatically call @code{calc-record-undo}, so the kinds of undo records
33465 you might need to create take the form @samp{(set @var{sym} @var{value})},
33466 which says that the Lisp variable @var{sym} was changed and had previously
33467 contained @var{value}; @samp{(store @var{var} @var{value})} which says that
33468 the Calc variable @var{var} (a string which is the name of the symbol that
33469 contains the variable's value) was stored and its previous value was
33470 @var{value} (either a Calc data object, or @code{nil} if the variable was
33471 previously void); or @samp{(eval @var{undo} @var{redo} @var{args} @dots{})},
33472 which means that to undo requires calling the function @samp{(@var{undo}
33473 @var{args} @dots{})} and, if the undo is later redone, calling
33474 @samp{(@var{redo} @var{args} @dots{})}.
33477 @defun calc-record-why msg args
33478 Record the error or warning message @var{msg}, which is normally a string.
33479 This message will be replayed if the user types @kbd{w} (@code{calc-why});
33480 if the message string begins with a @samp{*}, it is considered important
33481 enough to display even if the user doesn't type @kbd{w}. If one or more
33482 @var{args} are present, the displayed message will be of the form,
33483 @samp{@var{msg}: @var{arg1}, @var{arg2}, @dots{}}, where the arguments are
33484 formatted on the assumption that they are either strings or Calc objects of
33485 some sort. If @var{msg} is a symbol, it is the name of a Calc predicate
33486 (such as @code{integerp} or @code{numvecp}) which the arguments did not
33487 satisfy; it is expanded to a suitable string such as ``Expected an
33488 integer.'' The @code{reject-arg} function calls @code{calc-record-why}
33489 automatically; @pxref{Predicates}.
33492 @defun calc-is-inverse
33493 This predicate returns true if the current command is inverse,
33494 i.e., if the Inverse (@kbd{I} key) flag was set.
33497 @defun calc-is-hyperbolic
33498 This predicate is the analogous function for the @kbd{H} key.
33501 @node Stack Lisp Functions, Predicates, Interactive Lisp Functions, Internals
33502 @subsubsection Stack-Oriented Functions
33505 The functions described here perform various operations on the Calc
33506 stack and trail. They are to be used in interactive Calc commands.
33508 @defun calc-push-list vals n
33509 Push the Calc objects in list @var{vals} onto the stack at stack level
33510 @var{n}. If @var{n} is omitted it defaults to 1, so that the elements
33511 are pushed at the top of the stack. If @var{n} is greater than 1, the
33512 elements will be inserted into the stack so that the last element will
33513 end up at level @var{n}, the next-to-last at level @var{n}+1, etc.
33514 The elements of @var{vals} are assumed to be valid Calc objects, and
33515 are not evaluated, rounded, or renormalized in any way. If @var{vals}
33516 is an empty list, nothing happens.
33518 The stack elements are pushed without any sub-formula selections.
33519 You can give an optional third argument to this function, which must
33520 be a list the same size as @var{vals} of selections. Each selection
33521 must be @code{eq} to some sub-formula of the corresponding formula
33522 in @var{vals}, or @code{nil} if that formula should have no selection.
33525 @defun calc-top-list n m
33526 Return a list of the @var{n} objects starting at level @var{m} of the
33527 stack. If @var{m} is omitted it defaults to 1, so that the elements are
33528 taken from the top of the stack. If @var{n} is omitted, it also
33529 defaults to 1, so that the top stack element (in the form of a
33530 one-element list) is returned. If @var{m} is greater than 1, the
33531 @var{m}th stack element will be at the end of the list, the @var{m}+1st
33532 element will be next-to-last, etc. If @var{n} or @var{m} are out of
33533 range, the command is aborted with a suitable error message. If @var{n}
33534 is zero, the function returns an empty list. The stack elements are not
33535 evaluated, rounded, or renormalized.
33537 If any stack elements contain selections, and selections have not
33538 been disabled by the @kbd{j e} (@code{calc-enable-selections}) command,
33539 this function returns the selected portions rather than the entire
33540 stack elements. It can be given a third ``selection-mode'' argument
33541 which selects other behaviors. If it is the symbol @code{t}, then
33542 a selection in any of the requested stack elements produces an
33543 ``invalid operation on selections'' error. If it is the symbol @code{full},
33544 the whole stack entry is always returned regardless of selections.
33545 If it is the symbol @code{sel}, the selected portion is always returned,
33546 or @code{nil} if there is no selection. (This mode ignores the @kbd{j e}
33547 command.) If the symbol is @code{entry}, the complete stack entry in
33548 list form is returned; the first element of this list will be the whole
33549 formula, and the third element will be the selection (or @code{nil}).
33552 @defun calc-pop-stack n m
33553 Remove the specified elements from the stack. The parameters @var{n}
33554 and @var{m} are defined the same as for @code{calc-top-list}. The return
33555 value of @code{calc-pop-stack} is uninteresting.
33557 If there are any selected sub-formulas among the popped elements, and
33558 @kbd{j e} has not been used to disable selections, this produces an
33559 error without changing the stack. If you supply an optional third
33560 argument of @code{t}, the stack elements are popped even if they
33561 contain selections.
33564 @defun calc-record-list vals tag
33565 This function records one or more results in the trail. The @var{vals}
33566 are a list of strings or Calc objects. The @var{tag} is the four-character
33567 tag string to identify the values. If @var{tag} is omitted, a blank tag
33571 @defun calc-normalize n
33572 This function takes a Calc object and ``normalizes'' it. At the very
33573 least this involves re-rounding floating-point values according to the
33574 current precision and other similar jobs. Also, unless the user has
33575 selected No-Simplify mode (@pxref{Simplification Modes}), this involves
33576 actually evaluating a formula object by executing the function calls
33577 it contains, and possibly also doing algebraic simplification, etc.
33580 @defun calc-top-list-n n m
33581 This function is identical to @code{calc-top-list}, except that it calls
33582 @code{calc-normalize} on the values that it takes from the stack. They
33583 are also passed through @code{check-complete}, so that incomplete
33584 objects will be rejected with an error message. All computational
33585 commands should use this in preference to @code{calc-top-list}; the only
33586 standard Calc commands that operate on the stack without normalizing
33587 are stack management commands like @code{calc-enter} and @code{calc-roll-up}.
33588 This function accepts the same optional selection-mode argument as
33589 @code{calc-top-list}.
33592 @defun calc-top-n m
33593 This function is a convenient form of @code{calc-top-list-n} in which only
33594 a single element of the stack is taken and returned, rather than a list
33595 of elements. This also accepts an optional selection-mode argument.
33598 @defun calc-enter-result n tag vals
33599 This function is a convenient interface to most of the above functions.
33600 The @var{vals} argument should be either a single Calc object, or a list
33601 of Calc objects; the object or objects are normalized, and the top @var{n}
33602 stack entries are replaced by the normalized objects. If @var{tag} is
33603 non-@code{nil}, the normalized objects are also recorded in the trail.
33604 A typical stack-based computational command would take the form,
33607 (calc-enter-result @var{n} @var{tag} (cons 'calcFunc-@var{func}
33608 (calc-top-list-n @var{n})))
33611 If any of the @var{n} stack elements replaced contain sub-formula
33612 selections, and selections have not been disabled by @kbd{j e},
33613 this function takes one of two courses of action. If @var{n} is
33614 equal to the number of elements in @var{vals}, then each element of
33615 @var{vals} is spliced into the corresponding selection; this is what
33616 happens when you use the @key{TAB} key, or when you use a unary
33617 arithmetic operation like @code{sqrt}. If @var{vals} has only one
33618 element but @var{n} is greater than one, there must be only one
33619 selection among the top @var{n} stack elements; the element from
33620 @var{vals} is spliced into that selection. This is what happens when
33621 you use a binary arithmetic operation like @kbd{+}. Any other
33622 combination of @var{n} and @var{vals} is an error when selections
33626 @defun calc-unary-op tag func arg
33627 This function implements a unary operator that allows a numeric prefix
33628 argument to apply the operator over many stack entries. If the prefix
33629 argument @var{arg} is @code{nil}, this uses @code{calc-enter-result}
33630 as outlined above. Otherwise, it maps the function over several stack
33631 elements; @pxref{Prefix Arguments}. For example,
33634 (defun calc-zeta (arg)
33636 (calc-unary-op "zeta" 'calcFunc-zeta arg))
33640 @defun calc-binary-op tag func arg ident unary
33641 This function implements a binary operator, analogously to
33642 @code{calc-unary-op}. The optional @var{ident} and @var{unary}
33643 arguments specify the behavior when the prefix argument is zero or
33644 one, respectively. If the prefix is zero, the value @var{ident}
33645 is pushed onto the stack, if specified, otherwise an error message
33646 is displayed. If the prefix is one, the unary function @var{unary}
33647 is applied to the top stack element, or, if @var{unary} is not
33648 specified, nothing happens. When the argument is two or more,
33649 the binary function @var{func} is reduced across the top @var{arg}
33650 stack elements; when the argument is negative, the function is
33651 mapped between the next-to-top @mathit{-@var{arg}} stack elements and the
33655 @defun calc-stack-size
33656 Return the number of elements on the stack as an integer. This count
33657 does not include elements that have been temporarily hidden by stack
33658 truncation; @pxref{Truncating the Stack}.
33661 @defun calc-cursor-stack-index n
33662 Move the point to the @var{n}th stack entry. If @var{n} is zero, this
33663 will be the @samp{.} line. If @var{n} is from 1 to the current stack size,
33664 this will be the beginning of the first line of that stack entry's display.
33665 If line numbers are enabled, this will move to the first character of the
33666 line number, not the stack entry itself.
33669 @defun calc-substack-height n
33670 Return the number of lines between the beginning of the @var{n}th stack
33671 entry and the bottom of the buffer. If @var{n} is zero, this
33672 will be one (assuming no stack truncation). If all stack entries are
33673 one line long (i.e., no matrices are displayed), the return value will
33674 be equal @var{n}+1 as long as @var{n} is in range. (Note that in Big
33675 mode, the return value includes the blank lines that separate stack
33679 @defun calc-refresh
33680 Erase the @file{*Calculator*} buffer and reformat its contents from memory.
33681 This must be called after changing any parameter, such as the current
33682 display radix, which might change the appearance of existing stack
33683 entries. (During a keyboard macro invoked by the @kbd{X} key, refreshing
33684 is suppressed, but a flag is set so that the entire stack will be refreshed
33685 rather than just the top few elements when the macro finishes.)
33688 @node Predicates, Computational Lisp Functions, Stack Lisp Functions, Internals
33689 @subsubsection Predicates
33692 The functions described here are predicates, that is, they return a
33693 true/false value where @code{nil} means false and anything else means
33694 true. These predicates are expanded by @code{defmath}, for example,
33695 from @code{zerop} to @code{math-zerop}. In many cases they correspond
33696 to native Lisp functions by the same name, but are extended to cover
33697 the full range of Calc data types.
33700 Returns true if @var{x} is numerically zero, in any of the Calc data
33701 types. (Note that for some types, such as error forms and intervals,
33702 it never makes sense to return true.) In @code{defmath}, the expression
33703 @samp{(= x 0)} will automatically be converted to @samp{(math-zerop x)},
33704 and @samp{(/= x 0)} will be converted to @samp{(not (math-zerop x))}.
33708 Returns true if @var{x} is negative. This accepts negative real numbers
33709 of various types, negative HMS and date forms, and intervals in which
33710 all included values are negative. In @code{defmath}, the expression
33711 @samp{(< x 0)} will automatically be converted to @samp{(math-negp x)},
33712 and @samp{(>= x 0)} will be converted to @samp{(not (math-negp x))}.
33716 Returns true if @var{x} is positive (and non-zero). For complex
33717 numbers, none of these three predicates will return true.
33720 @defun looks-negp x
33721 Returns true if @var{x} is ``negative-looking.'' This returns true if
33722 @var{x} is a negative number, or a formula with a leading minus sign
33723 such as @samp{-a/b}. In other words, this is an object which can be
33724 made simpler by calling @code{(- @var{x})}.
33728 Returns true if @var{x} is an integer of any size.
33732 Returns true if @var{x} is a native Lisp integer.
33736 Returns true if @var{x} is a nonnegative integer of any size.
33739 @defun fixnatnump x
33740 Returns true if @var{x} is a nonnegative Lisp integer.
33743 @defun num-integerp x
33744 Returns true if @var{x} is numerically an integer, i.e., either a
33745 true integer or a float with no significant digits to the right of
33749 @defun messy-integerp x
33750 Returns true if @var{x} is numerically, but not literally, an integer.
33751 A value is @code{num-integerp} if it is @code{integerp} or
33752 @code{messy-integerp} (but it is never both at once).
33755 @defun num-natnump x
33756 Returns true if @var{x} is numerically a nonnegative integer.
33760 Returns true if @var{x} is an even integer.
33763 @defun looks-evenp x
33764 Returns true if @var{x} is an even integer, or a formula with a leading
33765 multiplicative coefficient which is an even integer.
33769 Returns true if @var{x} is an odd integer.
33773 Returns true if @var{x} is a rational number, i.e., an integer or a
33778 Returns true if @var{x} is a real number, i.e., an integer, fraction,
33779 or floating-point number.
33783 Returns true if @var{x} is a real number or HMS form.
33787 Returns true if @var{x} is a float, or a complex number, error form,
33788 interval, date form, or modulo form in which at least one component
33793 Returns true if @var{x} is a rectangular or polar complex number
33794 (but not a real number).
33797 @defun rect-complexp x
33798 Returns true if @var{x} is a rectangular complex number.
33801 @defun polar-complexp x
33802 Returns true if @var{x} is a polar complex number.
33806 Returns true if @var{x} is a real number or a complex number.
33810 Returns true if @var{x} is a real or complex number or an HMS form.
33814 Returns true if @var{x} is a vector (this simply checks if its argument
33815 is a list whose first element is the symbol @code{vec}).
33819 Returns true if @var{x} is a number or vector.
33823 Returns true if @var{x} is a matrix, i.e., a vector of one or more vectors,
33824 all of the same size.
33827 @defun square-matrixp x
33828 Returns true if @var{x} is a square matrix.
33832 Returns true if @var{x} is any numeric Calc object, including real and
33833 complex numbers, HMS forms, date forms, error forms, intervals, and
33834 modulo forms. (Note that error forms and intervals may include formulas
33835 as their components; see @code{constp} below.)
33839 Returns true if @var{x} is an object or a vector. This also accepts
33840 incomplete objects, but it rejects variables and formulas (except as
33841 mentioned above for @code{objectp}).
33845 Returns true if @var{x} is a ``primitive'' or ``atomic'' Calc object,
33846 i.e., one whose components cannot be regarded as sub-formulas. This
33847 includes variables, and all @code{objectp} types except error forms
33852 Returns true if @var{x} is constant, i.e., a real or complex number,
33853 HMS form, date form, or error form, interval, or vector all of whose
33854 components are @code{constp}.
33858 Returns true if @var{x} is numerically less than @var{y}. Returns false
33859 if @var{x} is greater than or equal to @var{y}, or if the order is
33860 undefined or cannot be determined. Generally speaking, this works
33861 by checking whether @samp{@var{x} - @var{y}} is @code{negp}. In
33862 @code{defmath}, the expression @samp{(< x y)} will automatically be
33863 converted to @samp{(lessp x y)}; expressions involving @code{>}, @code{<=},
33864 and @code{>=} are similarly converted in terms of @code{lessp}.
33868 Returns true if @var{x} comes before @var{y} in a canonical ordering
33869 of Calc objects. If @var{x} and @var{y} are both real numbers, this
33870 will be the same as @code{lessp}. But whereas @code{lessp} considers
33871 other types of objects to be unordered, @code{beforep} puts any two
33872 objects into a definite, consistent order. The @code{beforep}
33873 function is used by the @kbd{V S} vector-sorting command, and also
33874 by Calc's algebraic simplifications to put the terms of a product into
33875 canonical order: This allows @samp{x y + y x} to be simplified easily to
33880 This is the standard Lisp @code{equal} predicate; it returns true if
33881 @var{x} and @var{y} are structurally identical. This is the usual way
33882 to compare numbers for equality, but note that @code{equal} will treat
33883 0 and 0.0 as different.
33886 @defun math-equal x y
33887 Returns true if @var{x} and @var{y} are numerically equal, either because
33888 they are @code{equal}, or because their difference is @code{zerop}. In
33889 @code{defmath}, the expression @samp{(= x y)} will automatically be
33890 converted to @samp{(math-equal x y)}.
33893 @defun equal-int x n
33894 Returns true if @var{x} and @var{n} are numerically equal, where @var{n}
33895 is a fixnum which is not a multiple of 10. This will automatically be
33896 used by @code{defmath} in place of the more general @code{math-equal}
33900 @defun nearly-equal x y
33901 Returns true if @var{x} and @var{y}, as floating-point numbers, are
33902 equal except possibly in the last decimal place. For example,
33903 314.159 and 314.166 are considered nearly equal if the current
33904 precision is 6 (since they differ by 7 units), but not if the current
33905 precision is 7 (since they differ by 70 units). Most functions which
33906 use series expansions use @code{with-extra-prec} to evaluate the
33907 series with 2 extra digits of precision, then use @code{nearly-equal}
33908 to decide when the series has converged; this guards against cumulative
33909 error in the series evaluation without doing extra work which would be
33910 lost when the result is rounded back down to the current precision.
33911 In @code{defmath}, this can be written @samp{(~= @var{x} @var{y})}.
33912 The @var{x} and @var{y} can be numbers of any kind, including complex.
33915 @defun nearly-zerop x y
33916 Returns true if @var{x} is nearly zero, compared to @var{y}. This
33917 checks whether @var{x} plus @var{y} would by be @code{nearly-equal}
33918 to @var{y} itself, to within the current precision, in other words,
33919 if adding @var{x} to @var{y} would have a negligible effect on @var{y}
33920 due to roundoff error. @var{X} may be a real or complex number, but
33921 @var{y} must be real.
33925 Return true if the formula @var{x} represents a true value in
33926 Calc, not Lisp, terms. It tests if @var{x} is a non-zero number
33927 or a provably non-zero formula.
33930 @defun reject-arg val pred
33931 Abort the current function evaluation due to unacceptable argument values.
33932 This calls @samp{(calc-record-why @var{pred} @var{val})}, then signals a
33933 Lisp error which @code{normalize} will trap. The net effect is that the
33934 function call which led here will be left in symbolic form.
33937 @defun inexact-value
33938 If Symbolic mode is enabled, this will signal an error that causes
33939 @code{normalize} to leave the formula in symbolic form, with the message
33940 ``Inexact result.'' (This function has no effect when not in Symbolic mode.)
33941 Note that if your function calls @samp{(sin 5)} in Symbolic mode, the
33942 @code{sin} function will call @code{inexact-value}, which will cause your
33943 function to be left unsimplified. You may instead wish to call
33944 @samp{(normalize (list 'calcFunc-sin 5))}, which in Symbolic mode will
33945 return the formula @samp{sin(5)} to your function.
33949 This signals an error that will be reported as a floating-point overflow.
33953 This signals a floating-point underflow.
33956 @node Computational Lisp Functions, Vector Lisp Functions, Predicates, Internals
33957 @subsubsection Computational Functions
33960 The functions described here do the actual computational work of the
33961 Calculator. In addition to these, note that any function described in
33962 the main body of this manual may be called from Lisp; for example, if
33963 the documentation refers to the @code{calc-sqrt} [@code{sqrt}] command,
33964 this means @code{calc-sqrt} is an interactive stack-based square-root
33965 command and @code{sqrt} (which @code{defmath} expands to @code{calcFunc-sqrt})
33966 is the actual Lisp function for taking square roots.
33968 The functions @code{math-add}, @code{math-sub}, @code{math-mul},
33969 @code{math-div}, @code{math-mod}, and @code{math-neg} are not included
33970 in this list, since @code{defmath} allows you to write native Lisp
33971 @code{+}, @code{-}, @code{*}, @code{/}, @code{%}, and unary @code{-},
33972 respectively, instead.
33974 @defun normalize val
33975 (Full form: @code{math-normalize}.)
33976 Reduce the value @var{val} to standard form. For example, if @var{val}
33977 is a fixnum, it will be converted to a bignum if it is too large, and
33978 if @var{val} is a bignum it will be normalized by clipping off trailing
33979 (i.e., most-significant) zero digits and converting to a fixnum if it is
33980 small. All the various data types are similarly converted to their standard
33981 forms. Variables are left alone, but function calls are actually evaluated
33982 in formulas. For example, normalizing @samp{(+ 2 (calcFunc-abs -4))} will
33985 If a function call fails, because the function is void or has the wrong
33986 number of parameters, or because it returns @code{nil} or calls
33987 @code{reject-arg} or @code{inexact-result}, @code{normalize} returns
33988 the formula still in symbolic form.
33990 If the current simplification mode is ``none'' or ``numeric arguments
33991 only,'' @code{normalize} will act appropriately. However, the more
33992 powerful simplification modes (like Algebraic Simplification) are
33993 not handled by @code{normalize}. They are handled by @code{calc-normalize},
33994 which calls @code{normalize} and possibly some other routines, such
33995 as @code{simplify} or @code{simplify-units}. Programs generally will
33996 never call @code{calc-normalize} except when popping or pushing values
34000 @defun evaluate-expr expr
34001 Replace all variables in @var{expr} that have values with their values,
34002 then use @code{normalize} to simplify the result. This is what happens
34003 when you press the @kbd{=} key interactively.
34006 @defmac with-extra-prec n body
34007 Evaluate the Lisp forms in @var{body} with precision increased by @var{n}
34008 digits. This is a macro which expands to
34012 (let ((calc-internal-prec (+ calc-internal-prec @var{n})))
34016 The surrounding call to @code{math-normalize} causes a floating-point
34017 result to be rounded down to the original precision afterwards. This
34018 is important because some arithmetic operations assume a number's
34019 mantissa contains no more digits than the current precision allows.
34022 @defun make-frac n d
34023 Build a fraction @samp{@var{n}:@var{d}}. This is equivalent to calling
34024 @samp{(normalize (list 'frac @var{n} @var{d}))}, but more efficient.
34027 @defun make-float mant exp
34028 Build a floating-point value out of @var{mant} and @var{exp}, both
34029 of which are arbitrary integers. This function will return a
34030 properly normalized float value, or signal an overflow or underflow
34031 if @var{exp} is out of range.
34034 @defun make-sdev x sigma
34035 Build an error form out of @var{x} and the absolute value of @var{sigma}.
34036 If @var{sigma} is zero, the result is the number @var{x} directly.
34037 If @var{sigma} is negative or complex, its absolute value is used.
34038 If @var{x} or @var{sigma} is not a valid type of object for use in
34039 error forms, this calls @code{reject-arg}.
34042 @defun make-intv mask lo hi
34043 Build an interval form out of @var{mask} (which is assumed to be an
34044 integer from 0 to 3), and the limits @var{lo} and @var{hi}. If
34045 @var{lo} is greater than @var{hi}, an empty interval form is returned.
34046 This calls @code{reject-arg} if @var{lo} or @var{hi} is unsuitable.
34049 @defun sort-intv mask lo hi
34050 Build an interval form, similar to @code{make-intv}, except that if
34051 @var{lo} is less than @var{hi} they are simply exchanged, and the
34052 bits of @var{mask} are swapped accordingly.
34055 @defun make-mod n m
34056 Build a modulo form out of @var{n} and the modulus @var{m}. Since modulo
34057 forms do not allow formulas as their components, if @var{n} or @var{m}
34058 is not a real number or HMS form the result will be a formula which
34059 is a call to @code{makemod}, the algebraic version of this function.
34063 Convert @var{x} to floating-point form. Integers and fractions are
34064 converted to numerically equivalent floats; components of complex
34065 numbers, vectors, HMS forms, date forms, error forms, intervals, and
34066 modulo forms are recursively floated. If the argument is a variable
34067 or formula, this calls @code{reject-arg}.
34071 Compare the numbers @var{x} and @var{y}, and return @mathit{-1} if
34072 @samp{(lessp @var{x} @var{y})}, 1 if @samp{(lessp @var{y} @var{x})},
34073 0 if @samp{(math-equal @var{x} @var{y})}, or 2 if the order is
34074 undefined or cannot be determined.
34078 Return the number of digits of integer @var{n}, effectively
34079 @samp{ceil(log10(@var{n}))}, but much more efficient. Zero is
34080 considered to have zero digits.
34083 @defun scale-int x n
34084 Shift integer @var{x} left @var{n} decimal digits, or right @mathit{-@var{n}}
34085 digits with truncation toward zero.
34088 @defun scale-rounding x n
34089 Like @code{scale-int}, except that a right shift rounds to the nearest
34090 integer rather than truncating.
34094 Return the integer @var{n} as a fixnum, i.e., a native Lisp integer.
34095 If @var{n} is outside the permissible range for Lisp integers (usually
34096 24 binary bits) the result is undefined.
34100 Compute the square of @var{x}; short for @samp{(* @var{x} @var{x})}.
34103 @defun quotient x y
34104 Divide integer @var{x} by integer @var{y}; return an integer quotient
34105 and discard the remainder. If @var{x} or @var{y} is negative, the
34106 direction of rounding is undefined.
34110 Perform an integer division; if @var{x} and @var{y} are both nonnegative
34111 integers, this uses the @code{quotient} function, otherwise it computes
34112 @samp{floor(@var{x}/@var{y})}. Thus the result is well-defined but
34113 slower than for @code{quotient}.
34117 Divide integer @var{x} by integer @var{y}; return the integer remainder
34118 and discard the quotient. Like @code{quotient}, this works only for
34119 integer arguments and is not well-defined for negative arguments.
34120 For a more well-defined result, use @samp{(% @var{x} @var{y})}.
34124 Divide integer @var{x} by integer @var{y}; return a cons cell whose
34125 @code{car} is @samp{(quotient @var{x} @var{y})} and whose @code{cdr}
34126 is @samp{(imod @var{x} @var{y})}.
34130 Compute @var{x} to the power @var{y}. In @code{defmath} code, this can
34131 also be written @samp{(^ @var{x} @var{y})} or
34132 @w{@samp{(expt @var{x} @var{y})}}.
34135 @defun abs-approx x
34136 Compute a fast approximation to the absolute value of @var{x}. For
34137 example, for a rectangular complex number the result is the sum of
34138 the absolute values of the components.
34142 @findex gamma-const
34148 @findex pi-over-180
34149 @findex sqrt-two-pi
34153 The function @samp{(pi)} computes @samp{pi} to the current precision.
34154 Other related constant-generating functions are @code{two-pi},
34155 @code{pi-over-2}, @code{pi-over-4}, @code{pi-over-180}, @code{sqrt-two-pi},
34156 @code{e}, @code{sqrt-e}, @code{ln-2}, @code{ln-10}, @code{phi} and
34157 @code{gamma-const}. Each function returns a floating-point value in the
34158 current precision, and each uses caching so that all calls after the
34159 first are essentially free.
34162 @defmac math-defcache @var{func} @var{initial} @var{form}
34163 This macro, usually used as a top-level call like @code{defun} or
34164 @code{defvar}, defines a new cached constant analogous to @code{pi}, etc.
34165 It defines a function @code{func} which returns the requested value;
34166 if @var{initial} is non-@code{nil} it must be a @samp{(float @dots{})}
34167 form which serves as an initial value for the cache. If @var{func}
34168 is called when the cache is empty or does not have enough digits to
34169 satisfy the current precision, the Lisp expression @var{form} is evaluated
34170 with the current precision increased by four, and the result minus its
34171 two least significant digits is stored in the cache. For example,
34172 calling @samp{(pi)} with a precision of 30 computes @samp{pi} to 34
34173 digits, rounds it down to 32 digits for future use, then rounds it
34174 again to 30 digits for use in the present request.
34177 @findex half-circle
34178 @findex quarter-circle
34179 @defun full-circle symb
34180 If the current angular mode is Degrees or HMS, this function returns the
34181 integer 360. In Radians mode, this function returns either the
34182 corresponding value in radians to the current precision, or the formula
34183 @samp{2*pi}, depending on the Symbolic mode. There are also similar
34184 function @code{half-circle} and @code{quarter-circle}.
34187 @defun power-of-2 n
34188 Compute two to the integer power @var{n}, as a (potentially very large)
34189 integer. Powers of two are cached, so only the first call for a
34190 particular @var{n} is expensive.
34193 @defun integer-log2 n
34194 Compute the base-2 logarithm of @var{n}, which must be an integer which
34195 is a power of two. If @var{n} is not a power of two, this function will
34199 @defun div-mod a b m
34200 Divide @var{a} by @var{b}, modulo @var{m}. This returns @code{nil} if
34201 there is no solution, or if any of the arguments are not integers.
34204 @defun pow-mod a b m
34205 Compute @var{a} to the power @var{b}, modulo @var{m}. If @var{a},
34206 @var{b}, and @var{m} are integers, this uses an especially efficient
34207 algorithm. Otherwise, it simply computes @samp{(% (^ a b) m)}.
34211 Compute the integer square root of @var{n}. This is the square root
34212 of @var{n} rounded down toward zero, i.e., @samp{floor(sqrt(@var{n}))}.
34213 If @var{n} is itself an integer, the computation is especially efficient.
34216 @defun to-hms a ang
34217 Convert the argument @var{a} into an HMS form. If @var{ang} is specified,
34218 it is the angular mode in which to interpret @var{a}, either @code{deg}
34219 or @code{rad}. Otherwise, the current angular mode is used. If @var{a}
34220 is already an HMS form it is returned as-is.
34223 @defun from-hms a ang
34224 Convert the HMS form @var{a} into a real number. If @var{ang} is specified,
34225 it is the angular mode in which to express the result, otherwise the
34226 current angular mode is used. If @var{a} is already a real number, it
34230 @defun to-radians a
34231 Convert the number or HMS form @var{a} to radians from the current
34235 @defun from-radians a
34236 Convert the number @var{a} from radians to the current angular mode.
34237 If @var{a} is a formula, this returns the formula @samp{deg(@var{a})}.
34240 @defun to-radians-2 a
34241 Like @code{to-radians}, except that in Symbolic mode a degrees to
34242 radians conversion yields a formula like @samp{@var{a}*pi/180}.
34245 @defun from-radians-2 a
34246 Like @code{from-radians}, except that in Symbolic mode a radians to
34247 degrees conversion yields a formula like @samp{@var{a}*180/pi}.
34250 @defun random-digit
34251 Produce a random base-1000 digit in the range 0 to 999.
34254 @defun random-digits n
34255 Produce a random @var{n}-digit integer; this will be an integer
34256 in the interval @samp{[0, 10^@var{n})}.
34259 @defun random-float
34260 Produce a random float in the interval @samp{[0, 1)}.
34263 @defun prime-test n iters
34264 Determine whether the integer @var{n} is prime. Return a list which has
34265 one of these forms: @samp{(nil @var{f})} means the number is non-prime
34266 because it was found to be divisible by @var{f}; @samp{(nil)} means it
34267 was found to be non-prime by table look-up (so no factors are known);
34268 @samp{(nil unknown)} means it is definitely non-prime but no factors
34269 are known because @var{n} was large enough that Fermat's probabilistic
34270 test had to be used; @samp{(t)} means the number is definitely prime;
34271 and @samp{(maybe @var{i} @var{p})} means that Fermat's test, after @var{i}
34272 iterations, is @var{p} percent sure that the number is prime. The
34273 @var{iters} parameter is the number of Fermat iterations to use, in the
34274 case that this is necessary. If @code{prime-test} returns ``maybe,''
34275 you can call it again with the same @var{n} to get a greater certainty;
34276 @code{prime-test} remembers where it left off.
34279 @defun to-simple-fraction f
34280 If @var{f} is a floating-point number which can be represented exactly
34281 as a small rational number. return that number, else return @var{f}.
34282 For example, 0.75 would be converted to 3:4. This function is very
34286 @defun to-fraction f tol
34287 Find a rational approximation to floating-point number @var{f} to within
34288 a specified tolerance @var{tol}; this corresponds to the algebraic
34289 function @code{frac}, and can be rather slow.
34292 @defun quarter-integer n
34293 If @var{n} is an integer or integer-valued float, this function
34294 returns zero. If @var{n} is a half-integer (i.e., an integer plus
34295 @mathit{1:2} or 0.5), it returns 2. If @var{n} is a quarter-integer,
34296 it returns 1 or 3. If @var{n} is anything else, this function
34297 returns @code{nil}.
34300 @node Vector Lisp Functions, Symbolic Lisp Functions, Computational Lisp Functions, Internals
34301 @subsubsection Vector Functions
34304 The functions described here perform various operations on vectors and
34307 @defun math-concat x y
34308 Do a vector concatenation; this operation is written @samp{@var{x} | @var{y}}
34309 in a symbolic formula. @xref{Building Vectors}.
34312 @defun vec-length v
34313 Return the length of vector @var{v}. If @var{v} is not a vector, the
34314 result is zero. If @var{v} is a matrix, this returns the number of
34315 rows in the matrix.
34318 @defun mat-dimens m
34319 Determine the dimensions of vector or matrix @var{m}. If @var{m} is not
34320 a vector, the result is an empty list. If @var{m} is a plain vector
34321 but not a matrix, the result is a one-element list containing the length
34322 of the vector. If @var{m} is a matrix with @var{r} rows and @var{c} columns,
34323 the result is the list @samp{(@var{r} @var{c})}. Higher-order tensors
34324 produce lists of more than two dimensions. Note that the object
34325 @samp{[[1, 2, 3], [4, 5]]} is a vector of vectors not all the same size,
34326 and is treated by this and other Calc routines as a plain vector of two
34330 @defun dimension-error
34331 Abort the current function with a message of ``Dimension error.''
34332 The Calculator will leave the function being evaluated in symbolic
34333 form; this is really just a special case of @code{reject-arg}.
34336 @defun build-vector args
34337 Return a Calc vector with @var{args} as elements.
34338 For example, @samp{(build-vector 1 2 3)} returns the Calc vector
34339 @samp{[1, 2, 3]}, stored internally as the list @samp{(vec 1 2 3)}.
34342 @defun make-vec obj dims
34343 Return a Calc vector or matrix all of whose elements are equal to
34344 @var{obj}. For example, @samp{(make-vec 27 3 4)} returns a 3x4 matrix
34348 @defun row-matrix v
34349 If @var{v} is a plain vector, convert it into a row matrix, i.e.,
34350 a matrix whose single row is @var{v}. If @var{v} is already a matrix,
34354 @defun col-matrix v
34355 If @var{v} is a plain vector, convert it into a column matrix, i.e., a
34356 matrix with each element of @var{v} as a separate row. If @var{v} is
34357 already a matrix, leave it alone.
34361 Map the Lisp function @var{f} over the Calc vector @var{v}. For example,
34362 @samp{(map-vec 'math-floor v)} returns a vector of the floored components
34366 @defun map-vec-2 f a b
34367 Map the Lisp function @var{f} over the two vectors @var{a} and @var{b}.
34368 If @var{a} and @var{b} are vectors of equal length, the result is a
34369 vector of the results of calling @samp{(@var{f} @var{ai} @var{bi})}
34370 for each pair of elements @var{ai} and @var{bi}. If either @var{a} or
34371 @var{b} is a scalar, it is matched with each value of the other vector.
34372 For example, @samp{(map-vec-2 'math-add v 1)} returns the vector @var{v}
34373 with each element increased by one. Note that using @samp{'+} would not
34374 work here, since @code{defmath} does not expand function names everywhere,
34375 just where they are in the function position of a Lisp expression.
34378 @defun reduce-vec f v
34379 Reduce the function @var{f} over the vector @var{v}. For example, if
34380 @var{v} is @samp{[10, 20, 30, 40]}, this calls @samp{(f (f (f 10 20) 30) 40)}.
34381 If @var{v} is a matrix, this reduces over the rows of @var{v}.
34384 @defun reduce-cols f m
34385 Reduce the function @var{f} over the columns of matrix @var{m}. For
34386 example, if @var{m} is @samp{[[1, 2], [3, 4], [5, 6]]}, the result
34387 is a vector of the two elements @samp{(f (f 1 3) 5)} and @samp{(f (f 2 4) 6)}.
34391 Return the @var{n}th row of matrix @var{m}. This is equivalent to
34392 @samp{(elt m n)}. For a slower but safer version, use @code{mrow}.
34393 (@xref{Extracting Elements}.)
34397 Return the @var{n}th column of matrix @var{m}, in the form of a vector.
34398 The arguments are not checked for correctness.
34401 @defun mat-less-row m n
34402 Return a copy of matrix @var{m} with its @var{n}th row deleted. The
34403 number @var{n} must be in range from 1 to the number of rows in @var{m}.
34406 @defun mat-less-col m n
34407 Return a copy of matrix @var{m} with its @var{n}th column deleted.
34411 Return the transpose of matrix @var{m}.
34414 @defun flatten-vector v
34415 Flatten nested vector @var{v} into a vector of scalars. For example,
34416 if @var{v} is @samp{[[1, 2, 3], [4, 5]]} the result is @samp{[1, 2, 3, 4, 5]}.
34419 @defun copy-matrix m
34420 If @var{m} is a matrix, return a copy of @var{m}. This maps
34421 @code{copy-sequence} over the rows of @var{m}; in Lisp terms, each
34422 element of the result matrix will be @code{eq} to the corresponding
34423 element of @var{m}, but none of the @code{cons} cells that make up
34424 the structure of the matrix will be @code{eq}. If @var{m} is a plain
34425 vector, this is the same as @code{copy-sequence}.
34428 @defun swap-rows m r1 r2
34429 Exchange rows @var{r1} and @var{r2} of matrix @var{m} in-place. In
34430 other words, unlike most of the other functions described here, this
34431 function changes @var{m} itself rather than building up a new result
34432 matrix. The return value is @var{m}, i.e., @samp{(eq (swap-rows m 1 2) m)}
34433 is true, with the side effect of exchanging the first two rows of
34437 @node Symbolic Lisp Functions, Formatting Lisp Functions, Vector Lisp Functions, Internals
34438 @subsubsection Symbolic Functions
34441 The functions described here operate on symbolic formulas in the
34444 @defun calc-prepare-selection num
34445 Prepare a stack entry for selection operations. If @var{num} is
34446 omitted, the stack entry containing the cursor is used; otherwise,
34447 it is the number of the stack entry to use. This function stores
34448 useful information about the current stack entry into a set of
34449 variables. @code{calc-selection-cache-num} contains the number of
34450 the stack entry involved (equal to @var{num} if you specified it);
34451 @code{calc-selection-cache-entry} contains the stack entry as a
34452 list (such as @code{calc-top-list} would return with @code{entry}
34453 as the selection mode); and @code{calc-selection-cache-comp} contains
34454 a special ``tagged'' composition (@pxref{Formatting Lisp Functions})
34455 which allows Calc to relate cursor positions in the buffer with
34456 their corresponding sub-formulas.
34458 A slight complication arises in the selection mechanism because
34459 formulas may contain small integers. For example, in the vector
34460 @samp{[1, 2, 1]} the first and last elements are @code{eq} to each
34461 other; selections are recorded as the actual Lisp object that
34462 appears somewhere in the tree of the whole formula, but storing
34463 @code{1} would falsely select both @code{1}'s in the vector. So
34464 @code{calc-prepare-selection} also checks the stack entry and
34465 replaces any plain integers with ``complex number'' lists of the form
34466 @samp{(cplx @var{n} 0)}. This list will be displayed the same as a
34467 plain @var{n} and the change will be completely invisible to the
34468 user, but it will guarantee that no two sub-formulas of the stack
34469 entry will be @code{eq} to each other. Next time the stack entry
34470 is involved in a computation, @code{calc-normalize} will replace
34471 these lists with plain numbers again, again invisibly to the user.
34474 @defun calc-encase-atoms x
34475 This modifies the formula @var{x} to ensure that each part of the
34476 formula is a unique atom, using the @samp{(cplx @var{n} 0)} trick
34477 described above. This function may use @code{setcar} to modify
34478 the formula in-place.
34481 @defun calc-find-selected-part
34482 Find the smallest sub-formula of the current formula that contains
34483 the cursor. This assumes @code{calc-prepare-selection} has been
34484 called already. If the cursor is not actually on any part of the
34485 formula, this returns @code{nil}.
34488 @defun calc-change-current-selection selection
34489 Change the currently prepared stack element's selection to
34490 @var{selection}, which should be @code{eq} to some sub-formula
34491 of the stack element, or @code{nil} to unselect the formula.
34492 The stack element's appearance in the Calc buffer is adjusted
34493 to reflect the new selection.
34496 @defun calc-find-nth-part expr n
34497 Return the @var{n}th sub-formula of @var{expr}. This function is used
34498 by the selection commands, and (unless @kbd{j b} has been used) treats
34499 sums and products as flat many-element formulas. Thus if @var{expr}
34500 is @samp{((a + b) - c) + d}, calling @code{calc-find-nth-part} with
34501 @var{n} equal to four will return @samp{d}.
34504 @defun calc-find-parent-formula expr part
34505 Return the sub-formula of @var{expr} which immediately contains
34506 @var{part}. If @var{expr} is @samp{a*b + (c+1)*d} and @var{part}
34507 is @code{eq} to the @samp{c+1} term of @var{expr}, then this function
34508 will return @samp{(c+1)*d}. If @var{part} turns out not to be a
34509 sub-formula of @var{expr}, the function returns @code{nil}. If
34510 @var{part} is @code{eq} to @var{expr}, the function returns @code{t}.
34511 This function does not take associativity into account.
34514 @defun calc-find-assoc-parent-formula expr part
34515 This is the same as @code{calc-find-parent-formula}, except that
34516 (unless @kbd{j b} has been used) it continues widening the selection
34517 to contain a complete level of the formula. Given @samp{a} from
34518 @samp{((a + b) - c) + d}, @code{calc-find-parent-formula} will
34519 return @samp{a + b} but @code{calc-find-assoc-parent-formula} will
34520 return the whole expression.
34523 @defun calc-grow-assoc-formula expr part
34524 This expands sub-formula @var{part} of @var{expr} to encompass a
34525 complete level of the formula. If @var{part} and its immediate
34526 parent are not compatible associative operators, or if @kbd{j b}
34527 has been used, this simply returns @var{part}.
34530 @defun calc-find-sub-formula expr part
34531 This finds the immediate sub-formula of @var{expr} which contains
34532 @var{part}. It returns an index @var{n} such that
34533 @samp{(calc-find-nth-part @var{expr} @var{n})} would return @var{part}.
34534 If @var{part} is not a sub-formula of @var{expr}, it returns @code{nil}.
34535 If @var{part} is @code{eq} to @var{expr}, it returns @code{t}. This
34536 function does not take associativity into account.
34539 @defun calc-replace-sub-formula expr old new
34540 This function returns a copy of formula @var{expr}, with the
34541 sub-formula that is @code{eq} to @var{old} replaced by @var{new}.
34544 @defun simplify expr
34545 Simplify the expression @var{expr} by applying Calc's algebraic
34546 simplifications. This always returns a copy of the expression; the
34547 structure @var{expr} points to remains unchanged in memory.
34549 More precisely, here is what @code{simplify} does: The expression is
34550 first normalized and evaluated by calling @code{normalize}. If any
34551 @code{AlgSimpRules} have been defined, they are then applied. Then
34552 the expression is traversed in a depth-first, bottom-up fashion; at
34553 each level, any simplifications that can be made are made until no
34554 further changes are possible. Once the entire formula has been
34555 traversed in this way, it is compared with the original formula (from
34556 before the call to @code{normalize}) and, if it has changed,
34557 the entire procedure is repeated (starting with @code{normalize})
34558 until no further changes occur. Usually only two iterations are
34559 needed: one to simplify the formula, and another to verify that no
34560 further simplifications were possible.
34563 @defun simplify-extended expr
34564 Simplify the expression @var{expr}, with additional rules enabled that
34565 help do a more thorough job, while not being entirely ``safe'' in all
34566 circumstances. (For example, this mode will simplify @samp{sqrt(x^2)}
34567 to @samp{x}, which is only valid when @var{x} is positive.) This is
34568 implemented by temporarily binding the variable @code{math-living-dangerously}
34569 to @code{t} (using a @code{let} form) and calling @code{simplify}.
34570 Dangerous simplification rules are written to check this variable
34571 before taking any action.
34574 @defun simplify-units expr
34575 Simplify the expression @var{expr}, treating variable names as units
34576 whenever possible. This works by binding the variable
34577 @code{math-simplifying-units} to @code{t} while calling @code{simplify}.
34580 @defmac math-defsimplify funcs body
34581 Register a new simplification rule; this is normally called as a top-level
34582 form, like @code{defun} or @code{defmath}. If @var{funcs} is a symbol
34583 (like @code{+} or @code{calcFunc-sqrt}), this simplification rule is
34584 applied to the formulas which are calls to the specified function. Or,
34585 @var{funcs} can be a list of such symbols; the rule applies to all
34586 functions on the list. The @var{body} is written like the body of a
34587 function with a single argument called @code{expr}. The body will be
34588 executed with @code{expr} bound to a formula which is a call to one of
34589 the functions @var{funcs}. If the function body returns @code{nil}, or
34590 if it returns a result @code{equal} to the original @code{expr}, it is
34591 ignored and Calc goes on to try the next simplification rule that applies.
34592 If the function body returns something different, that new formula is
34593 substituted for @var{expr} in the original formula.
34595 At each point in the formula, rules are tried in the order of the
34596 original calls to @code{math-defsimplify}; the search stops after the
34597 first rule that makes a change. Thus later rules for that same
34598 function will not have a chance to trigger until the next iteration
34599 of the main @code{simplify} loop.
34601 Note that, since @code{defmath} is not being used here, @var{body} must
34602 be written in true Lisp code without the conveniences that @code{defmath}
34603 provides. If you prefer, you can have @var{body} simply call another
34604 function (defined with @code{defmath}) which does the real work.
34606 The arguments of a function call will already have been simplified
34607 before any rules for the call itself are invoked. Since a new argument
34608 list is consed up when this happens, this means that the rule's body is
34609 allowed to rearrange the function's arguments destructively if that is
34610 convenient. Here is a typical example of a simplification rule:
34613 (math-defsimplify calcFunc-arcsinh
34614 (or (and (math-looks-negp (nth 1 expr))
34615 (math-neg (list 'calcFunc-arcsinh
34616 (math-neg (nth 1 expr)))))
34617 (and (eq (car-safe (nth 1 expr)) 'calcFunc-sinh)
34618 (or math-living-dangerously
34619 (math-known-realp (nth 1 (nth 1 expr))))
34620 (nth 1 (nth 1 expr)))))
34623 This is really a pair of rules written with one @code{math-defsimplify}
34624 for convenience; the first replaces @samp{arcsinh(-x)} with
34625 @samp{-arcsinh(x)}, and the second, which is safe only for real @samp{x},
34626 replaces @samp{arcsinh(sinh(x))} with @samp{x}.
34629 @defun common-constant-factor expr
34630 Check @var{expr} to see if it is a sum of terms all multiplied by the
34631 same rational value. If so, return this value. If not, return @code{nil}.
34632 For example, if called on @samp{6x + 9y + 12z}, it would return 3, since
34633 3 is a common factor of all the terms.
34636 @defun cancel-common-factor expr factor
34637 Assuming @var{expr} is a sum with @var{factor} as a common factor,
34638 divide each term of the sum by @var{factor}. This is done by
34639 destructively modifying parts of @var{expr}, on the assumption that
34640 it is being used by a simplification rule (where such things are
34641 allowed; see above). For example, consider this built-in rule for
34645 (math-defsimplify calcFunc-sqrt
34646 (let ((fac (math-common-constant-factor (nth 1 expr))))
34647 (and fac (not (eq fac 1))
34648 (math-mul (math-normalize (list 'calcFunc-sqrt fac))
34650 (list 'calcFunc-sqrt
34651 (math-cancel-common-factor
34652 (nth 1 expr) fac)))))))
34656 @defun frac-gcd a b
34657 Compute a ``rational GCD'' of @var{a} and @var{b}, which must both be
34658 rational numbers. This is the fraction composed of the GCD of the
34659 numerators of @var{a} and @var{b}, over the GCD of the denominators.
34660 It is used by @code{common-constant-factor}. Note that the standard
34661 @code{gcd} function uses the LCM to combine the denominators.
34664 @defun map-tree func expr many
34665 Try applying Lisp function @var{func} to various sub-expressions of
34666 @var{expr}. Initially, call @var{func} with @var{expr} itself as an
34667 argument. If this returns an expression which is not @code{equal} to
34668 @var{expr}, apply @var{func} again until eventually it does return
34669 @var{expr} with no changes. Then, if @var{expr} is a function call,
34670 recursively apply @var{func} to each of the arguments. This keeps going
34671 until no changes occur anywhere in the expression; this final expression
34672 is returned by @code{map-tree}. Note that, unlike simplification rules,
34673 @var{func} functions may @emph{not} make destructive changes to
34674 @var{expr}. If a third argument @var{many} is provided, it is an
34675 integer which says how many times @var{func} may be applied; the
34676 default, as described above, is infinitely many times.
34679 @defun compile-rewrites rules
34680 Compile the rewrite rule set specified by @var{rules}, which should
34681 be a formula that is either a vector or a variable name. If the latter,
34682 the compiled rules are saved so that later @code{compile-rules} calls
34683 for that same variable can return immediately. If there are problems
34684 with the rules, this function calls @code{error} with a suitable
34688 @defun apply-rewrites expr crules heads
34689 Apply the compiled rewrite rule set @var{crules} to the expression
34690 @var{expr}. This will make only one rewrite and only checks at the
34691 top level of the expression. The result @code{nil} if no rules
34692 matched, or if the only rules that matched did not actually change
34693 the expression. The @var{heads} argument is optional; if is given,
34694 it should be a list of all function names that (may) appear in
34695 @var{expr}. The rewrite compiler tags each rule with the
34696 rarest-looking function name in the rule; if you specify @var{heads},
34697 @code{apply-rewrites} can use this information to narrow its search
34698 down to just a few rules in the rule set.
34701 @defun rewrite-heads expr
34702 Compute a @var{heads} list for @var{expr} suitable for use with
34703 @code{apply-rewrites}, as discussed above.
34706 @defun rewrite expr rules many
34707 This is an all-in-one rewrite function. It compiles the rule set
34708 specified by @var{rules}, then uses @code{map-tree} to apply the
34709 rules throughout @var{expr} up to @var{many} (default infinity)
34713 @defun match-patterns pat vec not-flag
34714 Given a Calc vector @var{vec} and an uncompiled pattern set or
34715 pattern set variable @var{pat}, this function returns a new vector
34716 of all elements of @var{vec} which do (or don't, if @var{not-flag} is
34717 non-@code{nil}) match any of the patterns in @var{pat}.
34720 @defun deriv expr var value symb
34721 Compute the derivative of @var{expr} with respect to variable @var{var}
34722 (which may actually be any sub-expression). If @var{value} is specified,
34723 the derivative is evaluated at the value of @var{var}; otherwise, the
34724 derivative is left in terms of @var{var}. If the expression contains
34725 functions for which no derivative formula is known, new derivative
34726 functions are invented by adding primes to the names; @pxref{Calculus}.
34727 However, if @var{symb} is non-@code{nil}, the presence of nondifferentiable
34728 functions in @var{expr} instead cancels the whole differentiation, and
34729 @code{deriv} returns @code{nil} instead.
34731 Derivatives of an @var{n}-argument function can be defined by
34732 adding a @code{math-derivative-@var{n}} property to the property list
34733 of the symbol for the function's derivative, which will be the
34734 function name followed by an apostrophe. The value of the property
34735 should be a Lisp function; it is called with the same arguments as the
34736 original function call that is being differentiated. It should return
34737 a formula for the derivative. For example, the derivative of @code{ln}
34741 (put 'calcFunc-ln\' 'math-derivative-1
34742 (function (lambda (u) (math-div 1 u))))
34745 The two-argument @code{log} function has two derivatives,
34747 (put 'calcFunc-log\' 'math-derivative-2 ; d(log(x,b)) / dx
34748 (function (lambda (x b) ... )))
34749 (put 'calcFunc-log\'2 'math-derivative-2 ; d(log(x,b)) / db
34750 (function (lambda (x b) ... )))
34754 @defun tderiv expr var value symb
34755 Compute the total derivative of @var{expr}. This is the same as
34756 @code{deriv}, except that variables other than @var{var} are not
34757 assumed to be constant with respect to @var{var}.
34760 @defun integ expr var low high
34761 Compute the integral of @var{expr} with respect to @var{var}.
34762 @xref{Calculus}, for further details.
34765 @defmac math-defintegral funcs body
34766 Define a rule for integrating a function or functions of one argument;
34767 this macro is very similar in format to @code{math-defsimplify}.
34768 The main difference is that here @var{body} is the body of a function
34769 with a single argument @code{u} which is bound to the argument to the
34770 function being integrated, not the function call itself. Also, the
34771 variable of integration is available as @code{math-integ-var}. If
34772 evaluation of the integral requires doing further integrals, the body
34773 should call @samp{(math-integral @var{x})} to find the integral of
34774 @var{x} with respect to @code{math-integ-var}; this function returns
34775 @code{nil} if the integral could not be done. Some examples:
34778 (math-defintegral calcFunc-conj
34779 (let ((int (math-integral u)))
34781 (list 'calcFunc-conj int))))
34783 (math-defintegral calcFunc-cos
34784 (and (equal u math-integ-var)
34785 (math-from-radians-2 (list 'calcFunc-sin u))))
34788 In the @code{cos} example, we define only the integral of @samp{cos(x) dx},
34789 relying on the general integration-by-substitution facility to handle
34790 cosines of more complicated arguments. An integration rule should return
34791 @code{nil} if it can't do the integral; if several rules are defined for
34792 the same function, they are tried in order until one returns a non-@code{nil}
34796 @defmac math-defintegral-2 funcs body
34797 Define a rule for integrating a function or functions of two arguments.
34798 This is exactly analogous to @code{math-defintegral}, except that @var{body}
34799 is written as the body of a function with two arguments, @var{u} and
34803 @defun solve-for lhs rhs var full
34804 Attempt to solve the equation @samp{@var{lhs} = @var{rhs}} by isolating
34805 the variable @var{var} on the lefthand side; return the resulting righthand
34806 side, or @code{nil} if the equation cannot be solved. The variable
34807 @var{var} must appear at least once in @var{lhs} or @var{rhs}. Note that
34808 the return value is a formula which does not contain @var{var}; this is
34809 different from the user-level @code{solve} and @code{finv} functions,
34810 which return a rearranged equation or a functional inverse, respectively.
34811 If @var{full} is non-@code{nil}, a full solution including dummy signs
34812 and dummy integers will be produced. User-defined inverses are provided
34813 as properties in a manner similar to derivatives:
34816 (put 'calcFunc-ln 'math-inverse
34817 (function (lambda (x) (list 'calcFunc-exp x))))
34820 This function can call @samp{(math-solve-get-sign @var{x})} to create
34821 a new arbitrary sign variable, returning @var{x} times that sign, and
34822 @samp{(math-solve-get-int @var{x})} to create a new arbitrary integer
34823 variable multiplied by @var{x}. These functions simply return @var{x}
34824 if the caller requested a non-``full'' solution.
34827 @defun solve-eqn expr var full
34828 This version of @code{solve-for} takes an expression which will
34829 typically be an equation or inequality. (If it is not, it will be
34830 interpreted as the equation @samp{@var{expr} = 0}.) It returns an
34831 equation or inequality, or @code{nil} if no solution could be found.
34834 @defun solve-system exprs vars full
34835 This function solves a system of equations. Generally, @var{exprs}
34836 and @var{vars} will be vectors of equal length.
34837 @xref{Solving Systems of Equations}, for other options.
34840 @defun expr-contains expr var
34841 Returns a non-@code{nil} value if @var{var} occurs as a subexpression
34844 This function might seem at first to be identical to
34845 @code{calc-find-sub-formula}. The key difference is that
34846 @code{expr-contains} uses @code{equal} to test for matches, whereas
34847 @code{calc-find-sub-formula} uses @code{eq}. In the formula
34848 @samp{f(a, a)}, the two @samp{a}s will be @code{equal} but not
34849 @code{eq} to each other.
34852 @defun expr-contains-count expr var
34853 Returns the number of occurrences of @var{var} as a subexpression
34854 of @var{expr}, or @code{nil} if there are no occurrences.
34857 @defun expr-depends expr var
34858 Returns true if @var{expr} refers to any variable the occurs in @var{var}.
34859 In other words, it checks if @var{expr} and @var{var} have any variables
34863 @defun expr-contains-vars expr
34864 Return true if @var{expr} contains any variables, or @code{nil} if @var{expr}
34865 contains only constants and functions with constant arguments.
34868 @defun expr-subst expr old new
34869 Returns a copy of @var{expr}, with all occurrences of @var{old} replaced
34870 by @var{new}. This treats @code{lambda} forms specially with respect
34871 to the dummy argument variables, so that the effect is always to return
34872 @var{expr} evaluated at @var{old} = @var{new}.
34875 @defun multi-subst expr old new
34876 This is like @code{expr-subst}, except that @var{old} and @var{new}
34877 are lists of expressions to be substituted simultaneously. If one
34878 list is shorter than the other, trailing elements of the longer list
34882 @defun expr-weight expr
34883 Returns the ``weight'' of @var{expr}, basically a count of the total
34884 number of objects and function calls that appear in @var{expr}. For
34885 ``primitive'' objects, this will be one.
34888 @defun expr-height expr
34889 Returns the ``height'' of @var{expr}, which is the deepest level to
34890 which function calls are nested. (Note that @samp{@var{a} + @var{b}}
34891 counts as a function call.) For primitive objects, this returns zero.
34894 @defun polynomial-p expr var
34895 Check if @var{expr} is a polynomial in variable (or sub-expression)
34896 @var{var}. If so, return the degree of the polynomial, that is, the
34897 highest power of @var{var} that appears in @var{expr}. For example,
34898 for @samp{(x^2 + 3)^3 + 4} this would return 6. This function returns
34899 @code{nil} unless @var{expr}, when expanded out by @kbd{a x}
34900 (@code{calc-expand}), would consist of a sum of terms in which @var{var}
34901 appears only raised to nonnegative integer powers. Note that if
34902 @var{var} does not occur in @var{expr}, then @var{expr} is considered
34903 a polynomial of degree 0.
34906 @defun is-polynomial expr var degree loose
34907 Check if @var{expr} is a polynomial in variable or sub-expression
34908 @var{var}, and, if so, return a list representation of the polynomial
34909 where the elements of the list are coefficients of successive powers of
34910 @var{var}: @samp{@var{a} + @var{b} x + @var{c} x^3} would produce the
34911 list @samp{(@var{a} @var{b} 0 @var{c})}, and @samp{(x + 1)^2} would
34912 produce the list @samp{(1 2 1)}. The highest element of the list will
34913 be non-zero, with the special exception that if @var{expr} is the
34914 constant zero, the returned value will be @samp{(0)}. Return @code{nil}
34915 if @var{expr} is not a polynomial in @var{var}. If @var{degree} is
34916 specified, this will not consider polynomials of degree higher than that
34917 value. This is a good precaution because otherwise an input of
34918 @samp{(x+1)^1000} will cause a huge coefficient list to be built. If
34919 @var{loose} is non-@code{nil}, then a looser definition of a polynomial
34920 is used in which coefficients are no longer required not to depend on
34921 @var{var}, but are only required not to take the form of polynomials
34922 themselves. For example, @samp{sin(x) x^2 + cos(x)} is a loose
34923 polynomial with coefficients @samp{((calcFunc-cos x) 0 (calcFunc-sin
34924 x))}. The result will never be @code{nil} in loose mode, since any
34925 expression can be interpreted as a ``constant'' loose polynomial.
34928 @defun polynomial-base expr pred
34929 Check if @var{expr} is a polynomial in any variable that occurs in it;
34930 if so, return that variable. (If @var{expr} is a multivariate polynomial,
34931 this chooses one variable arbitrarily.) If @var{pred} is specified, it should
34932 be a Lisp function which is called as @samp{(@var{pred} @var{subexpr})},
34933 and which should return true if @code{mpb-top-expr} (a global name for
34934 the original @var{expr}) is a suitable polynomial in @var{subexpr}.
34935 The default predicate uses @samp{(polynomial-p mpb-top-expr @var{subexpr})};
34936 you can use @var{pred} to specify additional conditions. Or, you could
34937 have @var{pred} build up a list of every suitable @var{subexpr} that
34941 @defun poly-simplify poly
34942 Simplify polynomial coefficient list @var{poly} by (destructively)
34943 clipping off trailing zeros.
34946 @defun poly-mix a ac b bc
34947 Mix two polynomial lists @var{a} and @var{b} (in the form returned by
34948 @code{is-polynomial}) in a linear combination with coefficient expressions
34949 @var{ac} and @var{bc}. The result is a (not necessarily simplified)
34950 polynomial list representing @samp{@var{ac} @var{a} + @var{bc} @var{b}}.
34953 @defun poly-mul a b
34954 Multiply two polynomial coefficient lists @var{a} and @var{b}. The
34955 result will be in simplified form if the inputs were simplified.
34958 @defun build-polynomial-expr poly var
34959 Construct a Calc formula which represents the polynomial coefficient
34960 list @var{poly} applied to variable @var{var}. The @kbd{a c}
34961 (@code{calc-collect}) command uses @code{is-polynomial} to turn an
34962 expression into a coefficient list, then @code{build-polynomial-expr}
34963 to turn the list back into an expression in regular form.
34966 @defun check-unit-name var
34967 Check if @var{var} is a variable which can be interpreted as a unit
34968 name. If so, return the units table entry for that unit. This
34969 will be a list whose first element is the unit name (not counting
34970 prefix characters) as a symbol and whose second element is the
34971 Calc expression which defines the unit. (Refer to the Calc sources
34972 for details on the remaining elements of this list.) If @var{var}
34973 is not a variable or is not a unit name, return @code{nil}.
34976 @defun units-in-expr-p expr sub-exprs
34977 Return true if @var{expr} contains any variables which can be
34978 interpreted as units. If @var{sub-exprs} is @code{t}, the entire
34979 expression is searched. If @var{sub-exprs} is @code{nil}, this
34980 checks whether @var{expr} is directly a units expression.
34983 @defun single-units-in-expr-p expr
34984 Check whether @var{expr} contains exactly one units variable. If so,
34985 return the units table entry for the variable. If @var{expr} does
34986 not contain any units, return @code{nil}. If @var{expr} contains
34987 two or more units, return the symbol @code{wrong}.
34990 @defun to-standard-units expr which
34991 Convert units expression @var{expr} to base units. If @var{which}
34992 is @code{nil}, use Calc's native base units. Otherwise, @var{which}
34993 can specify a units system, which is a list of two-element lists,
34994 where the first element is a Calc base symbol name and the second
34995 is an expression to substitute for it.
34998 @defun remove-units expr
34999 Return a copy of @var{expr} with all units variables replaced by ones.
35000 This expression is generally normalized before use.
35003 @defun extract-units expr
35004 Return a copy of @var{expr} with everything but units variables replaced
35008 @node Formatting Lisp Functions, Hooks, Symbolic Lisp Functions, Internals
35009 @subsubsection I/O and Formatting Functions
35012 The functions described here are responsible for parsing and formatting
35013 Calc numbers and formulas.
35015 @defun calc-eval str sep arg1 arg2 @dots{}
35016 This is the simplest interface to the Calculator from another Lisp program.
35017 @xref{Calling Calc from Your Programs}.
35020 @defun read-number str
35021 If string @var{str} contains a valid Calc number, either integer,
35022 fraction, float, or HMS form, this function parses and returns that
35023 number. Otherwise, it returns @code{nil}.
35026 @defun read-expr str
35027 Read an algebraic expression from string @var{str}. If @var{str} does
35028 not have the form of a valid expression, return a list of the form
35029 @samp{(error @var{pos} @var{msg})} where @var{pos} is an integer index
35030 into @var{str} of the general location of the error, and @var{msg} is
35031 a string describing the problem.
35034 @defun read-exprs str
35035 Read a list of expressions separated by commas, and return it as a
35036 Lisp list. If an error occurs in any expressions, an error list as
35037 shown above is returned instead.
35040 @defun calc-do-alg-entry initial prompt no-norm
35041 Read an algebraic formula or formulas using the minibuffer. All
35042 conventions of regular algebraic entry are observed. The return value
35043 is a list of Calc formulas; there will be more than one if the user
35044 entered a list of values separated by commas. The result is @code{nil}
35045 if the user presses Return with a blank line. If @var{initial} is
35046 given, it is a string which the minibuffer will initially contain.
35047 If @var{prompt} is given, it is the prompt string to use; the default
35048 is ``Algebraic:''. If @var{no-norm} is @code{t}, the formulas will
35049 be returned exactly as parsed; otherwise, they will be passed through
35050 @code{calc-normalize} first.
35052 To support the use of @kbd{$} characters in the algebraic entry, use
35053 @code{let} to bind @code{calc-dollar-values} to a list of the values
35054 to be substituted for @kbd{$}, @kbd{$$}, and so on, and bind
35055 @code{calc-dollar-used} to 0. Upon return, @code{calc-dollar-used}
35056 will have been changed to the highest number of consecutive @kbd{$}s
35057 that actually appeared in the input.
35060 @defun format-number a
35061 Convert the real or complex number or HMS form @var{a} to string form.
35064 @defun format-flat-expr a prec
35065 Convert the arbitrary Calc number or formula @var{a} to string form,
35066 in the style used by the trail buffer and the @code{calc-edit} command.
35067 This is a simple format designed
35068 mostly to guarantee the string is of a form that can be re-parsed by
35069 @code{read-expr}. Most formatting modes, such as digit grouping,
35070 complex number format, and point character, are ignored to ensure the
35071 result will be re-readable. The @var{prec} parameter is normally 0; if
35072 you pass a large integer like 1000 instead, the expression will be
35073 surrounded by parentheses unless it is a plain number or variable name.
35076 @defun format-nice-expr a width
35077 This is like @code{format-flat-expr} (with @var{prec} equal to 0),
35078 except that newlines will be inserted to keep lines down to the
35079 specified @var{width}, and vectors that look like matrices or rewrite
35080 rules are written in a pseudo-matrix format. The @code{calc-edit}
35081 command uses this when only one stack entry is being edited.
35084 @defun format-value a width
35085 Convert the Calc number or formula @var{a} to string form, using the
35086 format seen in the stack buffer. Beware the string returned may
35087 not be re-readable by @code{read-expr}, for example, because of digit
35088 grouping. Multi-line objects like matrices produce strings that
35089 contain newline characters to separate the lines. The @var{w}
35090 parameter, if given, is the target window size for which to format
35091 the expressions. If @var{w} is omitted, the width of the Calculator
35095 @defun compose-expr a prec
35096 Format the Calc number or formula @var{a} according to the current
35097 language mode, returning a ``composition.'' To learn about the
35098 structure of compositions, see the comments in the Calc source code.
35099 You can specify the format of a given type of function call by putting
35100 a @code{math-compose-@var{lang}} property on the function's symbol,
35101 whose value is a Lisp function that takes @var{a} and @var{prec} as
35102 arguments and returns a composition. Here @var{lang} is a language
35103 mode name, one of @code{normal}, @code{big}, @code{c}, @code{pascal},
35104 @code{fortran}, @code{tex}, @code{eqn}, @code{math}, or @code{maple}.
35105 In Big mode, Calc actually tries @code{math-compose-big} first, then
35106 tries @code{math-compose-normal}. If this property does not exist,
35107 or if the function returns @code{nil}, the function is written in the
35108 normal function-call notation for that language.
35111 @defun composition-to-string c w
35112 Convert a composition structure returned by @code{compose-expr} into
35113 a string. Multi-line compositions convert to strings containing
35114 newline characters. The target window size is given by @var{w}.
35115 The @code{format-value} function basically calls @code{compose-expr}
35116 followed by @code{composition-to-string}.
35119 @defun comp-width c
35120 Compute the width in characters of composition @var{c}.
35123 @defun comp-height c
35124 Compute the height in lines of composition @var{c}.
35127 @defun comp-ascent c
35128 Compute the portion of the height of composition @var{c} which is on or
35129 above the baseline. For a one-line composition, this will be one.
35132 @defun comp-descent c
35133 Compute the portion of the height of composition @var{c} which is below
35134 the baseline. For a one-line composition, this will be zero.
35137 @defun comp-first-char c
35138 If composition @var{c} is a ``flat'' composition, return the first
35139 (leftmost) character of the composition as an integer. Otherwise,
35143 @defun comp-last-char c
35144 If composition @var{c} is a ``flat'' composition, return the last
35145 (rightmost) character, otherwise return @code{nil}.
35148 @comment @node Lisp Variables, Hooks, Formatting Lisp Functions, Internals
35149 @comment @subsubsection Lisp Variables
35152 @comment (This section is currently unfinished.)
35154 @node Hooks, , Formatting Lisp Functions, Internals
35155 @subsubsection Hooks
35158 Hooks are variables which contain Lisp functions (or lists of functions)
35159 which are called at various times. Calc defines a number of hooks
35160 that help you to customize it in various ways. Calc uses the Lisp
35161 function @code{run-hooks} to invoke the hooks shown below. Several
35162 other customization-related variables are also described here.
35164 @defvar calc-load-hook
35165 This hook is called at the end of @file{calc.el}, after the file has
35166 been loaded, before any functions in it have been called, but after
35167 @code{calc-mode-map} and similar variables have been set up.
35170 @defvar calc-ext-load-hook
35171 This hook is called at the end of @file{calc-ext.el}.
35174 @defvar calc-start-hook
35175 This hook is called as the last step in a @kbd{M-x calc} command.
35176 At this point, the Calc buffer has been created and initialized if
35177 necessary, the Calc window and trail window have been created,
35178 and the ``Welcome to Calc'' message has been displayed.
35181 @defvar calc-mode-hook
35182 This hook is called when the Calc buffer is being created. Usually
35183 this will only happen once per Emacs session. The hook is called
35184 after Emacs has switched to the new buffer, the mode-settings file
35185 has been read if necessary, and all other buffer-local variables
35186 have been set up. After this hook returns, Calc will perform a
35187 @code{calc-refresh} operation, set up the mode line display, then
35188 evaluate any deferred @code{calc-define} properties that have not
35189 been evaluated yet.
35192 @defvar calc-trail-mode-hook
35193 This hook is called when the Calc Trail buffer is being created.
35194 It is called as the very last step of setting up the Trail buffer.
35195 Like @code{calc-mode-hook}, this will normally happen only once
35199 @defvar calc-end-hook
35200 This hook is called by @code{calc-quit}, generally because the user
35201 presses @kbd{q} or @kbd{C-x * c} while in Calc. The Calc buffer will
35202 be the current buffer. The hook is called as the very first
35203 step, before the Calc window is destroyed.
35206 @defvar calc-window-hook
35207 If this hook is non-@code{nil}, it is called to create the Calc window.
35208 Upon return, this new Calc window should be the current window.
35209 (The Calc buffer will already be the current buffer when the
35210 hook is called.) If the hook is not defined, Calc will
35211 generally use @code{split-window}, @code{set-window-buffer},
35212 and @code{select-window} to create the Calc window.
35215 @defvar calc-trail-window-hook
35216 If this hook is non-@code{nil}, it is called to create the Calc Trail
35217 window. The variable @code{calc-trail-buffer} will contain the buffer
35218 which the window should use. Unlike @code{calc-window-hook}, this hook
35219 must @emph{not} switch into the new window.
35222 @defvar calc-embedded-mode-hook
35223 This hook is called the first time that Embedded mode is entered.
35226 @defvar calc-embedded-new-buffer-hook
35227 This hook is called each time that Embedded mode is entered in a
35231 @defvar calc-embedded-new-formula-hook
35232 This hook is called each time that Embedded mode is enabled for a
35236 @defvar calc-edit-mode-hook
35237 This hook is called by @code{calc-edit} (and the other ``edit''
35238 commands) when the temporary editing buffer is being created.
35239 The buffer will have been selected and set up to be in
35240 @code{calc-edit-mode}, but will not yet have been filled with
35241 text. (In fact it may still have leftover text from a previous
35242 @code{calc-edit} command.)
35245 @defvar calc-mode-save-hook
35246 This hook is called by the @code{calc-save-modes} command,
35247 after Calc's own mode features have been inserted into the
35248 Calc init file and just before the ``End of mode settings''
35249 message is inserted.
35252 @defvar calc-reset-hook
35253 This hook is called after @kbd{C-x * 0} (@code{calc-reset}) has
35254 reset all modes. The Calc buffer will be the current buffer.
35257 @defvar calc-other-modes
35258 This variable contains a list of strings. The strings are
35259 concatenated at the end of the modes portion of the Calc
35260 mode line (after standard modes such as ``Deg'', ``Inv'' and
35261 ``Hyp''). Each string should be a short, single word followed
35262 by a space. The variable is @code{nil} by default.
35265 @defvar calc-mode-map
35266 This is the keymap that is used by Calc mode. The best time
35267 to adjust it is probably in a @code{calc-mode-hook}. If the
35268 Calc extensions package (@file{calc-ext.el}) has not yet been
35269 loaded, many of these keys will be bound to @code{calc-missing-key},
35270 which is a command that loads the extensions package and
35271 ``retypes'' the key. If your @code{calc-mode-hook} rebinds
35272 one of these keys, it will probably be overridden when the
35273 extensions are loaded.
35276 @defvar calc-digit-map
35277 This is the keymap that is used during numeric entry. Numeric
35278 entry uses the minibuffer, but this map binds every non-numeric
35279 key to @code{calcDigit-nondigit} which generally calls
35280 @code{exit-minibuffer} and ``retypes'' the key.
35283 @defvar calc-alg-ent-map
35284 This is the keymap that is used during algebraic entry. This is
35285 mostly a copy of @code{minibuffer-local-map}.
35288 @defvar calc-store-var-map
35289 This is the keymap that is used during entry of variable names for
35290 commands like @code{calc-store} and @code{calc-recall}. This is
35291 mostly a copy of @code{minibuffer-local-completion-map}.
35294 @defvar calc-edit-mode-map
35295 This is the (sparse) keymap used by @code{calc-edit} and other
35296 temporary editing commands. It binds @key{RET}, @key{LFD},
35297 and @kbd{C-c C-c} to @code{calc-edit-finish}.
35300 @defvar calc-mode-var-list
35301 This is a list of variables which are saved by @code{calc-save-modes}.
35302 Each entry is a list of two items, the variable (as a Lisp symbol)
35303 and its default value. When modes are being saved, each variable
35304 is compared with its default value (using @code{equal}) and any
35305 non-default variables are written out.
35308 @defvar calc-local-var-list
35309 This is a list of variables which should be buffer-local to the
35310 Calc buffer. Each entry is a variable name (as a Lisp symbol).
35311 These variables also have their default values manipulated by
35312 the @code{calc} and @code{calc-quit} commands; @pxref{Multiple Calculators}.
35313 Since @code{calc-mode-hook} is called after this list has been
35314 used the first time, your hook should add a variable to the
35315 list and also call @code{make-local-variable} itself.
35318 @node Copying, GNU Free Documentation License, Programming, Top
35319 @appendix GNU GENERAL PUBLIC LICENSE
35322 @node GNU Free Documentation License, Customizing Calc, Copying, Top
35323 @appendix GNU Free Documentation License
35324 @include doclicense.texi
35326 @node Customizing Calc, Reporting Bugs, GNU Free Documentation License, Top
35327 @appendix Customizing Calc
35329 The usual prefix for Calc is the key sequence @kbd{C-x *}. If you wish
35330 to use a different prefix, you can put
35333 (global-set-key "NEWPREFIX" 'calc-dispatch)
35337 in your .emacs file.
35338 (@xref{Key Bindings,,Customizing Key Bindings,emacs,
35339 The GNU Emacs Manual}, for more information on binding keys.)
35340 A convenient way to start Calc is with @kbd{C-x * *}; to make it equally
35341 convenient for users who use a different prefix, the prefix can be
35342 followed by @kbd{=}, @kbd{&}, @kbd{#}, @kbd{\}, @kbd{/}, @kbd{+} or
35343 @kbd{-} as well as @kbd{*} to start Calc, and so in many cases the last
35344 character of the prefix can simply be typed twice.
35346 Calc is controlled by many variables, most of which can be reset
35347 from within Calc. Some variables are less involved with actual
35348 calculation and can be set outside of Calc using Emacs's
35349 customization facilities. These variables are listed below.
35350 Typing @kbd{M-x customize-variable RET @var{variable-name} RET}
35351 will bring up a buffer in which the variable's value can be redefined.
35352 Typing @kbd{M-x customize-group RET calc RET} will bring up a buffer which
35353 contains all of Calc's customizable variables. (These variables can
35354 also be reset by putting the appropriate lines in your .emacs file;
35355 @xref{Init File, ,Init File, emacs, The GNU Emacs Manual}.)
35357 Some of the customizable variables are regular expressions. A regular
35358 expression is basically a pattern that Calc can search for.
35359 See @ref{Regexp Search,, Regular Expression Search, emacs, The GNU Emacs Manual}
35360 to see how regular expressions work.
35362 @defvar calc-settings-file
35363 The variable @code{calc-settings-file} holds the file name in
35364 which commands like @kbd{m m} and @kbd{Z P} store ``permanent''
35366 If @code{calc-settings-file} is not your user init file (typically
35367 @file{~/.emacs}) and if the variable @code{calc-loaded-settings-file} is
35368 @code{nil}, then Calc will automatically load your settings file (if it
35369 exists) the first time Calc is invoked.
35371 The default value for this variable is @code{"~/.emacs.d/calc.el"}
35372 unless the file @file{~/.calc.el} exists, in which case the default
35373 value will be @code{"~/.calc.el"}.
35376 @defvar calc-gnuplot-name
35377 See @ref{Graphics}.@*
35378 The variable @code{calc-gnuplot-name} should be the name of the
35379 GNUPLOT program (a string). If you have GNUPLOT installed on your
35380 system but Calc is unable to find it, you may need to set this
35381 variable. You may also need to set some Lisp variables to show Calc how
35382 to run GNUPLOT on your system, see @ref{Devices, ,Graphical Devices} .
35383 The default value of @code{calc-gnuplot-name} is @code{"gnuplot"}.
35386 @defvar calc-gnuplot-plot-command
35387 @defvarx calc-gnuplot-print-command
35388 See @ref{Devices, ,Graphical Devices}.@*
35389 The variables @code{calc-gnuplot-plot-command} and
35390 @code{calc-gnuplot-print-command} represent system commands to
35391 display and print the output of GNUPLOT, respectively. These may be
35392 @code{nil} if no command is necessary, or strings which can include
35393 @samp{%s} to signify the name of the file to be displayed or printed.
35394 Or, these variables may contain Lisp expressions which are evaluated
35395 to display or print the output.
35397 The default value of @code{calc-gnuplot-plot-command} is @code{nil},
35398 and the default value of @code{calc-gnuplot-print-command} is
35402 @defvar calc-language-alist
35403 See @ref{Basic Embedded Mode}.@*
35404 The variable @code{calc-language-alist} controls the languages that
35405 Calc will associate with major modes. When Calc embedded mode is
35406 enabled, it will try to use the current major mode to
35407 determine what language should be used. (This can be overridden using
35408 Calc's mode changing commands, @xref{Mode Settings in Embedded Mode}.)
35409 The variable @code{calc-language-alist} consists of a list of pairs of
35410 the form @code{(@var{MAJOR-MODE} . @var{LANGUAGE})}; for example,
35411 @code{(latex-mode . latex)} is one such pair. If Calc embedded is
35412 activated in a buffer whose major mode is @var{MAJOR-MODE}, it will set itself
35413 to use the language @var{LANGUAGE}.
35415 The default value of @code{calc-language-alist} is
35417 ((latex-mode . latex)
35419 (plain-tex-mode . tex)
35420 (context-mode . tex)
35422 (pascal-mode . pascal)
35425 (fortran-mode . fortran)
35426 (f90-mode . fortran))
35430 @defvar calc-embedded-announce-formula
35431 @defvarx calc-embedded-announce-formula-alist
35432 See @ref{Customizing Embedded Mode}.@*
35433 The variable @code{calc-embedded-announce-formula} helps determine
35434 what formulas @kbd{C-x * a} will activate in a buffer. It is a
35435 regular expression, and when activating embedded formulas with
35436 @kbd{C-x * a}, it will tell Calc that what follows is a formula to be
35437 activated. (Calc also uses other patterns to find formulas, such as
35438 @samp{=>} and @samp{:=}.)
35440 The default pattern is @code{"%Embed\n\\(% .*\n\\)*"}, which checks
35441 for @samp{%Embed} followed by any number of lines beginning with
35442 @samp{%} and a space.
35444 The variable @code{calc-embedded-announce-formula-alist} is used to
35445 set @code{calc-embedded-announce-formula} to different regular
35446 expressions depending on the major mode of the editing buffer.
35447 It consists of a list of pairs of the form @code{(@var{MAJOR-MODE} .
35448 @var{REGEXP})}, and its default value is
35450 ((c++-mode . "//Embed\n\\(// .*\n\\)*")
35451 (c-mode . "/\\*Embed\\*/\n\\(/\\* .*\\*/\n\\)*")
35452 (f90-mode . "!Embed\n\\(! .*\n\\)*")
35453 (fortran-mode . "C Embed\n\\(C .*\n\\)*")
35454 (html-helper-mode . "<!-- Embed -->\n\\(<!-- .* -->\n\\)*")
35455 (html-mode . "<!-- Embed -->\n\\(<!-- .* -->\n\\)*")
35456 (nroff-mode . "\\\\\"Embed\n\\(\\\\\" .*\n\\)*")
35457 (pascal-mode . "@{Embed@}\n\\(@{.*@}\n\\)*")
35458 (sgml-mode . "<!-- Embed -->\n\\(<!-- .* -->\n\\)*")
35459 (xml-mode . "<!-- Embed -->\n\\(<!-- .* -->\n\\)*")
35460 (texinfo-mode . "@@c Embed\n\\(@@c .*\n\\)*"))
35462 Any major modes added to @code{calc-embedded-announce-formula-alist}
35463 should also be added to @code{calc-embedded-open-close-plain-alist}
35464 and @code{calc-embedded-open-close-mode-alist}.
35467 @defvar calc-embedded-open-formula
35468 @defvarx calc-embedded-close-formula
35469 @defvarx calc-embedded-open-close-formula-alist
35470 See @ref{Customizing Embedded Mode}.@*
35471 The variables @code{calc-embedded-open-formula} and
35472 @code{calc-embedded-close-formula} control the region that Calc will
35473 activate as a formula when Embedded mode is entered with @kbd{C-x * e}.
35474 They are regular expressions;
35475 Calc normally scans backward and forward in the buffer for the
35476 nearest text matching these regular expressions to be the ``formula
35479 The simplest delimiters are blank lines. Other delimiters that
35480 Embedded mode understands by default are:
35483 The @TeX{} and @LaTeX{} math delimiters @samp{$ $}, @samp{$$ $$},
35484 @samp{\[ \]}, and @samp{\( \)};
35486 Lines beginning with @samp{\begin} and @samp{\end} (except matrix delimiters);
35488 Lines beginning with @samp{@@} (Texinfo delimiters).
35490 Lines beginning with @samp{.EQ} and @samp{.EN} (@dfn{eqn} delimiters);
35492 Lines containing a single @samp{%} or @samp{.\"} symbol and nothing else.
35495 The variable @code{calc-embedded-open-close-formula-alist} is used to
35496 set @code{calc-embedded-open-formula} and
35497 @code{calc-embedded-close-formula} to different regular
35498 expressions depending on the major mode of the editing buffer.
35499 It consists of a list of lists of the form
35500 @code{(@var{MAJOR-MODE} @var{OPEN-FORMULA-REGEXP}
35501 @var{CLOSE-FORMULA-REGEXP})}, and its default value is
35505 @defvar calc-embedded-word-regexp
35506 @defvarx calc-embedded-word-regexp-alist
35507 See @ref{Customizing Embedded Mode}.@*
35508 The variable @code{calc-embedded-word-regexp} determines the expression
35509 that Calc will activate when Embedded mode is entered with @kbd{C-x *
35510 w}. It is a regular expressions.
35512 The default value of @code{calc-embedded-word-regexp} is
35513 @code{"[-+]?[0-9]+\\(\\.[0-9]+\\)?\\([eE][-+]?[0-9]+\\)?"}.
35515 The variable @code{calc-embedded-word-regexp-alist} is used to
35516 set @code{calc-embedded-word-regexp} to a different regular
35517 expression depending on the major mode of the editing buffer.
35518 It consists of a list of lists of the form
35519 @code{(@var{MAJOR-MODE} @var{WORD-REGEXP})}, and its default value is
35523 @defvar calc-embedded-open-plain
35524 @defvarx calc-embedded-close-plain
35525 @defvarx calc-embedded-open-close-plain-alist
35526 See @ref{Customizing Embedded Mode}.@*
35527 The variables @code{calc-embedded-open-plain} and
35528 @code{calc-embedded-open-plain} are used to delimit ``plain''
35529 formulas. Note that these are actual strings, not regular
35530 expressions, because Calc must be able to write these string into a
35531 buffer as well as to recognize them.
35533 The default string for @code{calc-embedded-open-plain} is
35534 @code{"%%% "}, note the trailing space. The default string for
35535 @code{calc-embedded-close-plain} is @code{" %%%\n"}, without
35536 the trailing newline here, the first line of a Big mode formula
35537 that followed might be shifted over with respect to the other lines.
35539 The variable @code{calc-embedded-open-close-plain-alist} is used to
35540 set @code{calc-embedded-open-plain} and
35541 @code{calc-embedded-close-plain} to different strings
35542 depending on the major mode of the editing buffer.
35543 It consists of a list of lists of the form
35544 @code{(@var{MAJOR-MODE} @var{OPEN-PLAIN-STRING}
35545 @var{CLOSE-PLAIN-STRING})}, and its default value is
35547 ((c++-mode "// %% " " %%\n")
35548 (c-mode "/* %% " " %% */\n")
35549 (f90-mode "! %% " " %%\n")
35550 (fortran-mode "C %% " " %%\n")
35551 (html-helper-mode "<!-- %% " " %% -->\n")
35552 (html-mode "<!-- %% " " %% -->\n")
35553 (nroff-mode "\\\" %% " " %%\n")
35554 (pascal-mode "@{%% " " %%@}\n")
35555 (sgml-mode "<!-- %% " " %% -->\n")
35556 (xml-mode "<!-- %% " " %% -->\n")
35557 (texinfo-mode "@@c %% " " %%\n"))
35559 Any major modes added to @code{calc-embedded-open-close-plain-alist}
35560 should also be added to @code{calc-embedded-announce-formula-alist}
35561 and @code{calc-embedded-open-close-mode-alist}.
35564 @defvar calc-embedded-open-new-formula
35565 @defvarx calc-embedded-close-new-formula
35566 @defvarx calc-embedded-open-close-new-formula-alist
35567 See @ref{Customizing Embedded Mode}.@*
35568 The variables @code{calc-embedded-open-new-formula} and
35569 @code{calc-embedded-close-new-formula} are strings which are
35570 inserted before and after a new formula when you type @kbd{C-x * f}.
35572 The default value of @code{calc-embedded-open-new-formula} is
35573 @code{"\n\n"}. If this string begins with a newline character and the
35574 @kbd{C-x * f} is typed at the beginning of a line, @kbd{C-x * f} will skip
35575 this first newline to avoid introducing unnecessary blank lines in the
35576 file. The default value of @code{calc-embedded-close-new-formula} is
35577 also @code{"\n\n"}. The final newline is omitted by @w{@kbd{C-x * f}}
35578 if typed at the end of a line. (It follows that if @kbd{C-x * f} is
35579 typed on a blank line, both a leading opening newline and a trailing
35580 closing newline are omitted.)
35582 The variable @code{calc-embedded-open-close-new-formula-alist} is used to
35583 set @code{calc-embedded-open-new-formula} and
35584 @code{calc-embedded-close-new-formula} to different strings
35585 depending on the major mode of the editing buffer.
35586 It consists of a list of lists of the form
35587 @code{(@var{MAJOR-MODE} @var{OPEN-NEW-FORMULA-STRING}
35588 @var{CLOSE-NEW-FORMULA-STRING})}, and its default value is
35592 @defvar calc-embedded-open-mode
35593 @defvarx calc-embedded-close-mode
35594 @defvarx calc-embedded-open-close-mode-alist
35595 See @ref{Customizing Embedded Mode}.@*
35596 The variables @code{calc-embedded-open-mode} and
35597 @code{calc-embedded-close-mode} are strings which Calc will place before
35598 and after any mode annotations that it inserts. Calc never scans for
35599 these strings; Calc always looks for the annotation itself, so it is not
35600 necessary to add them to user-written annotations.
35602 The default value of @code{calc-embedded-open-mode} is @code{"% "}
35603 and the default value of @code{calc-embedded-close-mode} is
35605 If you change the value of @code{calc-embedded-close-mode}, it is a good
35606 idea still to end with a newline so that mode annotations will appear on
35607 lines by themselves.
35609 The variable @code{calc-embedded-open-close-mode-alist} is used to
35610 set @code{calc-embedded-open-mode} and
35611 @code{calc-embedded-close-mode} to different strings
35612 expressions depending on the major mode of the editing buffer.
35613 It consists of a list of lists of the form
35614 @code{(@var{MAJOR-MODE} @var{OPEN-MODE-STRING}
35615 @var{CLOSE-MODE-STRING})}, and its default value is
35617 ((c++-mode "// " "\n")
35618 (c-mode "/* " " */\n")
35619 (f90-mode "! " "\n")
35620 (fortran-mode "C " "\n")
35621 (html-helper-mode "<!-- " " -->\n")
35622 (html-mode "<!-- " " -->\n")
35623 (nroff-mode "\\\" " "\n")
35624 (pascal-mode "@{ " " @}\n")
35625 (sgml-mode "<!-- " " -->\n")
35626 (xml-mode "<!-- " " -->\n")
35627 (texinfo-mode "@@c " "\n"))
35629 Any major modes added to @code{calc-embedded-open-close-mode-alist}
35630 should also be added to @code{calc-embedded-announce-formula-alist}
35631 and @code{calc-embedded-open-close-plain-alist}.
35634 @defvar calc-lu-power-reference
35635 @defvarx calc-lu-field-reference
35636 See @ref{Logarithmic Units}.@*
35637 The variables @code{calc-lu-power-reference} and
35638 @code{calc-lu-field-reference} are unit expressions (written as
35639 strings) which Calc will use as reference quantities for logarithmic
35642 The default value of @code{calc-lu-power-reference} is @code{"mW"}
35643 and the default value of @code{calc-lu-field-reference} is
35647 @defvar calc-note-threshold
35648 See @ref{Musical Notes}.@*
35649 The variable @code{calc-note-threshold} is a number (written as a
35650 string) which determines how close (in cents) a frequency needs to be
35651 to a note to be recognized as that note.
35653 The default value of @code{calc-note-threshold} is 1.
35656 @defvar calc-highlight-selections-with-faces
35657 @defvarx calc-selected-face
35658 @defvarx calc-nonselected-face
35659 See @ref{Displaying Selections}.@*
35660 The variable @code{calc-highlight-selections-with-faces}
35661 determines how selected sub-formulas are distinguished.
35662 If @code{calc-highlight-selections-with-faces} is nil, then
35663 a selected sub-formula is distinguished either by changing every
35664 character not part of the sub-formula with a dot or by changing every
35665 character in the sub-formula with a @samp{#} sign.
35666 If @code{calc-highlight-selections-with-faces} is t,
35667 then a selected sub-formula is distinguished either by displaying the
35668 non-selected portion of the formula with @code{calc-nonselected-face}
35669 or by displaying the selected sub-formula with
35670 @code{calc-nonselected-face}.
35673 @defvar calc-multiplication-has-precedence
35674 The variable @code{calc-multiplication-has-precedence} determines
35675 whether multiplication has precedence over division in algebraic
35676 formulas in normal language modes. If
35677 @code{calc-multiplication-has-precedence} is non-@code{nil}, then
35678 multiplication has precedence (and, for certain obscure reasons, is
35679 right associative), and so for example @samp{a/b*c} will be interpreted
35680 as @samp{a/(b*c)}. If @code{calc-multiplication-has-precedence} is
35681 @code{nil}, then multiplication has the same precedence as division
35682 (and, like division, is left associative), and so for example
35683 @samp{a/b*c} will be interpreted as @samp{(a/b)*c}. The default value
35684 of @code{calc-multiplication-has-precedence} is @code{t}.
35687 @defvar calc-ensure-consistent-units
35688 When converting units, the variable @code{calc-ensure-consistent-units}
35689 determines whether or not the target units need to be consistent with the
35690 original units. If @code{calc-ensure-consistent-units} is @code{nil}, then
35691 the target units don't need to have the same dimensions as the original units;
35692 for example, converting @samp{100 ft/s} to @samp{m} will produce @samp{30.48 m/s}.
35693 If @code{calc-ensure-consistent-units} is non-@code{nil}, then the target units
35694 need to have the same dimensions as the original units; for example, converting
35695 @samp{100 ft/s} to @samp{m} will result in an error, since @samp{ft/s} and @samp{m}
35696 have different dimensions. The default value of @code{calc-ensure-consistent-units}
35700 @defvar calc-context-sensitive-enter
35701 The commands @code{calc-enter} and @code{calc-pop} will typically
35702 duplicate the top of the stack. If
35703 @code{calc-context-sensitive-enter} is non-@code{nil}, then the
35704 @code{calc-enter} will copy the element at the cursor to the
35705 top of the stack and @code{calc-pop} will delete the element at the
35706 cursor. The default value of @code{calc-context-sensitive-enter} is
35710 @defvar calc-undo-length
35711 The variable @code{calc-undo-length} determines the number of undo
35712 steps that Calc will keep track of when @code{calc-quit} is called.
35713 If @code{calc-undo-length} is a non-negative integer, then this is the
35714 number of undo steps that will be preserved; if
35715 @code{calc-undo-length} has any other value, then all undo steps will
35716 be preserved. The default value of @code{calc-undo-length} is @expr{100}.
35719 @defvar calc-gregorian-switch
35720 See @ref{Date Forms}.@*
35721 The variable @code{calc-gregorian-switch} is either a list of integers
35722 @code{(@var{YEAR} @var{MONTH} @var{DAY})} or @code{nil}.
35723 If it is @code{nil}, then Calc's date forms always represent Gregorian dates.
35724 Otherwise, @code{calc-gregorian-switch} represents the date that the
35725 calendar switches from Julian dates to Gregorian dates;
35726 @code{(@var{YEAR} @var{MONTH} @var{DAY})} will be the first Gregorian
35727 date. The customization buffer will offer several standard dates to
35728 choose from, or the user can enter their own date.
35730 The default value of @code{calc-gregorian-switch} is @code{nil}.
35733 @node Reporting Bugs, Summary, Customizing Calc, Top
35734 @appendix Reporting Bugs
35737 If you find a bug in Calc, send e-mail to Jay Belanger,
35740 jay.p.belanger@@gmail.com
35744 There is an automatic command @kbd{M-x report-calc-bug} which helps
35745 you to report bugs. This command prompts you for a brief subject
35746 line, then leaves you in a mail editing buffer. Type @kbd{C-c C-c} to
35747 send your mail. Make sure your subject line indicates that you are
35748 reporting a Calc bug; this command sends mail to the maintainer's
35751 If you have suggestions for additional features for Calc, please send
35752 them. Some have dared to suggest that Calc is already top-heavy with
35753 features; this obviously cannot be the case, so if you have ideas, send
35756 At the front of the source file, @file{calc.el}, is a list of ideas for
35757 future work. If any enthusiastic souls wish to take it upon themselves
35758 to work on these, please send a message (using @kbd{M-x report-calc-bug})
35759 so any efforts can be coordinated.
35761 The latest version of Calc is available from Savannah, in the Emacs
35762 repository. See @uref{http://savannah.gnu.org/projects/emacs}.
35765 @node Summary, Key Index, Reporting Bugs, Top
35766 @appendix Calc Summary
35769 This section includes a complete list of Calc keystroke commands.
35770 Each line lists the stack entries used by the command (top-of-stack
35771 last), the keystrokes themselves, the prompts asked by the command,
35772 and the result of the command (also with top-of-stack last).
35773 The result is expressed using the equivalent algebraic function.
35774 Commands which put no results on the stack show the full @kbd{M-x}
35775 command name in that position. Numbers preceding the result or
35776 command name refer to notes at the end.
35778 Algebraic functions and @kbd{M-x} commands that don't have corresponding
35779 keystrokes are not listed in this summary.
35780 @xref{Command Index}. @xref{Function Index}.
35785 \vskip-2\baselineskip \null
35786 \gdef\sumrow#1{\sumrowx#1\relax}%
35787 \gdef\sumrowx#1\:#2\:#3\:#4\:#5\:#6\relax{%
35790 \hbox to5em{\sl\hss#1}%
35791 \hbox to5em{\tt#2\hss}%
35792 \hbox to4em{\sl#3\hss}%
35793 \hbox to5em{\rm\hss#4}%
35798 \gdef\sumlpar{{\rm(}}%
35799 \gdef\sumrpar{{\rm)}}%
35800 \gdef\sumcomma{{\rm,\thinspace}}%
35801 \gdef\sumexcl{{\rm!}}%
35802 \gdef\sumbreak{\vskip-2.5\baselineskip\goodbreak}%
35803 \gdef\minus#1{{\tt-}}%
35807 @catcode`@(=@active @let(=@sumlpar
35808 @catcode`@)=@active @let)=@sumrpar
35809 @catcode`@,=@active @let,=@sumcomma
35810 @catcode`@!=@active @let!=@sumexcl
35814 @advance@baselineskip-2.5pt
35817 @r{ @: C-x * a @: @: 33 @:calc-embedded-activate@:}
35818 @r{ @: C-x * b @: @: @:calc-big-or-small@:}
35819 @r{ @: C-x * c @: @: @:calc@:}
35820 @r{ @: C-x * d @: @: @:calc-embedded-duplicate@:}
35821 @r{ @: C-x * e @: @: 34 @:calc-embedded@:}
35822 @r{ @: C-x * f @:formula @: @:calc-embedded-new-formula@:}
35823 @r{ @: C-x * g @: @: 35 @:calc-grab-region@:}
35824 @r{ @: C-x * i @: @: @:calc-info@:}
35825 @r{ @: C-x * j @: @: @:calc-embedded-select@:}
35826 @r{ @: C-x * k @: @: @:calc-keypad@:}
35827 @r{ @: C-x * l @: @: @:calc-load-everything@:}
35828 @r{ @: C-x * m @: @: @:read-kbd-macro@:}
35829 @r{ @: C-x * n @: @: 4 @:calc-embedded-next@:}
35830 @r{ @: C-x * o @: @: @:calc-other-window@:}
35831 @r{ @: C-x * p @: @: 4 @:calc-embedded-previous@:}
35832 @r{ @: C-x * q @:formula @: @:quick-calc@:}
35833 @r{ @: C-x * r @: @: 36 @:calc-grab-rectangle@:}
35834 @r{ @: C-x * s @: @: @:calc-info-summary@:}
35835 @r{ @: C-x * t @: @: @:calc-tutorial@:}
35836 @r{ @: C-x * u @: @: @:calc-embedded-update-formula@:}
35837 @r{ @: C-x * w @: @: @:calc-embedded-word@:}
35838 @r{ @: C-x * x @: @: @:calc-quit@:}
35839 @r{ @: C-x * y @: @:1,28,49 @:calc-copy-to-buffer@:}
35840 @r{ @: C-x * z @: @: @:calc-user-invocation@:}
35841 @r{ @: C-x * : @: @: 36 @:calc-grab-sum-down@:}
35842 @r{ @: C-x * _ @: @: 36 @:calc-grab-sum-across@:}
35843 @r{ @: C-x * ` @:editing @: 30 @:calc-embedded-edit@:}
35844 @r{ @: C-x * 0 @:(zero) @: @:calc-reset@:}
35847 @r{ @: 0-9 @:number @: @:@:number}
35848 @r{ @: . @:number @: @:@:0.number}
35849 @r{ @: _ @:number @: @:-@:number}
35850 @r{ @: e @:number @: @:@:1e number}
35851 @r{ @: # @:number @: @:@:current-radix@tfn{#}number}
35852 @r{ @: P @:(in number) @: @:+/-@:}
35853 @r{ @: M @:(in number) @: @:mod@:}
35854 @r{ @: @@ ' " @: (in number)@: @:@:HMS form}
35855 @r{ @: h m s @: (in number)@: @:@:HMS form}
35858 @r{ @: ' @:formula @: 37,46 @:@:formula}
35859 @r{ @: $ @:formula @: 37,46 @:$@:formula}
35860 @r{ @: " @:string @: 37,46 @:@:string}
35863 @r{ a b@: + @: @: 2 @:add@:(a,b) a+b}
35864 @r{ a b@: - @: @: 2 @:sub@:(a,b) a@minus{}b}
35865 @r{ a b@: * @: @: 2 @:mul@:(a,b) a b, a*b}
35866 @r{ a b@: / @: @: 2 @:div@:(a,b) a/b}
35867 @r{ a b@: ^ @: @: 2 @:pow@:(a,b) a^b}
35868 @r{ a b@: I ^ @: @: 2 @:nroot@:(a,b) a^(1/b)}
35869 @r{ a b@: % @: @: 2 @:mod@:(a,b) a%b}
35870 @r{ a b@: \ @: @: 2 @:idiv@:(a,b) a\b}
35871 @r{ a b@: : @: @: 2 @:fdiv@:(a,b)}
35872 @r{ a b@: | @: @: 2 @:vconcat@:(a,b) a|b}
35873 @r{ a b@: I | @: @: @:vconcat@:(b,a) b|a}
35874 @r{ a b@: H | @: @: 2 @:append@:(a,b)}
35875 @r{ a b@: I H | @: @: @:append@:(b,a)}
35876 @r{ a@: & @: @: 1 @:inv@:(a) 1/a}
35877 @r{ a@: ! @: @: 1 @:fact@:(a) a!}
35878 @r{ a@: = @: @: 1 @:evalv@:(a)}
35879 @r{ a@: M-% @: @: @:percent@:(a) a%}
35882 @r{ ... a@: @summarykey{RET} @: @: 1 @:@:... a a}
35883 @r{ ... a@: @summarykey{SPC} @: @: 1 @:@:... a a}
35884 @r{... a b@: @summarykey{TAB} @: @: 3 @:@:... b a}
35885 @r{. a b c@: M-@summarykey{TAB} @: @: 3 @:@:... b c a}
35886 @r{... a b@: @summarykey{LFD} @: @: 1 @:@:... a b a}
35887 @r{ ... a@: @summarykey{DEL} @: @: 1 @:@:...}
35888 @r{... a b@: M-@summarykey{DEL} @: @: 1 @:@:... b}
35889 @r{ @: M-@summarykey{RET} @: @: 4 @:calc-last-args@:}
35890 @r{ a@: ` @:editing @: 1,30 @:calc-edit@:}
35893 @r{ ... a@: C-d @: @: 1 @:@:...}
35894 @r{ @: C-k @: @: 27 @:calc-kill@:}
35895 @r{ @: C-w @: @: 27 @:calc-kill-region@:}
35896 @r{ @: C-y @: @: @:calc-yank@:}
35897 @r{ @: C-_ @: @: 4 @:calc-undo@:}
35898 @r{ @: M-k @: @: 27 @:calc-copy-as-kill@:}
35899 @r{ @: M-w @: @: 27 @:calc-copy-region-as-kill@:}
35902 @r{ @: [ @: @: @:@:[...}
35903 @r{[.. a b@: ] @: @: @:@:[a,b]}
35904 @r{ @: ( @: @: @:@:(...}
35905 @r{(.. a b@: ) @: @: @:@:(a,b)}
35906 @r{ @: , @: @: @:@:vector or rect complex}
35907 @r{ @: ; @: @: @:@:matrix or polar complex}
35908 @r{ @: .. @: @: @:@:interval}
35911 @r{ @: ~ @: @: @:calc-num-prefix@:}
35912 @r{ @: < @: @: 4 @:calc-scroll-left@:}
35913 @r{ @: > @: @: 4 @:calc-scroll-right@:}
35914 @r{ @: @{ @: @: 4 @:calc-scroll-down@:}
35915 @r{ @: @} @: @: 4 @:calc-scroll-up@:}
35916 @r{ @: ? @: @: @:calc-help@:}
35919 @r{ a@: n @: @: 1 @:neg@:(a) @minus{}a}
35920 @r{ @: o @: @: 4 @:calc-realign@:}
35921 @r{ @: p @:precision @: 31 @:calc-precision@:}
35922 @r{ @: q @: @: @:calc-quit@:}
35923 @r{ @: w @: @: @:calc-why@:}
35924 @r{ @: x @:command @: @:M-x calc-@:command}
35925 @r{ a@: y @: @:1,28,49 @:calc-copy-to-buffer@:}
35928 @r{ a@: A @: @: 1 @:abs@:(a)}
35929 @r{ a b@: B @: @: 2 @:log@:(a,b)}
35930 @r{ a b@: I B @: @: 2 @:alog@:(a,b) b^a}
35931 @r{ a@: C @: @: 1 @:cos@:(a)}
35932 @r{ a@: I C @: @: 1 @:arccos@:(a)}
35933 @r{ a@: H C @: @: 1 @:cosh@:(a)}
35934 @r{ a@: I H C @: @: 1 @:arccosh@:(a)}
35935 @r{ @: D @: @: 4 @:calc-redo@:}
35936 @r{ a@: E @: @: 1 @:exp@:(a)}
35937 @r{ a@: H E @: @: 1 @:exp10@:(a) 10.^a}
35938 @r{ a@: F @: @: 1,11 @:floor@:(a,d)}
35939 @r{ a@: I F @: @: 1,11 @:ceil@:(a,d)}
35940 @r{ a@: H F @: @: 1,11 @:ffloor@:(a,d)}
35941 @r{ a@: I H F @: @: 1,11 @:fceil@:(a,d)}
35942 @r{ a@: G @: @: 1 @:arg@:(a)}
35943 @r{ @: H @:command @: 32 @:@:Hyperbolic}
35944 @r{ @: I @:command @: 32 @:@:Inverse}
35945 @r{ a@: J @: @: 1 @:conj@:(a)}
35946 @r{ @: K @:command @: 32 @:@:Keep-args}
35947 @r{ a@: L @: @: 1 @:ln@:(a)}
35948 @r{ a@: H L @: @: 1 @:log10@:(a)}
35949 @r{ @: M @: @: @:calc-more-recursion-depth@:}
35950 @r{ @: I M @: @: @:calc-less-recursion-depth@:}
35951 @r{ a@: N @: @: 5 @:evalvn@:(a)}
35952 @r{ @: O @:command @: 32 @:@:Option}
35953 @r{ @: P @: @: @:@:pi}
35954 @r{ @: I P @: @: @:@:gamma}
35955 @r{ @: H P @: @: @:@:e}
35956 @r{ @: I H P @: @: @:@:phi}
35957 @r{ a@: Q @: @: 1 @:sqrt@:(a)}
35958 @r{ a@: I Q @: @: 1 @:sqr@:(a) a^2}
35959 @r{ a@: R @: @: 1,11 @:round@:(a,d)}
35960 @r{ a@: I R @: @: 1,11 @:trunc@:(a,d)}
35961 @r{ a@: H R @: @: 1,11 @:fround@:(a,d)}
35962 @r{ a@: I H R @: @: 1,11 @:ftrunc@:(a,d)}
35963 @r{ a@: S @: @: 1 @:sin@:(a)}
35964 @r{ a@: I S @: @: 1 @:arcsin@:(a)}
35965 @r{ a@: H S @: @: 1 @:sinh@:(a)}
35966 @r{ a@: I H S @: @: 1 @:arcsinh@:(a)}
35967 @r{ a@: T @: @: 1 @:tan@:(a)}
35968 @r{ a@: I T @: @: 1 @:arctan@:(a)}
35969 @r{ a@: H T @: @: 1 @:tanh@:(a)}
35970 @r{ a@: I H T @: @: 1 @:arctanh@:(a)}
35971 @r{ @: U @: @: 4 @:calc-undo@:}
35972 @r{ @: X @: @: 4 @:calc-call-last-kbd-macro@:}
35975 @r{ a b@: a = @: @: 2 @:eq@:(a,b) a=b}
35976 @r{ a b@: a # @: @: 2 @:neq@:(a,b) a!=b}
35977 @r{ a b@: a < @: @: 2 @:lt@:(a,b) a<b}
35978 @r{ a b@: a > @: @: 2 @:gt@:(a,b) a>b}
35979 @r{ a b@: a [ @: @: 2 @:leq@:(a,b) a<=b}
35980 @r{ a b@: a ] @: @: 2 @:geq@:(a,b) a>=b}
35981 @r{ a b@: a @{ @: @: 2 @:in@:(a,b)}
35982 @r{ a b@: a & @: @: 2,45 @:land@:(a,b) a&&b}
35983 @r{ a b@: a | @: @: 2,45 @:lor@:(a,b) a||b}
35984 @r{ a@: a ! @: @: 1,45 @:lnot@:(a) !a}
35985 @r{ a b c@: a : @: @: 45 @:if@:(a,b,c) a?b:c}
35986 @r{ a@: a . @: @: 1 @:rmeq@:(a)}
35987 @r{ a@: a " @: @: 7,8 @:calc-expand-formula@:}
35990 @r{ a@: a + @:i, l, h @: 6,38 @:sum@:(a,i,l,h)}
35991 @r{ a@: a - @:i, l, h @: 6,38 @:asum@:(a,i,l,h)}
35992 @r{ a@: a * @:i, l, h @: 6,38 @:prod@:(a,i,l,h)}
35993 @r{ a b@: a _ @: @: 2 @:subscr@:(a,b) a_b}
35996 @r{ a b@: a \ @: @: 2 @:pdiv@:(a,b)}
35997 @r{ a b@: a % @: @: 2 @:prem@:(a,b)}
35998 @r{ a b@: a / @: @: 2 @:pdivrem@:(a,b) [q,r]}
35999 @r{ a b@: H a / @: @: 2 @:pdivide@:(a,b) q+r/b}
36002 @r{ a@: a a @: @: 1 @:apart@:(a)}
36003 @r{ a@: a b @:old, new @: 38 @:subst@:(a,old,new)}
36004 @r{ a@: a c @:v @: 38 @:collect@:(a,v)}
36005 @r{ a@: a d @:v @: 4,38 @:deriv@:(a,v)}
36006 @r{ a@: H a d @:v @: 4,38 @:tderiv@:(a,v)}
36007 @r{ a@: a e @: @: @:esimplify@:(a)}
36008 @r{ a@: a f @: @: 1 @:factor@:(a)}
36009 @r{ a@: H a f @: @: 1 @:factors@:(a)}
36010 @r{ a b@: a g @: @: 2 @:pgcd@:(a,b)}
36011 @r{ a@: a i @:v @: 38 @:integ@:(a,v)}
36012 @r{ a@: a m @:pats @: 38 @:match@:(a,pats)}
36013 @r{ a@: I a m @:pats @: 38 @:matchnot@:(a,pats)}
36014 @r{ data x@: a p @: @: 28 @:polint@:(data,x)}
36015 @r{ data x@: H a p @: @: 28 @:ratint@:(data,x)}
36016 @r{ a@: a n @: @: 1 @:nrat@:(a)}
36017 @r{ a@: a r @:rules @:4,8,38 @:rewrite@:(a,rules,n)}
36018 @r{ a@: a s @: @: @:simplify@:(a)}
36019 @r{ a@: a t @:v, n @: 31,39 @:taylor@:(a,v,n)}
36020 @r{ a@: a v @: @: 7,8 @:calc-alg-evaluate@:}
36021 @r{ a@: a x @: @: 4,8 @:expand@:(a)}
36024 @r{ data@: a F @:model, vars @: 48 @:fit@:(m,iv,pv,data)}
36025 @r{ data@: I a F @:model, vars @: 48 @:xfit@:(m,iv,pv,data)}
36026 @r{ data@: H a F @:model, vars @: 48 @:efit@:(m,iv,pv,data)}
36027 @r{ a@: a I @:v, l, h @: 38 @:ninteg@:(a,v,l,h)}
36028 @r{ a b@: a M @:op @: 22 @:mapeq@:(op,a,b)}
36029 @r{ a b@: I a M @:op @: 22 @:mapeqr@:(op,a,b)}
36030 @r{ a b@: H a M @:op @: 22 @:mapeqp@:(op,a,b)}
36031 @r{ a g@: a N @:v @: 38 @:minimize@:(a,v,g)}
36032 @r{ a g@: H a N @:v @: 38 @:wminimize@:(a,v,g)}
36033 @r{ a@: a P @:v @: 38 @:roots@:(a,v)}
36034 @r{ a g@: a R @:v @: 38 @:root@:(a,v,g)}
36035 @r{ a g@: H a R @:v @: 38 @:wroot@:(a,v,g)}
36036 @r{ a@: a S @:v @: 38 @:solve@:(a,v)}
36037 @r{ a@: I a S @:v @: 38 @:finv@:(a,v)}
36038 @r{ a@: H a S @:v @: 38 @:fsolve@:(a,v)}
36039 @r{ a@: I H a S @:v @: 38 @:ffinv@:(a,v)}
36040 @r{ a@: a T @:i, l, h @: 6,38 @:table@:(a,i,l,h)}
36041 @r{ a g@: a X @:v @: 38 @:maximize@:(a,v,g)}
36042 @r{ a g@: H a X @:v @: 38 @:wmaximize@:(a,v,g)}
36045 @r{ a b@: b a @: @: 9 @:and@:(a,b,w)}
36046 @r{ a@: b c @: @: 9 @:clip@:(a,w)}
36047 @r{ a b@: b d @: @: 9 @:diff@:(a,b,w)}
36048 @r{ a@: b l @: @: 10 @:lsh@:(a,n,w)}
36049 @r{ a n@: H b l @: @: 9 @:lsh@:(a,n,w)}
36050 @r{ a@: b n @: @: 9 @:not@:(a,w)}
36051 @r{ a b@: b o @: @: 9 @:or@:(a,b,w)}
36052 @r{ v@: b p @: @: 1 @:vpack@:(v)}
36053 @r{ a@: b r @: @: 10 @:rsh@:(a,n,w)}
36054 @r{ a n@: H b r @: @: 9 @:rsh@:(a,n,w)}
36055 @r{ a@: b t @: @: 10 @:rot@:(a,n,w)}
36056 @r{ a n@: H b t @: @: 9 @:rot@:(a,n,w)}
36057 @r{ a@: b u @: @: 1 @:vunpack@:(a)}
36058 @r{ @: b w @:w @: 9,50 @:calc-word-size@:}
36059 @r{ a b@: b x @: @: 9 @:xor@:(a,b,w)}
36062 @r{c s l p@: b D @: @: @:ddb@:(c,s,l,p)}
36063 @r{ r n p@: b F @: @: @:fv@:(r,n,p)}
36064 @r{ r n p@: I b F @: @: @:fvb@:(r,n,p)}
36065 @r{ r n p@: H b F @: @: @:fvl@:(r,n,p)}
36066 @r{ v@: b I @: @: 19 @:irr@:(v)}
36067 @r{ v@: I b I @: @: 19 @:irrb@:(v)}
36068 @r{ a@: b L @: @: 10 @:ash@:(a,n,w)}
36069 @r{ a n@: H b L @: @: 9 @:ash@:(a,n,w)}
36070 @r{ r n a@: b M @: @: @:pmt@:(r,n,a)}
36071 @r{ r n a@: I b M @: @: @:pmtb@:(r,n,a)}
36072 @r{ r n a@: H b M @: @: @:pmtl@:(r,n,a)}
36073 @r{ r v@: b N @: @: 19 @:npv@:(r,v)}
36074 @r{ r v@: I b N @: @: 19 @:npvb@:(r,v)}
36075 @r{ r n p@: b P @: @: @:pv@:(r,n,p)}
36076 @r{ r n p@: I b P @: @: @:pvb@:(r,n,p)}
36077 @r{ r n p@: H b P @: @: @:pvl@:(r,n,p)}
36078 @r{ a@: b R @: @: 10 @:rash@:(a,n,w)}
36079 @r{ a n@: H b R @: @: 9 @:rash@:(a,n,w)}
36080 @r{ c s l@: b S @: @: @:sln@:(c,s,l)}
36081 @r{ n p a@: b T @: @: @:rate@:(n,p,a)}
36082 @r{ n p a@: I b T @: @: @:rateb@:(n,p,a)}
36083 @r{ n p a@: H b T @: @: @:ratel@:(n,p,a)}
36084 @r{c s l p@: b Y @: @: @:syd@:(c,s,l,p)}
36086 @r{ r p a@: b # @: @: @:nper@:(r,p,a)}
36087 @r{ r p a@: I b # @: @: @:nperb@:(r,p,a)}
36088 @r{ r p a@: H b # @: @: @:nperl@:(r,p,a)}
36089 @r{ a b@: b % @: @: @:relch@:(a,b)}
36092 @r{ a@: c c @: @: 5 @:pclean@:(a,p)}
36093 @r{ a@: c 0-9 @: @: @:pclean@:(a,p)}
36094 @r{ a@: H c c @: @: 5 @:clean@:(a,p)}
36095 @r{ a@: H c 0-9 @: @: @:clean@:(a,p)}
36096 @r{ a@: c d @: @: 1 @:deg@:(a)}
36097 @r{ a@: c f @: @: 1 @:pfloat@:(a)}
36098 @r{ a@: H c f @: @: 1 @:float@:(a)}
36099 @r{ a@: c h @: @: 1 @:hms@:(a)}
36100 @r{ a@: c p @: @: @:polar@:(a)}
36101 @r{ a@: I c p @: @: @:rect@:(a)}
36102 @r{ a@: c r @: @: 1 @:rad@:(a)}
36105 @r{ a@: c F @: @: 5 @:pfrac@:(a,p)}
36106 @r{ a@: H c F @: @: 5 @:frac@:(a,p)}
36109 @r{ a@: c % @: @: @:percent@:(a*100)}
36112 @r{ @: d . @:char @: 50 @:calc-point-char@:}
36113 @r{ @: d , @:char @: 50 @:calc-group-char@:}
36114 @r{ @: d < @: @: 13,50 @:calc-left-justify@:}
36115 @r{ @: d = @: @: 13,50 @:calc-center-justify@:}
36116 @r{ @: d > @: @: 13,50 @:calc-right-justify@:}
36117 @r{ @: d @{ @:label @: 50 @:calc-left-label@:}
36118 @r{ @: d @} @:label @: 50 @:calc-right-label@:}
36119 @r{ @: d [ @: @: 4 @:calc-truncate-up@:}
36120 @r{ @: d ] @: @: 4 @:calc-truncate-down@:}
36121 @r{ @: d " @: @: 12,50 @:calc-display-strings@:}
36122 @r{ @: d @summarykey{SPC} @: @: @:calc-refresh@:}
36123 @r{ @: d @summarykey{RET} @: @: 1 @:calc-refresh-top@:}
36126 @r{ @: d 0 @: @: 50 @:calc-decimal-radix@:}
36127 @r{ @: d 2 @: @: 50 @:calc-binary-radix@:}
36128 @r{ @: d 6 @: @: 50 @:calc-hex-radix@:}
36129 @r{ @: d 8 @: @: 50 @:calc-octal-radix@:}
36132 @r{ @: d b @: @:12,13,50 @:calc-line-breaking@:}
36133 @r{ @: d c @: @: 50 @:calc-complex-notation@:}
36134 @r{ @: d d @:format @: 50 @:calc-date-notation@:}
36135 @r{ @: d e @: @: 5,50 @:calc-eng-notation@:}
36136 @r{ @: d f @:num @: 31,50 @:calc-fix-notation@:}
36137 @r{ @: d g @: @:12,13,50 @:calc-group-digits@:}
36138 @r{ @: d h @:format @: 50 @:calc-hms-notation@:}
36139 @r{ @: d i @: @: 50 @:calc-i-notation@:}
36140 @r{ @: d j @: @: 50 @:calc-j-notation@:}
36141 @r{ @: d l @: @: 12,50 @:calc-line-numbering@:}
36142 @r{ @: d n @: @: 5,50 @:calc-normal-notation@:}
36143 @r{ @: d o @:format @: 50 @:calc-over-notation@:}
36144 @r{ @: d p @: @: 12,50 @:calc-show-plain@:}
36145 @r{ @: d r @:radix @: 31,50 @:calc-radix@:}
36146 @r{ @: d s @: @: 5,50 @:calc-sci-notation@:}
36147 @r{ @: d t @: @: 27 @:calc-truncate-stack@:}
36148 @r{ @: d w @: @: 12,13 @:calc-auto-why@:}
36149 @r{ @: d z @: @: 12,50 @:calc-leading-zeros@:}
36152 @r{ @: d B @: @: 50 @:calc-big-language@:}
36153 @r{ @: d C @: @: 50 @:calc-c-language@:}
36154 @r{ @: d E @: @: 50 @:calc-eqn-language@:}
36155 @r{ @: d F @: @: 50 @:calc-fortran-language@:}
36156 @r{ @: d M @: @: 50 @:calc-mathematica-language@:}
36157 @r{ @: d N @: @: 50 @:calc-normal-language@:}
36158 @r{ @: d O @: @: 50 @:calc-flat-language@:}
36159 @r{ @: d P @: @: 50 @:calc-pascal-language@:}
36160 @r{ @: d T @: @: 50 @:calc-tex-language@:}
36161 @r{ @: d L @: @: 50 @:calc-latex-language@:}
36162 @r{ @: d U @: @: 50 @:calc-unformatted-language@:}
36163 @r{ @: d W @: @: 50 @:calc-maple-language@:}
36166 @r{ a@: f [ @: @: 4 @:decr@:(a,n)}
36167 @r{ a@: f ] @: @: 4 @:incr@:(a,n)}
36170 @r{ a b@: f b @: @: 2 @:beta@:(a,b)}
36171 @r{ a@: f e @: @: 1 @:erf@:(a)}
36172 @r{ a@: I f e @: @: 1 @:erfc@:(a)}
36173 @r{ a@: f g @: @: 1 @:gamma@:(a)}
36174 @r{ a b@: f h @: @: 2 @:hypot@:(a,b)}
36175 @r{ a@: f i @: @: 1 @:im@:(a)}
36176 @r{ n a@: f j @: @: 2 @:besJ@:(n,a)}
36177 @r{ a b@: f n @: @: 2 @:min@:(a,b)}
36178 @r{ a@: f r @: @: 1 @:re@:(a)}
36179 @r{ a@: f s @: @: 1 @:sign@:(a)}
36180 @r{ a b@: f x @: @: 2 @:max@:(a,b)}
36181 @r{ n a@: f y @: @: 2 @:besY@:(n,a)}
36184 @r{ a@: f A @: @: 1 @:abssqr@:(a)}
36185 @r{ x a b@: f B @: @: @:betaI@:(x,a,b)}
36186 @r{ x a b@: H f B @: @: @:betaB@:(x,a,b)}
36187 @r{ a@: f E @: @: 1 @:expm1@:(a)}
36188 @r{ a x@: f G @: @: 2 @:gammaP@:(a,x)}
36189 @r{ a x@: I f G @: @: 2 @:gammaQ@:(a,x)}
36190 @r{ a x@: H f G @: @: 2 @:gammag@:(a,x)}
36191 @r{ a x@: I H f G @: @: 2 @:gammaG@:(a,x)}
36192 @r{ a b@: f I @: @: 2 @:ilog@:(a,b)}
36193 @r{ a b@: I f I @: @: 2 @:alog@:(a,b) b^a}
36194 @r{ a@: f L @: @: 1 @:lnp1@:(a)}
36195 @r{ a@: f M @: @: 1 @:mant@:(a)}
36196 @r{ a@: f Q @: @: 1 @:isqrt@:(a)}
36197 @r{ a@: I f Q @: @: 1 @:sqr@:(a) a^2}
36198 @r{ a n@: f S @: @: 2 @:scf@:(a,n)}
36199 @r{ y x@: f T @: @: @:arctan2@:(y,x)}
36200 @r{ a@: f X @: @: 1 @:xpon@:(a)}
36203 @r{ x y@: g a @: @: 28,40 @:calc-graph-add@:}
36204 @r{ @: g b @: @: 12 @:calc-graph-border@:}
36205 @r{ @: g c @: @: @:calc-graph-clear@:}
36206 @r{ @: g d @: @: 41 @:calc-graph-delete@:}
36207 @r{ x y@: g f @: @: 28,40 @:calc-graph-fast@:}
36208 @r{ @: g g @: @: 12 @:calc-graph-grid@:}
36209 @r{ @: g h @:title @: @:calc-graph-header@:}
36210 @r{ @: g j @: @: 4 @:calc-graph-juggle@:}
36211 @r{ @: g k @: @: 12 @:calc-graph-key@:}
36212 @r{ @: g l @: @: 12 @:calc-graph-log-x@:}
36213 @r{ @: g n @:name @: @:calc-graph-name@:}
36214 @r{ @: g p @: @: 42 @:calc-graph-plot@:}
36215 @r{ @: g q @: @: @:calc-graph-quit@:}
36216 @r{ @: g r @:range @: @:calc-graph-range-x@:}
36217 @r{ @: g s @: @: 12,13 @:calc-graph-line-style@:}
36218 @r{ @: g t @:title @: @:calc-graph-title-x@:}
36219 @r{ @: g v @: @: @:calc-graph-view-commands@:}
36220 @r{ @: g x @:display @: @:calc-graph-display@:}
36221 @r{ @: g z @: @: 12 @:calc-graph-zero-x@:}
36224 @r{ x y z@: g A @: @: 28,40 @:calc-graph-add-3d@:}
36225 @r{ @: g C @:command @: @:calc-graph-command@:}
36226 @r{ @: g D @:device @: 43,44 @:calc-graph-device@:}
36227 @r{ x y z@: g F @: @: 28,40 @:calc-graph-fast-3d@:}
36228 @r{ @: g H @: @: 12 @:calc-graph-hide@:}
36229 @r{ @: g K @: @: @:calc-graph-kill@:}
36230 @r{ @: g L @: @: 12 @:calc-graph-log-y@:}
36231 @r{ @: g N @:number @: 43,51 @:calc-graph-num-points@:}
36232 @r{ @: g O @:filename @: 43,44 @:calc-graph-output@:}
36233 @r{ @: g P @: @: 42 @:calc-graph-print@:}
36234 @r{ @: g R @:range @: @:calc-graph-range-y@:}
36235 @r{ @: g S @: @: 12,13 @:calc-graph-point-style@:}
36236 @r{ @: g T @:title @: @:calc-graph-title-y@:}
36237 @r{ @: g V @: @: @:calc-graph-view-trail@:}
36238 @r{ @: g X @:format @: @:calc-graph-geometry@:}
36239 @r{ @: g Z @: @: 12 @:calc-graph-zero-y@:}
36242 @r{ @: g C-l @: @: 12 @:calc-graph-log-z@:}
36243 @r{ @: g C-r @:range @: @:calc-graph-range-z@:}
36244 @r{ @: g C-t @:title @: @:calc-graph-title-z@:}
36247 @r{ @: h b @: @: @:calc-describe-bindings@:}
36248 @r{ @: h c @:key @: @:calc-describe-key-briefly@:}
36249 @r{ @: h f @:function @: @:calc-describe-function@:}
36250 @r{ @: h h @: @: @:calc-full-help@:}
36251 @r{ @: h i @: @: @:calc-info@:}
36252 @r{ @: h k @:key @: @:calc-describe-key@:}
36253 @r{ @: h n @: @: @:calc-view-news@:}
36254 @r{ @: h s @: @: @:calc-info-summary@:}
36255 @r{ @: h t @: @: @:calc-tutorial@:}
36256 @r{ @: h v @:var @: @:calc-describe-variable@:}
36259 @r{ @: j 1-9 @: @: @:calc-select-part@:}
36260 @r{ @: j @summarykey{RET} @: @: 27 @:calc-copy-selection@:}
36261 @r{ @: j @summarykey{DEL} @: @: 27 @:calc-del-selection@:}
36262 @r{ @: j ' @:formula @: 27 @:calc-enter-selection@:}
36263 @r{ @: j ` @:editing @: 27,30 @:calc-edit-selection@:}
36264 @r{ @: j " @: @: 7,27 @:calc-sel-expand-formula@:}
36267 @r{ @: j + @:formula @: 27 @:calc-sel-add-both-sides@:}
36268 @r{ @: j - @:formula @: 27 @:calc-sel-sub-both-sides@:}
36269 @r{ @: j * @:formula @: 27 @:calc-sel-mul-both-sides@:}
36270 @r{ @: j / @:formula @: 27 @:calc-sel-div-both-sides@:}
36271 @r{ @: j & @: @: 27 @:calc-sel-invert@:}
36274 @r{ @: j a @: @: 27 @:calc-select-additional@:}
36275 @r{ @: j b @: @: 12 @:calc-break-selections@:}
36276 @r{ @: j c @: @: @:calc-clear-selections@:}
36277 @r{ @: j d @: @: 12,50 @:calc-show-selections@:}
36278 @r{ @: j e @: @: 12 @:calc-enable-selections@:}
36279 @r{ @: j l @: @: 4,27 @:calc-select-less@:}
36280 @r{ @: j m @: @: 4,27 @:calc-select-more@:}
36281 @r{ @: j n @: @: 4 @:calc-select-next@:}
36282 @r{ @: j o @: @: 4,27 @:calc-select-once@:}
36283 @r{ @: j p @: @: 4 @:calc-select-previous@:}
36284 @r{ @: j r @:rules @:4,8,27 @:calc-rewrite-selection@:}
36285 @r{ @: j s @: @: 4,27 @:calc-select-here@:}
36286 @r{ @: j u @: @: 27 @:calc-unselect@:}
36287 @r{ @: j v @: @: 7,27 @:calc-sel-evaluate@:}
36290 @r{ @: j C @: @: 27 @:calc-sel-commute@:}
36291 @r{ @: j D @: @: 4,27 @:calc-sel-distribute@:}
36292 @r{ @: j E @: @: 27 @:calc-sel-jump-equals@:}
36293 @r{ @: j I @: @: 27 @:calc-sel-isolate@:}
36294 @r{ @: H j I @: @: 27 @:calc-sel-isolate@: (full)}
36295 @r{ @: j L @: @: 4,27 @:calc-commute-left@:}
36296 @r{ @: j M @: @: 27 @:calc-sel-merge@:}
36297 @r{ @: j N @: @: 27 @:calc-sel-negate@:}
36298 @r{ @: j O @: @: 4,27 @:calc-select-once-maybe@:}
36299 @r{ @: j R @: @: 4,27 @:calc-commute-right@:}
36300 @r{ @: j S @: @: 4,27 @:calc-select-here-maybe@:}
36301 @r{ @: j U @: @: 27 @:calc-sel-unpack@:}
36304 @r{ @: k a @: @: @:calc-random-again@:}
36305 @r{ n@: k b @: @: 1 @:bern@:(n)}
36306 @r{ n x@: H k b @: @: 2 @:bern@:(n,x)}
36307 @r{ n m@: k c @: @: 2 @:choose@:(n,m)}
36308 @r{ n m@: H k c @: @: 2 @:perm@:(n,m)}
36309 @r{ n@: k d @: @: 1 @:dfact@:(n) n!!}
36310 @r{ n@: k e @: @: 1 @:euler@:(n)}
36311 @r{ n x@: H k e @: @: 2 @:euler@:(n,x)}
36312 @r{ n@: k f @: @: 4 @:prfac@:(n)}
36313 @r{ n m@: k g @: @: 2 @:gcd@:(n,m)}
36314 @r{ m n@: k h @: @: 14 @:shuffle@:(n,m)}
36315 @r{ n m@: k l @: @: 2 @:lcm@:(n,m)}
36316 @r{ n@: k m @: @: 1 @:moebius@:(n)}
36317 @r{ n@: k n @: @: 4 @:nextprime@:(n)}
36318 @r{ n@: I k n @: @: 4 @:prevprime@:(n)}
36319 @r{ n@: k p @: @: 4,28 @:calc-prime-test@:}
36320 @r{ m@: k r @: @: 14 @:random@:(m)}
36321 @r{ n m@: k s @: @: 2 @:stir1@:(n,m)}
36322 @r{ n m@: H k s @: @: 2 @:stir2@:(n,m)}
36323 @r{ n@: k t @: @: 1 @:totient@:(n)}
36326 @r{ n p x@: k B @: @: @:utpb@:(x,n,p)}
36327 @r{ n p x@: I k B @: @: @:ltpb@:(x,n,p)}
36328 @r{ v x@: k C @: @: @:utpc@:(x,v)}
36329 @r{ v x@: I k C @: @: @:ltpc@:(x,v)}
36330 @r{ n m@: k E @: @: @:egcd@:(n,m)}
36331 @r{v1 v2 x@: k F @: @: @:utpf@:(x,v1,v2)}
36332 @r{v1 v2 x@: I k F @: @: @:ltpf@:(x,v1,v2)}
36333 @r{ m s x@: k N @: @: @:utpn@:(x,m,s)}
36334 @r{ m s x@: I k N @: @: @:ltpn@:(x,m,s)}
36335 @r{ m x@: k P @: @: @:utpp@:(x,m)}
36336 @r{ m x@: I k P @: @: @:ltpp@:(x,m)}
36337 @r{ v x@: k T @: @: @:utpt@:(x,v)}
36338 @r{ v x@: I k T @: @: @:ltpt@:(x,v)}
36341 @r{ a b@: l + @: @: @:lupadd@:(a,b)}
36342 @r{ a b@: H l + @: @: @:lufadd@:(a,b)}
36343 @r{ a b@: l - @: @: @:lupsub@:(a,b)}
36344 @r{ a b@: H l - @: @: @:lufsub@:(a,b)}
36345 @r{ a b@: l * @: @: @:lupmul@:(a,b)}
36346 @r{ a b@: H l * @: @: @:lufmul@:(a,b)}
36347 @r{ a b@: l / @: @: @:lupdiv@:(a,b)}
36348 @r{ a b@: H l / @: @: @:lufdiv@:(a,b)}
36349 @r{ a@: l d @: @: @:dbpower@:(a)}
36350 @r{ a b@: O l d @: @: @:dbpower@:(a,b)}
36351 @r{ a@: H l d @: @: @:dbfield@:(a)}
36352 @r{ a b@: O H l d @: @: @:dbfield@:(a,b)}
36353 @r{ a@: l n @: @: @:nppower@:(a)}
36354 @r{ a b@: O l n @: @: @:nppower@:(a,b)}
36355 @r{ a@: H l n @: @: @:npfield@:(a)}
36356 @r{ a b@: O H l n @: @: @:npfield@:(a,b)}
36357 @r{ a@: l q @: @: @:lupquant@:(a)}
36358 @r{ a b@: O l q @: @: @:lupquant@:(a,b)}
36359 @r{ a@: H l q @: @: @:lufquant@:(a)}
36360 @r{ a b@: O H l q @: @: @:lufquant@:(a,b)}
36361 @r{ a@: l s @: @: @:spn@:(a)}
36362 @r{ a@: l m @: @: @:midi@:(a)}
36363 @r{ a@: l f @: @: @:freq@:(a)}
36366 @r{ @: m a @: @: 12,13 @:calc-algebraic-mode@:}
36367 @r{ @: m d @: @: @:calc-degrees-mode@:}
36368 @r{ @: m e @: @: @:calc-embedded-preserve-modes@:}
36369 @r{ @: m f @: @: 12 @:calc-frac-mode@:}
36370 @r{ @: m g @: @: 52 @:calc-get-modes@:}
36371 @r{ @: m h @: @: @:calc-hms-mode@:}
36372 @r{ @: m i @: @: 12,13 @:calc-infinite-mode@:}
36373 @r{ @: m m @: @: @:calc-save-modes@:}
36374 @r{ @: m p @: @: 12 @:calc-polar-mode@:}
36375 @r{ @: m r @: @: @:calc-radians-mode@:}
36376 @r{ @: m s @: @: 12 @:calc-symbolic-mode@:}
36377 @r{ @: m t @: @: 12 @:calc-total-algebraic-mode@:}
36378 @r{ @: m v @: @: 12,13 @:calc-matrix-mode@:}
36379 @r{ @: m w @: @: 13 @:calc-working@:}
36380 @r{ @: m x @: @: @:calc-always-load-extensions@:}
36383 @r{ @: m A @: @: 12 @:calc-alg-simplify-mode@:}
36384 @r{ @: m B @: @: 12 @:calc-bin-simplify-mode@:}
36385 @r{ @: m C @: @: 12 @:calc-auto-recompute@:}
36386 @r{ @: m D @: @: @:calc-default-simplify-mode@:}
36387 @r{ @: m E @: @: 12 @:calc-ext-simplify-mode@:}
36388 @r{ @: m F @:filename @: 13 @:calc-settings-file-name@:}
36389 @r{ @: m N @: @: 12 @:calc-num-simplify-mode@:}
36390 @r{ @: m O @: @: 12 @:calc-no-simplify-mode@:}
36391 @r{ @: m R @: @: 12,13 @:calc-mode-record-mode@:}
36392 @r{ @: m S @: @: 12 @:calc-shift-prefix@:}
36393 @r{ @: m U @: @: 12 @:calc-units-simplify-mode@:}
36396 @r{ @: r s @:register @: 27 @:calc-copy-to-register@:}
36397 @r{ @: r i @:register @: @:calc-insert-register@:}
36400 @r{ @: s c @:var1, var2 @: 29 @:calc-copy-variable@:}
36401 @r{ @: s d @:var, decl @: @:calc-declare-variable@:}
36402 @r{ @: s e @:var, editing @: 29,30 @:calc-edit-variable@:}
36403 @r{ @: s i @:buffer @: @:calc-insert-variables@:}
36404 @r{ @: s k @:const, var @: 29 @:calc-copy-special-constant@:}
36405 @r{ a b@: s l @:var @: 29 @:@:a (letting var=b)}
36406 @r{ a ...@: s m @:op, var @: 22,29 @:calc-store-map@:}
36407 @r{ @: s n @:var @: 29,47 @:calc-store-neg@: (v/-1)}
36408 @r{ @: s p @:var @: 29 @:calc-permanent-variable@:}
36409 @r{ @: s r @:var @: 29 @:@:v (recalled value)}
36410 @r{ @: r 0-9 @: @: @:calc-recall-quick@:}
36411 @r{ a@: s s @:var @: 28,29 @:calc-store@:}
36412 @r{ a@: s 0-9 @: @: @:calc-store-quick@:}
36413 @r{ a@: s t @:var @: 29 @:calc-store-into@:}
36414 @r{ a@: t 0-9 @: @: @:calc-store-into-quick@:}
36415 @r{ @: s u @:var @: 29 @:calc-unstore@:}
36416 @r{ a@: s x @:var @: 29 @:calc-store-exchange@:}
36419 @r{ @: s A @:editing @: 30 @:calc-edit-AlgSimpRules@:}
36420 @r{ @: s D @:editing @: 30 @:calc-edit-Decls@:}
36421 @r{ @: s E @:editing @: 30 @:calc-edit-EvalRules@:}
36422 @r{ @: s F @:editing @: 30 @:calc-edit-FitRules@:}
36423 @r{ @: s G @:editing @: 30 @:calc-edit-GenCount@:}
36424 @r{ @: s H @:editing @: 30 @:calc-edit-Holidays@:}
36425 @r{ @: s I @:editing @: 30 @:calc-edit-IntegLimit@:}
36426 @r{ @: s L @:editing @: 30 @:calc-edit-LineStyles@:}
36427 @r{ @: s P @:editing @: 30 @:calc-edit-PointStyles@:}
36428 @r{ @: s R @:editing @: 30 @:calc-edit-PlotRejects@:}
36429 @r{ @: s T @:editing @: 30 @:calc-edit-TimeZone@:}
36430 @r{ @: s U @:editing @: 30 @:calc-edit-Units@:}
36431 @r{ @: s X @:editing @: 30 @:calc-edit-ExtSimpRules@:}
36434 @r{ a@: s + @:var @: 29,47 @:calc-store-plus@: (v+a)}
36435 @r{ a@: s - @:var @: 29,47 @:calc-store-minus@: (v-a)}
36436 @r{ a@: s * @:var @: 29,47 @:calc-store-times@: (v*a)}
36437 @r{ a@: s / @:var @: 29,47 @:calc-store-div@: (v/a)}
36438 @r{ a@: s ^ @:var @: 29,47 @:calc-store-power@: (v^a)}
36439 @r{ a@: s | @:var @: 29,47 @:calc-store-concat@: (v|a)}
36440 @r{ @: s & @:var @: 29,47 @:calc-store-inv@: (v^-1)}
36441 @r{ @: s [ @:var @: 29,47 @:calc-store-decr@: (v-1)}
36442 @r{ @: s ] @:var @: 29,47 @:calc-store-incr@: (v-(-1))}
36443 @r{ a b@: s : @: @: 2 @:assign@:(a,b) a @tfn{:=} b}
36444 @r{ a@: s = @: @: 1 @:evalto@:(a,b) a @tfn{=>}}
36447 @r{ @: t [ @: @: 4 @:calc-trail-first@:}
36448 @r{ @: t ] @: @: 4 @:calc-trail-last@:}
36449 @r{ @: t < @: @: 4 @:calc-trail-scroll-left@:}
36450 @r{ @: t > @: @: 4 @:calc-trail-scroll-right@:}
36451 @r{ @: t . @: @: 12 @:calc-full-trail-vectors@:}
36454 @r{ @: t b @: @: 4 @:calc-trail-backward@:}
36455 @r{ @: t d @: @: 12,50 @:calc-trail-display@:}
36456 @r{ @: t f @: @: 4 @:calc-trail-forward@:}
36457 @r{ @: t h @: @: @:calc-trail-here@:}
36458 @r{ @: t i @: @: @:calc-trail-in@:}
36459 @r{ @: t k @: @: 4 @:calc-trail-kill@:}
36460 @r{ @: t m @:string @: @:calc-trail-marker@:}
36461 @r{ @: t n @: @: 4 @:calc-trail-next@:}
36462 @r{ @: t o @: @: @:calc-trail-out@:}
36463 @r{ @: t p @: @: 4 @:calc-trail-previous@:}
36464 @r{ @: t r @:string @: @:calc-trail-isearch-backward@:}
36465 @r{ @: t s @:string @: @:calc-trail-isearch-forward@:}
36466 @r{ @: t y @: @: 4 @:calc-trail-yank@:}
36469 @r{ d@: t C @:oz, nz @: @:tzconv@:(d,oz,nz)}
36470 @r{d oz nz@: t C @:$ @: @:tzconv@:(d,oz,nz)}
36471 @r{ d@: t D @: @: 15 @:date@:(d)}
36472 @r{ d@: t I @: @: 4 @:incmonth@:(d,n)}
36473 @r{ d@: t J @: @: 16 @:julian@:(d,z)}
36474 @r{ d@: t M @: @: 17 @:newmonth@:(d,n)}
36475 @r{ @: t N @: @: 16 @:now@:(z)}
36476 @r{ d@: t P @:1 @: 31 @:year@:(d)}
36477 @r{ d@: t P @:2 @: 31 @:month@:(d)}
36478 @r{ d@: t P @:3 @: 31 @:day@:(d)}
36479 @r{ d@: t P @:4 @: 31 @:hour@:(d)}
36480 @r{ d@: t P @:5 @: 31 @:minute@:(d)}
36481 @r{ d@: t P @:6 @: 31 @:second@:(d)}
36482 @r{ d@: t P @:7 @: 31 @:weekday@:(d)}
36483 @r{ d@: t P @:8 @: 31 @:yearday@:(d)}
36484 @r{ d@: t P @:9 @: 31 @:time@:(d)}
36485 @r{ d@: t U @: @: 16 @:unixtime@:(d,z)}
36486 @r{ d@: t W @: @: 17 @:newweek@:(d,w)}
36487 @r{ d@: t Y @: @: 17 @:newyear@:(d,n)}
36490 @r{ a b@: t + @: @: 2 @:badd@:(a,b)}
36491 @r{ a b@: t - @: @: 2 @:bsub@:(a,b)}
36494 @r{ @: u a @: @: 12 @:calc-autorange-units@:}
36495 @r{ a@: u b @: @: @:calc-base-units@:}
36496 @r{ a@: u c @:units @: 18 @:calc-convert-units@:}
36497 @r{ defn@: u d @:unit, descr @: @:calc-define-unit@:}
36498 @r{ @: u e @: @: @:calc-explain-units@:}
36499 @r{ @: u g @:unit @: @:calc-get-unit-definition@:}
36500 @r{ @: u p @: @: @:calc-permanent-units@:}
36501 @r{ a@: u r @: @: @:calc-remove-units@:}
36502 @r{ a@: u s @: @: @:usimplify@:(a)}
36503 @r{ a@: u t @:units @: 18 @:calc-convert-temperature@:}
36504 @r{ @: u u @:unit @: @:calc-undefine-unit@:}
36505 @r{ @: u v @: @: @:calc-enter-units-table@:}
36506 @r{ a@: u x @: @: @:calc-extract-units@:}
36507 @r{ a@: u 0-9 @: @: @:calc-quick-units@:}
36510 @r{ v1 v2@: u C @: @: 20 @:vcov@:(v1,v2)}
36511 @r{ v1 v2@: I u C @: @: 20 @:vpcov@:(v1,v2)}
36512 @r{ v1 v2@: H u C @: @: 20 @:vcorr@:(v1,v2)}
36513 @r{ v@: u G @: @: 19 @:vgmean@:(v)}
36514 @r{ a b@: H u G @: @: 2 @:agmean@:(a,b)}
36515 @r{ v@: u M @: @: 19 @:vmean@:(v)}
36516 @r{ v@: I u M @: @: 19 @:vmeane@:(v)}
36517 @r{ v@: H u M @: @: 19 @:vmedian@:(v)}
36518 @r{ v@: I H u M @: @: 19 @:vhmean@:(v)}
36519 @r{ v@: u N @: @: 19 @:vmin@:(v)}
36520 @r{ v@: u S @: @: 19 @:vsdev@:(v)}
36521 @r{ v@: I u S @: @: 19 @:vpsdev@:(v)}
36522 @r{ v@: H u S @: @: 19 @:vvar@:(v)}
36523 @r{ v@: I H u S @: @: 19 @:vpvar@:(v)}
36524 @r{ @: u V @: @: @:calc-view-units-table@:}
36525 @r{ v@: u X @: @: 19 @:vmax@:(v)}
36528 @r{ v@: u + @: @: 19 @:vsum@:(v)}
36529 @r{ v@: u * @: @: 19 @:vprod@:(v)}
36530 @r{ v@: u # @: @: 19 @:vcount@:(v)}
36533 @r{ @: V ( @: @: 50 @:calc-vector-parens@:}
36534 @r{ @: V @{ @: @: 50 @:calc-vector-braces@:}
36535 @r{ @: V [ @: @: 50 @:calc-vector-brackets@:}
36536 @r{ @: V ] @:ROCP @: 50 @:calc-matrix-brackets@:}
36537 @r{ @: V , @: @: 50 @:calc-vector-commas@:}
36538 @r{ @: V < @: @: 50 @:calc-matrix-left-justify@:}
36539 @r{ @: V = @: @: 50 @:calc-matrix-center-justify@:}
36540 @r{ @: V > @: @: 50 @:calc-matrix-right-justify@:}
36541 @r{ @: V / @: @: 12,50 @:calc-break-vectors@:}
36542 @r{ @: V . @: @: 12,50 @:calc-full-vectors@:}
36545 @r{ s t@: V ^ @: @: 2 @:vint@:(s,t)}
36546 @r{ s t@: V - @: @: 2 @:vdiff@:(s,t)}
36547 @r{ s@: V ~ @: @: 1 @:vcompl@:(s)}
36548 @r{ s@: V # @: @: 1 @:vcard@:(s)}
36549 @r{ s@: V : @: @: 1 @:vspan@:(s)}
36550 @r{ s@: V + @: @: 1 @:rdup@:(s)}
36553 @r{ m@: V & @: @: 1 @:inv@:(m) 1/m}
36556 @r{ v@: v a @:n @: @:arrange@:(v,n)}
36557 @r{ a@: v b @:n @: @:cvec@:(a,n)}
36558 @r{ v@: v c @:n >0 @: 21,31 @:mcol@:(v,n)}
36559 @r{ v@: v c @:n <0 @: 31 @:mrcol@:(v,-n)}
36560 @r{ m@: v c @:0 @: 31 @:getdiag@:(m)}
36561 @r{ v@: v d @: @: 25 @:diag@:(v,n)}
36562 @r{ v m@: v e @: @: 2 @:vexp@:(v,m)}
36563 @r{ v m f@: H v e @: @: 2 @:vexp@:(v,m,f)}
36564 @r{ v a@: v f @: @: 26 @:find@:(v,a,n)}
36565 @r{ v@: v h @: @: 1 @:head@:(v)}
36566 @r{ v@: I v h @: @: 1 @:tail@:(v)}
36567 @r{ v@: H v h @: @: 1 @:rhead@:(v)}
36568 @r{ v@: I H v h @: @: 1 @:rtail@:(v)}
36569 @r{ @: v i @:n @: 31 @:idn@:(1,n)}
36570 @r{ @: v i @:0 @: 31 @:idn@:(1)}
36571 @r{ h t@: v k @: @: 2 @:cons@:(h,t)}
36572 @r{ h t@: H v k @: @: 2 @:rcons@:(h,t)}
36573 @r{ v@: v l @: @: 1 @:vlen@:(v)}
36574 @r{ v@: H v l @: @: 1 @:mdims@:(v)}
36575 @r{ v m@: v m @: @: 2 @:vmask@:(v,m)}
36576 @r{ v@: v n @: @: 1 @:rnorm@:(v)}
36577 @r{ a b c@: v p @: @: 24 @:calc-pack@:}
36578 @r{ v@: v r @:n >0 @: 21,31 @:mrow@:(v,n)}
36579 @r{ v@: v r @:n <0 @: 31 @:mrrow@:(v,-n)}
36580 @r{ m@: v r @:0 @: 31 @:getdiag@:(m)}
36581 @r{ v i j@: v s @: @: @:subvec@:(v,i,j)}
36582 @r{ v i j@: I v s @: @: @:rsubvec@:(v,i,j)}
36583 @r{ m@: v t @: @: 1 @:trn@:(m)}
36584 @r{ v@: v u @: @: 24 @:calc-unpack@:}
36585 @r{ v@: v v @: @: 1 @:rev@:(v)}
36586 @r{ @: v x @:n @: 31 @:index@:(n)}
36587 @r{ n s i@: C-u v x @: @: @:index@:(n,s,i)}
36590 @r{ v@: V A @:op @: 22 @:apply@:(op,v)}
36591 @r{ v1 v2@: V C @: @: 2 @:cross@:(v1,v2)}
36592 @r{ m@: V D @: @: 1 @:det@:(m)}
36593 @r{ s@: V E @: @: 1 @:venum@:(s)}
36594 @r{ s@: V F @: @: 1 @:vfloor@:(s)}
36595 @r{ v@: V G @: @: @:grade@:(v)}
36596 @r{ v@: I V G @: @: @:rgrade@:(v)}
36597 @r{ v@: V H @:n @: 31 @:histogram@:(v,n)}
36598 @r{ v w@: H V H @:n @: 31 @:histogram@:(v,w,n)}
36599 @r{ v1 v2@: V I @:mop aop @: 22 @:inner@:(mop,aop,v1,v2)}
36600 @r{ m@: V J @: @: 1 @:ctrn@:(m)}
36601 @r{ m1 m2@: V K @: @: @:kron@:(m1,m2)}
36602 @r{ m@: V L @: @: 1 @:lud@:(m)}
36603 @r{ v@: V M @:op @: 22,23 @:map@:(op,v)}
36604 @r{ v@: V N @: @: 1 @:cnorm@:(v)}
36605 @r{ v1 v2@: V O @:op @: 22 @:outer@:(op,v1,v2)}
36606 @r{ v@: V R @:op @: 22,23 @:reduce@:(op,v)}
36607 @r{ v@: I V R @:op @: 22,23 @:rreduce@:(op,v)}
36608 @r{ a n@: H V R @:op @: 22 @:nest@:(op,a,n)}
36609 @r{ a@: I H V R @:op @: 22 @:fixp@:(op,a)}
36610 @r{ v@: V S @: @: @:sort@:(v)}
36611 @r{ v@: I V S @: @: @:rsort@:(v)}
36612 @r{ m@: V T @: @: 1 @:tr@:(m)}
36613 @r{ v@: V U @:op @: 22 @:accum@:(op,v)}
36614 @r{ v@: I V U @:op @: 22 @:raccum@:(op,v)}
36615 @r{ a n@: H V U @:op @: 22 @:anest@:(op,a,n)}
36616 @r{ a@: I H V U @:op @: 22 @:afixp@:(op,a)}
36617 @r{ s t@: V V @: @: 2 @:vunion@:(s,t)}
36618 @r{ s t@: V X @: @: 2 @:vxor@:(s,t)}
36621 @r{ @: Y @: @: @:@:user commands}
36624 @r{ @: z @: @: @:@:user commands}
36627 @r{ c@: Z [ @: @: 45 @:calc-kbd-if@:}
36628 @r{ c@: Z | @: @: 45 @:calc-kbd-else-if@:}
36629 @r{ @: Z : @: @: @:calc-kbd-else@:}
36630 @r{ @: Z ] @: @: @:calc-kbd-end-if@:}
36633 @r{ @: Z @{ @: @: 4 @:calc-kbd-loop@:}
36634 @r{ c@: Z / @: @: 45 @:calc-kbd-break@:}
36635 @r{ @: Z @} @: @: @:calc-kbd-end-loop@:}
36636 @r{ n@: Z < @: @: @:calc-kbd-repeat@:}
36637 @r{ @: Z > @: @: @:calc-kbd-end-repeat@:}
36638 @r{ n m@: Z ( @: @: @:calc-kbd-for@:}
36639 @r{ s@: Z ) @: @: @:calc-kbd-end-for@:}
36642 @r{ @: Z C-g @: @: @:@:cancel if/loop command}
36645 @r{ @: Z ` @: @: @:calc-kbd-push@:}
36646 @r{ @: Z ' @: @: @:calc-kbd-pop@:}
36647 @r{ @: Z # @: @: @:calc-kbd-query@:}
36650 @r{ comp@: Z C @:func, args @: 50 @:calc-user-define-composition@:}
36651 @r{ @: Z D @:key, command @: @:calc-user-define@:}
36652 @r{ @: Z E @:key, editing @: 30 @:calc-user-define-edit@:}
36653 @r{ defn@: Z F @:k, c, f, a, n@: 28 @:calc-user-define-formula@:}
36654 @r{ @: Z G @:key @: @:calc-get-user-defn@:}
36655 @r{ @: Z I @: @: @:calc-user-define-invocation@:}
36656 @r{ @: Z K @:key, command @: @:calc-user-define-kbd-macro@:}
36657 @r{ @: Z P @:key @: @:calc-user-define-permanent@:}
36658 @r{ @: Z S @: @: 30 @:calc-edit-user-syntax@:}
36659 @r{ @: Z T @: @: 12 @:calc-timing@:}
36660 @r{ @: Z U @:key @: @:calc-user-undefine@:}
36670 Positive prefix arguments apply to @expr{n} stack entries.
36671 Negative prefix arguments apply to the @expr{-n}th stack entry.
36672 A prefix of zero applies to the entire stack. (For @key{LFD} and
36673 @kbd{M-@key{DEL}}, the meaning of the sign is reversed.)
36677 Positive prefix arguments apply to @expr{n} stack entries.
36678 Negative prefix arguments apply to the top stack entry
36679 and the next @expr{-n} stack entries.
36683 Positive prefix arguments rotate top @expr{n} stack entries by one.
36684 Negative prefix arguments rotate the entire stack by @expr{-n}.
36685 A prefix of zero reverses the entire stack.
36689 Prefix argument specifies a repeat count or distance.
36693 Positive prefix arguments specify a precision @expr{p}.
36694 Negative prefix arguments reduce the current precision by @expr{-p}.
36698 A prefix argument is interpreted as an additional step-size parameter.
36699 A plain @kbd{C-u} prefix means to prompt for the step size.
36703 A prefix argument specifies simplification level and depth.
36704 1=Basic simplifications, 2=Algebraic simplifications, 3=Extended simplifications
36708 A negative prefix operates only on the top level of the input formula.
36712 Positive prefix arguments specify a word size of @expr{w} bits, unsigned.
36713 Negative prefix arguments specify a word size of @expr{w} bits, signed.
36717 Prefix arguments specify the shift amount @expr{n}. The @expr{w} argument
36718 cannot be specified in the keyboard version of this command.
36722 From the keyboard, @expr{d} is omitted and defaults to zero.
36726 Mode is toggled; a positive prefix always sets the mode, and a negative
36727 prefix always clears the mode.
36731 Some prefix argument values provide special variations of the mode.
36735 A prefix argument, if any, is used for @expr{m} instead of taking
36736 @expr{m} from the stack. @expr{M} may take any of these values:
36738 {@advance@tableindent10pt
36742 Random integer in the interval @expr{[0 .. m)}.
36744 Random floating-point number in the interval @expr{[0 .. m)}.
36746 Gaussian with mean 1 and standard deviation 0.
36748 Gaussian with specified mean and standard deviation.
36750 Random integer or floating-point number in that interval.
36752 Random element from the vector.
36760 A prefix argument from 1 to 6 specifies number of date components
36761 to remove from the stack. @xref{Date Conversions}.
36765 A prefix argument specifies a time zone; @kbd{C-u} says to take the
36766 time zone number or name from the top of the stack. @xref{Time Zones}.
36770 A prefix argument specifies a day number (0--6, 0--31, or 0--366).
36774 If the input has no units, you will be prompted for both the old and
36779 With a prefix argument, collect that many stack entries to form the
36780 input data set. Each entry may be a single value or a vector of values.
36784 With a prefix argument of 1, take a single
36785 @texline @var{n}@math{\times2}
36786 @infoline @mathit{@var{N}x2}
36787 matrix from the stack instead of two separate data vectors.
36791 The row or column number @expr{n} may be given as a numeric prefix
36792 argument instead. A plain @kbd{C-u} prefix says to take @expr{n}
36793 from the top of the stack. If @expr{n} is a vector or interval,
36794 a subvector/submatrix of the input is created.
36798 The @expr{op} prompt can be answered with the key sequence for the
36799 desired function, or with @kbd{x} or @kbd{z} followed by a function name,
36800 or with @kbd{$} to take a formula from the top of the stack, or with
36801 @kbd{'} and a typed formula. In the last two cases, the formula may
36802 be a nameless function like @samp{<#1+#2>} or @samp{<x, y : x+y>}, or it
36803 may include @kbd{$}, @kbd{$$}, etc. (where @kbd{$} will correspond to the
36804 last argument of the created function), or otherwise you will be
36805 prompted for an argument list. The number of vectors popped from the
36806 stack by @kbd{V M} depends on the number of arguments of the function.
36810 One of the mapping direction keys @kbd{_} (horizontal, i.e., map
36811 by rows or reduce across), @kbd{:} (vertical, i.e., map by columns or
36812 reduce down), or @kbd{=} (map or reduce by rows) may be used before
36813 entering @expr{op}; these modify the function name by adding the letter
36814 @code{r} for ``rows,'' @code{c} for ``columns,'' @code{a} for ``across,''
36815 or @code{d} for ``down.''
36819 The prefix argument specifies a packing mode. A nonnegative mode
36820 is the number of items (for @kbd{v p}) or the number of levels
36821 (for @kbd{v u}). A negative mode is as described below. With no
36822 prefix argument, the mode is taken from the top of the stack and
36823 may be an integer or a vector of integers.
36825 {@advance@tableindent-20pt
36829 (@var{2}) Rectangular complex number.
36831 (@var{2}) Polar complex number.
36833 (@var{3}) HMS form.
36835 (@var{2}) Error form.
36837 (@var{2}) Modulo form.
36839 (@var{2}) Closed interval.
36841 (@var{2}) Closed .. open interval.
36843 (@var{2}) Open .. closed interval.
36845 (@var{2}) Open interval.
36847 (@var{2}) Fraction.
36849 (@var{2}) Float with integer mantissa.
36851 (@var{2}) Float with mantissa in @expr{[1 .. 10)}.
36853 (@var{1}) Date form (using date numbers).
36855 (@var{3}) Date form (using year, month, day).
36857 (@var{6}) Date form (using year, month, day, hour, minute, second).
36865 A prefix argument specifies the size @expr{n} of the matrix. With no
36866 prefix argument, @expr{n} is omitted and the size is inferred from
36871 The prefix argument specifies the starting position @expr{n} (default 1).
36875 Cursor position within stack buffer affects this command.
36879 Arguments are not actually removed from the stack by this command.
36883 Variable name may be a single digit or a full name.
36887 Editing occurs in a separate buffer. Press @kbd{C-c C-c} (or
36888 @key{LFD}, or in some cases @key{RET}) to finish the edit, or kill the
36889 buffer with @kbd{C-x k} to cancel the edit. The @key{LFD} key prevents evaluation
36890 of the result of the edit.
36894 The number prompted for can also be provided as a prefix argument.
36898 Press this key a second time to cancel the prefix.
36902 With a negative prefix, deactivate all formulas. With a positive
36903 prefix, deactivate and then reactivate from scratch.
36907 Default is to scan for nearest formula delimiter symbols. With a
36908 prefix of zero, formula is delimited by mark and point. With a
36909 non-zero prefix, formula is delimited by scanning forward or
36910 backward by that many lines.
36914 Parse the region between point and mark as a vector. A nonzero prefix
36915 parses @var{n} lines before or after point as a vector. A zero prefix
36916 parses the current line as a vector. A @kbd{C-u} prefix parses the
36917 region between point and mark as a single formula.
36921 Parse the rectangle defined by point and mark as a matrix. A positive
36922 prefix @var{n} divides the rectangle into columns of width @var{n}.
36923 A zero or @kbd{C-u} prefix parses each line as one formula. A negative
36924 prefix suppresses special treatment of bracketed portions of a line.
36928 A numeric prefix causes the current language mode to be ignored.
36932 Responding to a prompt with a blank line answers that and all
36933 later prompts by popping additional stack entries.
36937 Answer for @expr{v} may also be of the form @expr{v = v_0} or
36942 With a positive prefix argument, stack contains many @expr{y}'s and one
36943 common @expr{x}. With a zero prefix, stack contains a vector of
36944 @expr{y}s and a common @expr{x}. With a negative prefix, stack
36945 contains many @expr{[x,y]} vectors. (For 3D plots, substitute
36946 @expr{z} for @expr{y} and @expr{x,y} for @expr{x}.)
36950 With any prefix argument, all curves in the graph are deleted.
36954 With a positive prefix, refines an existing plot with more data points.
36955 With a negative prefix, forces recomputation of the plot data.
36959 With any prefix argument, set the default value instead of the
36960 value for this graph.
36964 With a negative prefix argument, set the value for the printer.
36968 Condition is considered ``true'' if it is a nonzero real or complex
36969 number, or a formula whose value is known to be nonzero; it is ``false''
36974 Several formulas separated by commas are pushed as multiple stack
36975 entries. Trailing @kbd{)}, @kbd{]}, @kbd{@}}, @kbd{>}, and @kbd{"}
36976 delimiters may be omitted. The notation @kbd{$$$} refers to the value
36977 in stack level three, and causes the formula to replace the top three
36978 stack levels. The notation @kbd{$3} refers to stack level three without
36979 causing that value to be removed from the stack. Use @key{LFD} in place
36980 of @key{RET} to prevent evaluation; use @kbd{M-=} in place of @key{RET}
36981 to evaluate variables.
36985 The variable is replaced by the formula shown on the right. The
36986 Inverse flag reverses the order of the operands, e.g., @kbd{I s - x}
36988 @texline @math{x \coloneq a-x}.
36989 @infoline @expr{x := a-x}.
36993 Press @kbd{?} repeatedly to see how to choose a model. Answer the
36994 variables prompt with @expr{iv} or @expr{iv;pv} to specify
36995 independent and parameter variables. A positive prefix argument
36996 takes @mathit{@var{n}+1} vectors from the stack; a zero prefix takes a matrix
36997 and a vector from the stack.
37001 With a plain @kbd{C-u} prefix, replace the current region of the
37002 destination buffer with the yanked text instead of inserting.
37006 All stack entries are reformatted; the @kbd{H} prefix inhibits this.
37007 The @kbd{I} prefix sets the mode temporarily, redraws the top stack
37008 entry, then restores the original setting of the mode.
37012 A negative prefix sets the default 3D resolution instead of the
37013 default 2D resolution.
37017 This grabs a vector of the form [@var{prec}, @var{wsize}, @var{ssize},
37018 @var{radix}, @var{flfmt}, @var{ang}, @var{frac}, @var{symb}, @var{polar},
37019 @var{matrix}, @var{simp}, @var{inf}]. A prefix argument from 1 to 12
37020 grabs the @var{n}th mode value only.
37024 (Space is provided below for you to keep your own written notes.)
37032 @node Key Index, Command Index, Summary, Top
37033 @unnumbered Index of Key Sequences
37037 @node Command Index, Function Index, Key Index, Top
37038 @unnumbered Index of Calculator Commands
37040 Since all Calculator commands begin with the prefix @samp{calc-}, the
37041 @kbd{x} key has been provided as a variant of @kbd{M-x} which automatically
37042 types @samp{calc-} for you. Thus, @kbd{x last-args} is short for
37043 @kbd{M-x calc-last-args}.
37047 @node Function Index, Concept Index, Command Index, Top
37048 @unnumbered Index of Algebraic Functions
37050 This is a list of built-in functions and operators usable in algebraic
37051 expressions. Their full Lisp names are derived by adding the prefix
37052 @samp{calcFunc-}, as in @code{calcFunc-sqrt}.
37054 All functions except those noted with ``*'' have corresponding
37055 Calc keystrokes and can also be found in the Calc Summary.
37060 @node Concept Index, Variable Index, Function Index, Top
37061 @unnumbered Concept Index
37065 @node Variable Index, Lisp Function Index, Concept Index, Top
37066 @unnumbered Index of Variables
37068 The variables in this list that do not contain dashes are accessible
37069 as Calc variables. Add a @samp{var-} prefix to get the name of the
37070 corresponding Lisp variable.
37072 The remaining variables are Lisp variables suitable for @code{setq}ing
37073 in your Calc init file or @file{.emacs} file.
37077 @node Lisp Function Index, , Variable Index, Top
37078 @unnumbered Index of Lisp Math Functions
37080 The following functions are meant to be used with @code{defmath}, not
37081 @code{defun} definitions. For names that do not start with @samp{calc-},
37082 the corresponding full Lisp name is derived by adding a prefix of