1 \input texinfo @c -*-texinfo-*-
2 @comment %**start of header (This is for running Texinfo on a region.)
4 @setfilename ../../info/calc
6 @settitle GNU Emacs Calc Manual
8 @comment %**end of header (This is for running Texinfo on a region.)
10 @include emacsver.texi
12 @c The following macros are used for conditional output for single lines.
14 @c `foo' will appear only in TeX output
16 @c `foo' will appear only in non-TeX output
18 @c @expr{expr} will typeset an expression;
19 @c $x$ in TeX, @samp{x} otherwise.
24 @alias infoline=comment
38 @alias texline=comment
39 @macro infoline{stuff}
58 % Suggested by Karl Berry <karl@@freefriends.org>
59 \gdef\!{\mskip-\thinmuskip}
62 @c Fix some other things specifically for this manual.
65 @mathcode`@:=`@: @c Make Calc fractions come out right in math mode
67 \gdef\coloneq{\mathrel{\mathord:\mathord=}}
69 \gdef\beforedisplay{\vskip-10pt}
70 \gdef\afterdisplay{\vskip-5pt}
71 \gdef\beforedisplayh{\vskip-25pt}
72 \gdef\afterdisplayh{\vskip-10pt}
74 @newdimen@kyvpos @kyvpos=0pt
75 @newdimen@kyhpos @kyhpos=0pt
76 @newcount@calcclubpenalty @calcclubpenalty=1000
79 @newtoks@calcoldeverypar @calcoldeverypar=@everypar
80 @everypar={@calceverypar@the@calcoldeverypar}
81 @ifx@ninett@undefinedzzz@font@ninett=cmtt9@fi
82 @catcode`@\=0 \catcode`\@=11
84 \catcode`\@=0 @catcode`@\=@active
90 This file documents Calc, the GNU Emacs calculator.
93 This file documents Calc, the GNU Emacs calculator, included with
94 GNU Emacs @value{EMACSVER}.
97 Copyright @copyright{} 1990, 1991, 2001, 2002, 2003, 2004,
98 2005, 2006, 2007, 2008, 2009, 2010, 2011 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. Buying copies from the FSF supports it in
111 developing GNU and promoting software freedom.''
117 * Calc: (calc). Advanced desk calculator and mathematical tool.
122 @center @titlefont{Calc Manual}
124 @center GNU Emacs Calc
127 @center Dave Gillespie
128 @center daveg@@synaptics.com
131 @vskip 0pt plus 1filll
144 @node Top, Getting Started, (dir), (dir)
145 @chapter The GNU Emacs Calculator
148 @dfn{Calc} is an advanced desk calculator and mathematical tool
149 written by Dave Gillespie that runs as part of the GNU Emacs environment.
151 This manual, also written (mostly) by Dave Gillespie, is divided into
152 three major parts: ``Getting Started,'' the ``Calc Tutorial,'' and the
153 ``Calc Reference.'' The Tutorial introduces all the major aspects of
154 Calculator use in an easy, hands-on way. The remainder of the manual is
155 a complete reference to the features of the Calculator.
159 For help in the Emacs Info system (which you are using to read this
160 file), type @kbd{?}. (You can also type @kbd{h} to run through a
161 longer Info tutorial.)
167 * Getting Started:: General description and overview.
169 * Interactive Tutorial::
171 * Tutorial:: A step-by-step introduction for beginners.
173 * Introduction:: Introduction to the Calc reference manual.
174 * Data Types:: Types of objects manipulated by Calc.
175 * Stack and Trail:: Manipulating the stack and trail buffers.
176 * Mode Settings:: Adjusting display format and other modes.
177 * Arithmetic:: Basic arithmetic functions.
178 * Scientific Functions:: Transcendentals and other scientific functions.
179 * Matrix Functions:: Operations on vectors and matrices.
180 * Algebra:: Manipulating expressions algebraically.
181 * Units:: Operations on numbers with units.
182 * Store and Recall:: Storing and recalling variables.
183 * Graphics:: Commands for making graphs of data.
184 * Kill and Yank:: Moving data into and out of Calc.
185 * Keypad Mode:: Operating Calc from a keypad.
186 * Embedded Mode:: Working with formulas embedded in a file.
187 * Programming:: Calc as a programmable calculator.
189 * Copying:: How you can copy and share Calc.
190 * GNU Free Documentation License:: The license for this documentation.
191 * Customizing Calc:: Customizing Calc.
192 * Reporting Bugs:: How to report bugs and make suggestions.
194 * Summary:: Summary of Calc commands and functions.
196 * Key Index:: The standard Calc key sequences.
197 * Command Index:: The interactive Calc commands.
198 * Function Index:: Functions (in algebraic formulas).
199 * Concept Index:: General concepts.
200 * Variable Index:: Variables used by Calc (both user and internal).
201 * Lisp Function Index:: Internal Lisp math functions.
205 @node Getting Started, Interactive Tutorial, Top, Top
208 @node Getting Started, Tutorial, Top, Top
210 @chapter Getting Started
212 This chapter provides a general overview of Calc, the GNU Emacs
213 Calculator: What it is, how to start it and how to exit from it,
214 and what are the various ways that it can be used.
218 * About This Manual::
219 * Notations Used in This Manual::
220 * Demonstration of Calc::
222 * History and Acknowledgements::
225 @node What is Calc, About This Manual, Getting Started, Getting Started
226 @section What is Calc?
229 @dfn{Calc} is an advanced calculator and mathematical tool that runs as
230 part of the GNU Emacs environment. Very roughly based on the HP-28/48
231 series of calculators, its many features include:
235 Choice of algebraic or RPN (stack-based) entry of calculations.
238 Arbitrary precision integers and floating-point numbers.
241 Arithmetic on rational numbers, complex numbers (rectangular and polar),
242 error forms with standard deviations, open and closed intervals, vectors
243 and matrices, dates and times, infinities, sets, quantities with units,
244 and algebraic formulas.
247 Mathematical operations such as logarithms and trigonometric functions.
250 Programmer's features (bitwise operations, non-decimal numbers).
253 Financial functions such as future value and internal rate of return.
256 Number theoretical features such as prime factorization and arithmetic
257 modulo @var{m} for any @var{m}.
260 Algebraic manipulation features, including symbolic calculus.
263 Moving data to and from regular editing buffers.
266 Embedded mode for manipulating Calc formulas and data directly
267 inside any editing buffer.
270 Graphics using GNUPLOT, a versatile (and free) plotting program.
273 Easy programming using keyboard macros, algebraic formulas,
274 algebraic rewrite rules, or extended Emacs Lisp.
277 Calc tries to include a little something for everyone; as a result it is
278 large and might be intimidating to the first-time user. If you plan to
279 use Calc only as a traditional desk calculator, all you really need to
280 read is the ``Getting Started'' chapter of this manual and possibly the
281 first few sections of the tutorial. As you become more comfortable with
282 the program you can learn its additional features. Calc does not
283 have the scope and depth of a fully-functional symbolic math package,
284 but Calc has the advantages of convenience, portability, and freedom.
286 @node About This Manual, Notations Used in This Manual, What is Calc, Getting Started
287 @section About This Manual
290 This document serves as a complete description of the GNU Emacs
291 Calculator. It works both as an introduction for novices and as
292 a reference for experienced users. While it helps to have some
293 experience with GNU Emacs in order to get the most out of Calc,
294 this manual ought to be readable even if you don't know or use Emacs
297 This manual is divided into three major parts:@: the ``Getting
298 Started'' chapter you are reading now, the Calc tutorial, and the Calc
301 @c This manual has been printed in two volumes, the @dfn{Tutorial} and the
302 @c @dfn{Reference}. Both volumes include a copy of the ``Getting Started''
305 If you are in a hurry to use Calc, there is a brief ``demonstration''
306 below which illustrates the major features of Calc in just a couple of
307 pages. If you don't have time to go through the full tutorial, this
308 will show you everything you need to know to begin.
309 @xref{Demonstration of Calc}.
311 The tutorial chapter walks you through the various parts of Calc
312 with lots of hands-on examples and explanations. If you are new
313 to Calc and you have some time, try going through at least the
314 beginning of the tutorial. The tutorial includes about 70 exercises
315 with answers. These exercises give you some guided practice with
316 Calc, as well as pointing out some interesting and unusual ways
319 The reference section discusses Calc in complete depth. You can read
320 the reference from start to finish if you want to learn every aspect
321 of Calc. Or, you can look in the table of contents or the Concept
322 Index to find the parts of the manual that discuss the things you
325 @c @cindex Marginal notes
326 Every Calc keyboard command is listed in the Calc Summary, and also
327 in the Key Index. Algebraic functions, @kbd{M-x} commands, and
328 variables also have their own indices.
330 @c @infoline In the printed manual, each
331 @c paragraph that is referenced in the Key or Function Index is marked
332 @c in the margin with its index entry.
334 @c [fix-ref Help Commands]
335 You can access this manual on-line at any time within Calc by pressing
336 the @kbd{h i} key sequence. Outside of the Calc window, you can press
337 @kbd{C-x * i} to read the manual on-line. From within Calc the command
338 @kbd{h t} will jump directly to the Tutorial; from outside of Calc the
339 command @kbd{C-x * t} will jump to the Tutorial and start Calc if
340 necessary. Pressing @kbd{h s} or @kbd{C-x * s} will take you directly
341 to the Calc Summary. Within Calc, you can also go to the part of the
342 manual describing any Calc key, function, or variable using
343 @w{@kbd{h k}}, @kbd{h f}, or @kbd{h v}, respectively. @xref{Help Commands}.
346 The Calc manual can be printed, but because the manual is so large, you
347 should only make a printed copy if you really need it. To print the
348 manual, you will need the @TeX{} typesetting program (this is a free
349 program by Donald Knuth at Stanford University) as well as the
350 @file{texindex} program and @file{texinfo.tex} file, both of which can
351 be obtained from the FSF as part of the @code{texinfo} package.
352 To print the Calc manual in one huge tome, you will need the
353 source code to this manual, @file{calc.texi}, available as part of the
354 Emacs source. Once you have this file, type @kbd{texi2dvi calc.texi}.
355 Alternatively, change to the @file{man} subdirectory of the Emacs
356 source distribution, and type @kbd{make calc.dvi}. (Don't worry if you
357 get some ``overfull box'' warnings while @TeX{} runs.)
358 The result will be a device-independent output file called
359 @file{calc.dvi}, which you must print in whatever way is right
360 for your system. On many systems, the command is
373 @c Printed copies of this manual are also available from the Free Software
376 @node Notations Used in This Manual, Demonstration of Calc, About This Manual, Getting Started
377 @section Notations Used in This Manual
380 This section describes the various notations that are used
381 throughout the Calc manual.
383 In keystroke sequences, uppercase letters mean you must hold down
384 the shift key while typing the letter. Keys pressed with Control
385 held down are shown as @kbd{C-x}. Keys pressed with Meta held down
386 are shown as @kbd{M-x}. Other notations are @key{RET} for the
387 Return key, @key{SPC} for the space bar, @key{TAB} for the Tab key,
388 @key{DEL} for the Delete key, and @key{LFD} for the Line-Feed key.
389 The @key{DEL} key is called Backspace on some keyboards, it is
390 whatever key you would use to correct a simple typing error when
391 regularly using Emacs.
393 (If you don't have the @key{LFD} or @key{TAB} keys on your keyboard,
394 the @kbd{C-j} and @kbd{C-i} keys are equivalent to them, respectively.
395 If you don't have a Meta key, look for Alt or Extend Char. You can
396 also press @key{ESC} or @kbd{C-[} first to get the same effect, so
397 that @kbd{M-x}, @kbd{@key{ESC} x}, and @kbd{C-[ x} are all equivalent.)
399 Sometimes the @key{RET} key is not shown when it is ``obvious''
400 that you must press @key{RET} to proceed. For example, the @key{RET}
401 is usually omitted in key sequences like @kbd{M-x calc-keypad @key{RET}}.
403 Commands are generally shown like this: @kbd{p} (@code{calc-precision})
404 or @kbd{C-x * k} (@code{calc-keypad}). This means that the command is
405 normally used by pressing the @kbd{p} key or @kbd{C-x * k} key sequence,
406 but it also has the full-name equivalent shown, e.g., @kbd{M-x calc-precision}.
408 Commands that correspond to functions in algebraic notation
409 are written: @kbd{C} (@code{calc-cos}) [@code{cos}]. This means
410 the @kbd{C} key is equivalent to @kbd{M-x calc-cos}, and that
411 the corresponding function in an algebraic-style formula would
412 be @samp{cos(@var{x})}.
414 A few commands don't have key equivalents: @code{calc-sincos}
417 @node Demonstration of Calc, Using Calc, Notations Used in This Manual, Getting Started
418 @section A Demonstration of Calc
421 @cindex Demonstration of Calc
422 This section will show some typical small problems being solved with
423 Calc. The focus is more on demonstration than explanation, but
424 everything you see here will be covered more thoroughly in the
427 To begin, start Emacs if necessary (usually the command @code{emacs}
428 does this), and type @kbd{C-x * c} to start the
429 Calculator. (You can also use @kbd{M-x calc} if this doesn't work.
430 @xref{Starting Calc}, for various ways of starting the Calculator.)
432 Be sure to type all the sample input exactly, especially noting the
433 difference between lower-case and upper-case letters. Remember,
434 @key{RET}, @key{TAB}, @key{DEL}, and @key{SPC} are the Return, Tab,
435 Delete, and Space keys.
437 @strong{RPN calculation.} In RPN, you type the input number(s) first,
438 then the command to operate on the numbers.
441 Type @kbd{2 @key{RET} 3 + Q} to compute
442 @texline @math{\sqrt{2+3} = 2.2360679775}.
443 @infoline the square root of 2+3, which is 2.2360679775.
446 Type @kbd{P 2 ^} to compute
447 @texline @math{\pi^2 = 9.86960440109}.
448 @infoline the value of `pi' squared, 9.86960440109.
451 Type @key{TAB} to exchange the order of these two results.
454 Type @kbd{- I H S} to subtract these results and compute the Inverse
455 Hyperbolic sine of the difference, 2.72996136574.
458 Type @key{DEL} to erase this result.
460 @strong{Algebraic calculation.} You can also enter calculations using
461 conventional ``algebraic'' notation. To enter an algebraic formula,
462 use the apostrophe key.
465 Type @kbd{' sqrt(2+3) @key{RET}} to compute
466 @texline @math{\sqrt{2+3}}.
467 @infoline the square root of 2+3.
470 Type @kbd{' pi^2 @key{RET}} to enter
471 @texline @math{\pi^2}.
472 @infoline `pi' squared.
473 To evaluate this symbolic formula as a number, type @kbd{=}.
476 Type @kbd{' arcsinh($ - $$) @key{RET}} to subtract the second-most-recent
477 result from the most-recent and compute the Inverse Hyperbolic sine.
479 @strong{Keypad mode.} If you are using the X window system, press
480 @w{@kbd{C-x * k}} to get Keypad mode. (If you don't use X, skip to
484 Click on the @key{2}, @key{ENTER}, @key{3}, @key{+}, and @key{SQRT}
485 ``buttons'' using your left mouse button.
488 Click on @key{PI}, @key{2}, and @tfn{y^x}.
491 Click on @key{INV}, then @key{ENTER} to swap the two results.
494 Click on @key{-}, @key{INV}, @key{HYP}, and @key{SIN}.
497 Click on @key{<-} to erase the result, then click @key{OFF} to turn
498 the Keypad Calculator off.
500 @strong{Grabbing data.} Type @kbd{C-x * x} if necessary to exit Calc.
501 Now select the following numbers as an Emacs region: ``Mark'' the
502 front of the list by typing @kbd{C-@key{SPC}} or @kbd{C-@@} there,
503 then move to the other end of the list. (Either get this list from
504 the on-line copy of this manual, accessed by @w{@kbd{C-x * i}}, or just
505 type these numbers into a scratch file.) Now type @kbd{C-x * g} to
506 ``grab'' these numbers into Calc.
517 The result @samp{[1.23, 1.97, 1.6, 2, 1.19, 1.08]} is a Calc ``vector.''
518 Type @w{@kbd{V R +}} to compute the sum of these numbers.
521 Type @kbd{U} to Undo this command, then type @kbd{V R *} to compute
522 the product of the numbers.
525 You can also grab data as a rectangular matrix. Place the cursor on
526 the upper-leftmost @samp{1} and set the mark, then move to just after
527 the lower-right @samp{8} and press @kbd{C-x * r}.
530 Type @kbd{v t} to transpose this
531 @texline @math{3\times2}
534 @texline @math{2\times3}
536 matrix. Type @w{@kbd{v u}} to unpack the rows into two separate
537 vectors. Now type @w{@kbd{V R + @key{TAB} V R +}} to compute the sums
538 of the two original columns. (There is also a special
539 grab-and-sum-columns command, @kbd{C-x * :}.)
541 @strong{Units conversion.} Units are entered algebraically.
542 Type @w{@kbd{' 43 mi/hr @key{RET}}} to enter the quantity 43 miles-per-hour.
543 Type @w{@kbd{u c km/hr @key{RET}}}. Type @w{@kbd{u c m/s @key{RET}}}.
545 @strong{Date arithmetic.} Type @kbd{t N} to get the current date and
546 time. Type @kbd{90 +} to find the date 90 days from now. Type
547 @kbd{' <25 dec 87> @key{RET}} to enter a date, then @kbd{- 7 /} to see how
548 many weeks have passed since then.
550 @strong{Algebra.} Algebraic entries can also include formulas
551 or equations involving variables. Type @kbd{@w{' [x + y} = a, x y = 1] @key{RET}}
552 to enter a pair of equations involving three variables.
553 (Note the leading apostrophe in this example; also, note that the space
554 in @samp{x y} is required.) Type @w{@kbd{a S x,y @key{RET}}} to solve
555 these equations for the variables @expr{x} and @expr{y}.
558 Type @kbd{d B} to view the solutions in more readable notation.
559 Type @w{@kbd{d C}} to view them in C language notation, @kbd{d T}
560 to view them in the notation for the @TeX{} typesetting system,
561 and @kbd{d L} to view them in the notation for the La@TeX{} typesetting
562 system. Type @kbd{d N} to return to normal notation.
565 Type @kbd{7.5}, then @kbd{s l a @key{RET}} to let @expr{a = 7.5} in these formulas.
566 (That's the letter @kbd{l}, not the numeral @kbd{1}.)
569 @strong{Help functions.} You can read about any command in the on-line
570 manual. Type @kbd{C-x * c} to return to Calc after each of these
571 commands: @kbd{h k t N} to read about the @kbd{t N} command,
572 @kbd{h f sqrt @key{RET}} to read about the @code{sqrt} function, and
573 @kbd{h s} to read the Calc summary.
576 @strong{Help functions.} You can read about any command in the on-line
577 manual. Remember to type the letter @kbd{l}, then @kbd{C-x * c}, to
578 return here after each of these commands: @w{@kbd{h k t N}} to read
579 about the @w{@kbd{t N}} command, @kbd{h f sqrt @key{RET}} to read about the
580 @code{sqrt} function, and @kbd{h s} to read the Calc summary.
583 Press @key{DEL} repeatedly to remove any leftover results from the stack.
584 To exit from Calc, press @kbd{q} or @kbd{C-x * c} again.
586 @node Using Calc, History and Acknowledgements, Demonstration of Calc, Getting Started
590 Calc has several user interfaces that are specialized for
591 different kinds of tasks. As well as Calc's standard interface,
592 there are Quick mode, Keypad mode, and Embedded mode.
596 * The Standard Interface::
597 * Quick Mode Overview::
598 * Keypad Mode Overview::
599 * Standalone Operation::
600 * Embedded Mode Overview::
601 * Other C-x * Commands::
604 @node Starting Calc, The Standard Interface, Using Calc, Using Calc
605 @subsection Starting Calc
608 On most systems, you can type @kbd{C-x *} to start the Calculator.
609 The key sequence @kbd{C-x *} is bound to the command @code{calc-dispatch},
610 which can be rebound if convenient (@pxref{Customizing Calc}).
612 When you press @kbd{C-x *}, Emacs waits for you to press a second key to
613 complete the command. In this case, you will follow @kbd{C-x *} with a
614 letter (upper- or lower-case, it doesn't matter for @kbd{C-x *}) that says
615 which Calc interface you want to use.
617 To get Calc's standard interface, type @kbd{C-x * c}. To get
618 Keypad mode, type @kbd{C-x * k}. Type @kbd{C-x * ?} to get a brief
619 list of the available options, and type a second @kbd{?} to get
622 To ease typing, @kbd{C-x * *} also works to start Calc. It starts the
623 same interface (either @kbd{C-x * c} or @w{@kbd{C-x * k}}) that you last
624 used, selecting the @kbd{C-x * c} interface by default.
626 If @kbd{C-x *} doesn't work for you, you can always type explicit
627 commands like @kbd{M-x calc} (for the standard user interface) or
628 @w{@kbd{M-x calc-keypad}} (for Keypad mode). First type @kbd{M-x}
629 (that's Meta with the letter @kbd{x}), then, at the prompt,
630 type the full command (like @kbd{calc-keypad}) and press Return.
632 The same commands (like @kbd{C-x * c} or @kbd{C-x * *}) that start
633 the Calculator also turn it off if it is already on.
635 @node The Standard Interface, Quick Mode Overview, Starting Calc, Using Calc
636 @subsection The Standard Calc Interface
639 @cindex Standard user interface
640 Calc's standard interface acts like a traditional RPN calculator,
641 operated by the normal Emacs keyboard. When you type @kbd{C-x * c}
642 to start the Calculator, the Emacs screen splits into two windows
643 with the file you were editing on top and Calc on the bottom.
649 --**-Emacs: myfile (Fundamental)----All----------------------
650 --- Emacs Calculator Mode --- |Emacs Calculator Trail
658 --%*-Calc: 12 Deg (Calculator)----All----- --%*- *Calc Trail*
662 In this figure, the mode-line for @file{myfile} has moved up and the
663 ``Calculator'' window has appeared below it. As you can see, Calc
664 actually makes two windows side-by-side. The lefthand one is
665 called the @dfn{stack window} and the righthand one is called the
666 @dfn{trail window.} The stack holds the numbers involved in the
667 calculation you are currently performing. The trail holds a complete
668 record of all calculations you have done. In a desk calculator with
669 a printer, the trail corresponds to the paper tape that records what
672 In this case, the trail shows that four numbers (17.3, 3, 2, and 4)
673 were first entered into the Calculator, then the 2 and 4 were
674 multiplied to get 8, then the 3 and 8 were subtracted to get @mathit{-5}.
675 (The @samp{>} symbol shows that this was the most recent calculation.)
676 The net result is the two numbers 17.3 and @mathit{-5} sitting on the stack.
678 Most Calculator commands deal explicitly with the stack only, but
679 there is a set of commands that allow you to search back through
680 the trail and retrieve any previous result.
682 Calc commands use the digits, letters, and punctuation keys.
683 Shifted (i.e., upper-case) letters are different from lowercase
684 letters. Some letters are @dfn{prefix} keys that begin two-letter
685 commands. For example, @kbd{e} means ``enter exponent'' and shifted
686 @kbd{E} means @expr{e^x}. With the @kbd{d} (``display modes'') prefix
687 the letter ``e'' takes on very different meanings: @kbd{d e} means
688 ``engineering notation'' and @kbd{d E} means ``@dfn{eqn} language mode.''
690 There is nothing stopping you from switching out of the Calc
691 window and back into your editing window, say by using the Emacs
692 @w{@kbd{C-x o}} (@code{other-window}) command. When the cursor is
693 inside a regular window, Emacs acts just like normal. When the
694 cursor is in the Calc stack or trail windows, keys are interpreted
697 When you quit by pressing @kbd{C-x * c} a second time, the Calculator
698 windows go away but the actual Stack and Trail are not gone, just
699 hidden. When you press @kbd{C-x * c} once again you will get the
700 same stack and trail contents you had when you last used the
703 The Calculator does not remember its state between Emacs sessions.
704 Thus if you quit Emacs and start it again, @kbd{C-x * c} will give you
705 a fresh stack and trail. There is a command (@kbd{m m}) that lets
706 you save your favorite mode settings between sessions, though.
707 One of the things it saves is which user interface (standard or
708 Keypad) you last used; otherwise, a freshly started Emacs will
709 always treat @kbd{C-x * *} the same as @kbd{C-x * c}.
711 The @kbd{q} key is another equivalent way to turn the Calculator off.
713 If you type @kbd{C-x * b} first and then @kbd{C-x * c}, you get a
714 full-screen version of Calc (@code{full-calc}) in which the stack and
715 trail windows are still side-by-side but are now as tall as the whole
716 Emacs screen. When you press @kbd{q} or @kbd{C-x * c} again to quit,
717 the file you were editing before reappears. The @kbd{C-x * b} key
718 switches back and forth between ``big'' full-screen mode and the
719 normal partial-screen mode.
721 Finally, @kbd{C-x * o} (@code{calc-other-window}) is like @kbd{C-x * c}
722 except that the Calc window is not selected. The buffer you were
723 editing before remains selected instead. If you are in a Calc window,
724 then @kbd{C-x * o} will switch you out of it, being careful not to
725 switch you to the Calc Trail window. So @kbd{C-x * o} is a handy
726 way to switch out of Calc momentarily to edit your file; you can then
727 type @kbd{C-x * c} to switch back into Calc when you are done.
729 @node Quick Mode Overview, Keypad Mode Overview, The Standard Interface, Using Calc
730 @subsection Quick Mode (Overview)
733 @dfn{Quick mode} is a quick way to use Calc when you don't need the
734 full complexity of the stack and trail. To use it, type @kbd{C-x * q}
735 (@code{quick-calc}) in any regular editing buffer.
737 Quick mode is very simple: It prompts you to type any formula in
738 standard algebraic notation (like @samp{4 - 2/3}) and then displays
739 the result at the bottom of the Emacs screen (@mathit{3.33333333333}
740 in this case). You are then back in the same editing buffer you
741 were in before, ready to continue editing or to type @kbd{C-x * q}
742 again to do another quick calculation. The result of the calculation
743 will also be in the Emacs ``kill ring'' so that a @kbd{C-y} command
744 at this point will yank the result into your editing buffer.
746 Calc mode settings affect Quick mode, too, though you will have to
747 go into regular Calc (with @kbd{C-x * c}) to change the mode settings.
749 @c [fix-ref Quick Calculator mode]
750 @xref{Quick Calculator}, for further information.
752 @node Keypad Mode Overview, Standalone Operation, Quick Mode Overview, Using Calc
753 @subsection Keypad Mode (Overview)
756 @dfn{Keypad mode} is a mouse-based interface to the Calculator.
757 It is designed for use with terminals that support a mouse. If you
758 don't have a mouse, you will have to operate Keypad mode with your
759 arrow keys (which is probably more trouble than it's worth).
761 Type @kbd{C-x * k} to turn Keypad mode on or off. Once again you
762 get two new windows, this time on the righthand side of the screen
763 instead of at the bottom. The upper window is the familiar Calc
764 Stack; the lower window is a picture of a typical calculator keypad.
768 \advance \dimen0 by 24\baselineskip%
769 \ifdim \dimen0>\pagegoal \vfill\eject \fi%
774 |--- Emacs Calculator Mode ---
778 |--%*-Calc: 12 Deg (Calcul
779 |----+----+--Calc---+----+----1
780 |FLR |CEIL|RND |TRNC|CLN2|FLT |
781 |----+----+----+----+----+----|
782 | LN |EXP | |ABS |IDIV|MOD |
783 |----+----+----+----+----+----|
784 |SIN |COS |TAN |SQRT|y^x |1/x |
785 |----+----+----+----+----+----|
786 | ENTER |+/- |EEX |UNDO| <- |
787 |-----+---+-+--+--+-+---++----|
788 | INV | 7 | 8 | 9 | / |
789 |-----+-----+-----+-----+-----|
790 | HYP | 4 | 5 | 6 | * |
791 |-----+-----+-----+-----+-----|
792 |EXEC | 1 | 2 | 3 | - |
793 |-----+-----+-----+-----+-----|
794 | OFF | 0 | . | PI | + |
795 |-----+-----+-----+-----+-----+
799 Keypad mode is much easier for beginners to learn, because there
800 is no need to memorize lots of obscure key sequences. But not all
801 commands in regular Calc are available on the Keypad. You can
802 always switch the cursor into the Calc stack window to use
803 standard Calc commands if you need. Serious Calc users, though,
804 often find they prefer the standard interface over Keypad mode.
806 To operate the Calculator, just click on the ``buttons'' of the
807 keypad using your left mouse button. To enter the two numbers
808 shown here you would click @w{@kbd{1 7 .@: 3 ENTER 5 +/- ENTER}}; to
809 add them together you would then click @kbd{+} (to get 12.3 on
812 If you click the right mouse button, the top three rows of the
813 keypad change to show other sets of commands, such as advanced
814 math functions, vector operations, and operations on binary
817 Because Keypad mode doesn't use the regular keyboard, Calc leaves
818 the cursor in your original editing buffer. You can type in
819 this buffer in the usual way while also clicking on the Calculator
820 keypad. One advantage of Keypad mode is that you don't need an
821 explicit command to switch between editing and calculating.
823 If you press @kbd{C-x * b} first, you get a full-screen Keypad mode
824 (@code{full-calc-keypad}) with three windows: The keypad in the lower
825 left, the stack in the lower right, and the trail on top.
827 @c [fix-ref Keypad Mode]
828 @xref{Keypad Mode}, for further information.
830 @node Standalone Operation, Embedded Mode Overview, Keypad Mode Overview, Using Calc
831 @subsection Standalone Operation
834 @cindex Standalone Operation
835 If you are not in Emacs at the moment but you wish to use Calc,
836 you must start Emacs first. If all you want is to run Calc, you
837 can give the commands:
847 emacs -f full-calc-keypad
851 which run a full-screen Calculator (as if by @kbd{C-x * b C-x * c}) or
852 a full-screen X-based Calculator (as if by @kbd{C-x * b C-x * k}).
853 In standalone operation, quitting the Calculator (by pressing
854 @kbd{q} or clicking on the keypad @key{EXIT} button) quits Emacs
857 @node Embedded Mode Overview, Other C-x * Commands, Standalone Operation, Using Calc
858 @subsection Embedded Mode (Overview)
861 @dfn{Embedded mode} is a way to use Calc directly from inside an
862 editing buffer. Suppose you have a formula written as part of a
876 and you wish to have Calc compute and format the derivative for
877 you and store this derivative in the buffer automatically. To
878 do this with Embedded mode, first copy the formula down to where
879 you want the result to be, leaving a blank line before and after the
894 Now, move the cursor onto this new formula and press @kbd{C-x * e}.
895 Calc will read the formula (using the surrounding blank lines to tell
896 how much text to read), then push this formula (invisibly) onto the Calc
897 stack. The cursor will stay on the formula in the editing buffer, but
898 the line with the formula will now appear as it would on the Calc stack
899 (in this case, it will be left-aligned) and the buffer's mode line will
900 change to look like the Calc mode line (with mode indicators like
901 @samp{12 Deg} and so on). Even though you are still in your editing
902 buffer, the keyboard now acts like the Calc keyboard, and any new result
903 you get is copied from the stack back into the buffer. To take the
904 derivative, you would type @kbd{a d x @key{RET}}.
918 (Note that by default, Calc gives division lower precedence than multiplication,
919 so that @samp{1 / ln(x) x} is equivalent to @samp{1 / (ln(x) x)}.)
921 To make this look nicer, you might want to press @kbd{d =} to center
922 the formula, and even @kbd{d B} to use Big display mode.
931 % [calc-mode: justify: center]
932 % [calc-mode: language: big]
940 Calc has added annotations to the file to help it remember the modes
941 that were used for this formula. They are formatted like comments
942 in the @TeX{} typesetting language, just in case you are using @TeX{} or
943 La@TeX{}. (In this example @TeX{} is not being used, so you might want
944 to move these comments up to the top of the file or otherwise put them
947 As an extra flourish, we can add an equation number using a
948 righthand label: Type @kbd{d @} (1) @key{RET}}.
952 % [calc-mode: justify: center]
953 % [calc-mode: language: big]
954 % [calc-mode: right-label: " (1)"]
962 To leave Embedded mode, type @kbd{C-x * e} again. The mode line
963 and keyboard will revert to the way they were before.
965 The related command @kbd{C-x * w} operates on a single word, which
966 generally means a single number, inside text. It searches for an
967 expression which ``looks'' like a number containing the point.
968 Here's an example of its use:
971 A slope of one-third corresponds to an angle of 1 degrees.
974 Place the cursor on the @samp{1}, then type @kbd{C-x * w} to enable
975 Embedded mode on that number. Now type @kbd{3 /} (to get one-third),
976 and @kbd{I T} (the Inverse Tangent converts a slope into an angle),
977 then @w{@kbd{C-x * w}} again to exit Embedded mode.
980 A slope of one-third corresponds to an angle of 18.4349488229 degrees.
983 @c [fix-ref Embedded Mode]
984 @xref{Embedded Mode}, for full details.
986 @node Other C-x * Commands, , Embedded Mode Overview, Using Calc
987 @subsection Other @kbd{C-x *} Commands
990 Two more Calc-related commands are @kbd{C-x * g} and @kbd{C-x * r},
991 which ``grab'' data from a selected region of a buffer into the
992 Calculator. The region is defined in the usual Emacs way, by
993 a ``mark'' placed at one end of the region, and the Emacs
994 cursor or ``point'' placed at the other.
996 The @kbd{C-x * g} command reads the region in the usual left-to-right,
997 top-to-bottom order. The result is packaged into a Calc vector
998 of numbers and placed on the stack. Calc (in its standard
999 user interface) is then started. Type @kbd{v u} if you want
1000 to unpack this vector into separate numbers on the stack. Also,
1001 @kbd{C-u C-x * g} interprets the region as a single number or
1004 The @kbd{C-x * r} command reads a rectangle, with the point and
1005 mark defining opposite corners of the rectangle. The result
1006 is a matrix of numbers on the Calculator stack.
1008 Complementary to these is @kbd{C-x * y}, which ``yanks'' the
1009 value at the top of the Calc stack back into an editing buffer.
1010 If you type @w{@kbd{C-x * y}} while in such a buffer, the value is
1011 yanked at the current position. If you type @kbd{C-x * y} while
1012 in the Calc buffer, Calc makes an educated guess as to which
1013 editing buffer you want to use. The Calc window does not have
1014 to be visible in order to use this command, as long as there
1015 is something on the Calc stack.
1017 Here, for reference, is the complete list of @kbd{C-x *} commands.
1018 The shift, control, and meta keys are ignored for the keystroke
1019 following @kbd{C-x *}.
1022 Commands for turning Calc on and off:
1026 Turn Calc on or off, employing the same user interface as last time.
1028 @item =, +, -, /, \, &, #
1029 Alternatives for @kbd{*}.
1032 Turn Calc on or off using its standard bottom-of-the-screen
1033 interface. If Calc is already turned on but the cursor is not
1034 in the Calc window, move the cursor into the window.
1037 Same as @kbd{C}, but don't select the new Calc window. If
1038 Calc is already turned on and the cursor is in the Calc window,
1039 move it out of that window.
1042 Control whether @kbd{C-x * c} and @kbd{C-x * k} use the full screen.
1045 Use Quick mode for a single short calculation.
1048 Turn Calc Keypad mode on or off.
1051 Turn Calc Embedded mode on or off at the current formula.
1054 Turn Calc Embedded mode on or off, select the interesting part.
1057 Turn Calc Embedded mode on or off at the current word (number).
1060 Turn Calc on in a user-defined way, as defined by a @kbd{Z I} command.
1063 Quit Calc; turn off standard, Keypad, or Embedded mode if on.
1064 (This is like @kbd{q} or @key{OFF} inside of Calc.)
1071 Commands for moving data into and out of the Calculator:
1075 Grab the region into the Calculator as a vector.
1078 Grab the rectangular region into the Calculator as a matrix.
1081 Grab the rectangular region and compute the sums of its columns.
1084 Grab the rectangular region and compute the sums of its rows.
1087 Yank a value from the Calculator into the current editing buffer.
1094 Commands for use with Embedded mode:
1098 ``Activate'' the current buffer. Locate all formulas that
1099 contain @samp{:=} or @samp{=>} symbols and record their locations
1100 so that they can be updated automatically as variables are changed.
1103 Duplicate the current formula immediately below and select
1107 Insert a new formula at the current point.
1110 Move the cursor to the next active formula in the buffer.
1113 Move the cursor to the previous active formula in the buffer.
1116 Update (i.e., as if by the @kbd{=} key) the formula at the current point.
1119 Edit (as if by @code{calc-edit}) the formula at the current point.
1126 Miscellaneous commands:
1130 Run the Emacs Info system to read the Calc manual.
1131 (This is the same as @kbd{h i} inside of Calc.)
1134 Run the Emacs Info system to read the Calc Tutorial.
1137 Run the Emacs Info system to read the Calc Summary.
1140 Load Calc entirely into memory. (Normally the various parts
1141 are loaded only as they are needed.)
1144 Read a region of written keystroke names (like @kbd{C-n a b c @key{RET}})
1145 and record them as the current keyboard macro.
1148 (This is the ``zero'' digit key.) Reset the Calculator to
1149 its initial state: Empty stack, and initial mode settings.
1152 @node History and Acknowledgements, , Using Calc, Getting Started
1153 @section History and Acknowledgements
1156 Calc was originally started as a two-week project to occupy a lull
1157 in the author's schedule. Basically, a friend asked if I remembered
1159 @texline @math{2^{32}}.
1160 @infoline @expr{2^32}.
1161 I didn't offhand, but I said, ``that's easy, just call up an
1162 @code{xcalc}.'' @code{Xcalc} duly reported that the answer to our
1163 question was @samp{4.294967e+09}---with no way to see the full ten
1164 digits even though we knew they were there in the program's memory! I
1165 was so annoyed, I vowed to write a calculator of my own, once and for
1168 I chose Emacs Lisp, a) because I had always been curious about it
1169 and b) because, being only a text editor extension language after
1170 all, Emacs Lisp would surely reach its limits long before the project
1171 got too far out of hand.
1173 To make a long story short, Emacs Lisp turned out to be a distressingly
1174 solid implementation of Lisp, and the humble task of calculating
1175 turned out to be more open-ended than one might have expected.
1177 Emacs Lisp didn't have built-in floating point math (now it does), so
1178 this had to be simulated in software. In fact, Emacs integers would
1179 only comfortably fit six decimal digits or so---not enough for a decent
1180 calculator. So I had to write my own high-precision integer code as
1181 well, and once I had this I figured that arbitrary-size integers were
1182 just as easy as large integers. Arbitrary floating-point precision was
1183 the logical next step. Also, since the large integer arithmetic was
1184 there anyway it seemed only fair to give the user direct access to it,
1185 which in turn made it practical to support fractions as well as floats.
1186 All these features inspired me to look around for other data types that
1187 might be worth having.
1189 Around this time, my friend Rick Koshi showed me his nifty new HP-28
1190 calculator. It allowed the user to manipulate formulas as well as
1191 numerical quantities, and it could also operate on matrices. I
1192 decided that these would be good for Calc to have, too. And once
1193 things had gone this far, I figured I might as well take a look at
1194 serious algebra systems for further ideas. Since these systems did
1195 far more than I could ever hope to implement, I decided to focus on
1196 rewrite rules and other programming features so that users could
1197 implement what they needed for themselves.
1199 Rick complained that matrices were hard to read, so I put in code to
1200 format them in a 2D style. Once these routines were in place, Big mode
1201 was obligatory. Gee, what other language modes would be useful?
1203 Scott Hemphill and Allen Knutson, two friends with a strong mathematical
1204 bent, contributed ideas and algorithms for a number of Calc features
1205 including modulo forms, primality testing, and float-to-fraction conversion.
1207 Units were added at the eager insistence of Mass Sivilotti. Later,
1208 Ulrich Mueller at CERN and Przemek Klosowski at NIST provided invaluable
1209 expert assistance with the units table. As far as I can remember, the
1210 idea of using algebraic formulas and variables to represent units dates
1211 back to an ancient article in Byte magazine about muMath, an early
1212 algebra system for microcomputers.
1214 Many people have contributed to Calc by reporting bugs and suggesting
1215 features, large and small. A few deserve special mention: Tim Peters,
1216 who helped develop the ideas that led to the selection commands, rewrite
1217 rules, and many other algebra features;
1218 @texline Fran\c{c}ois
1220 Pinard, who contributed an early prototype of the Calc Summary appendix
1221 as well as providing valuable suggestions in many other areas of Calc;
1222 Carl Witty, whose eagle eyes discovered many typographical and factual
1223 errors in the Calc manual; Tim Kay, who drove the development of
1224 Embedded mode; Ove Ewerlid, who made many suggestions relating to the
1225 algebra commands and contributed some code for polynomial operations;
1226 Randal Schwartz, who suggested the @code{calc-eval} function; Juha
1227 Sarlin, who first worked out how to split Calc into quickly-loading
1228 parts; Bob Weiner, who helped immensely with the Lucid Emacs port; and
1229 Robert J. Chassell, who suggested the Calc Tutorial and exercises as
1230 well as many other things.
1232 @cindex Bibliography
1233 @cindex Knuth, Art of Computer Programming
1234 @cindex Numerical Recipes
1235 @c Should these be expanded into more complete references?
1236 Among the books used in the development of Calc were Knuth's @emph{Art
1237 of Computer Programming} (especially volume II, @emph{Seminumerical
1238 Algorithms}); @emph{Numerical Recipes} by Press, Flannery, Teukolsky,
1239 and Vetterling; Bevington's @emph{Data Reduction and Error Analysis
1240 for the Physical Sciences}; @emph{Concrete Mathematics} by Graham,
1241 Knuth, and Patashnik; Steele's @emph{Common Lisp, the Language}; the
1242 @emph{CRC Standard Math Tables} (William H. Beyer, ed.); and
1243 Abramowitz and Stegun's venerable @emph{Handbook of Mathematical
1244 Functions}. Also, of course, Calc could not have been written without
1245 the excellent @emph{GNU Emacs Lisp Reference Manual}, by Bil Lewis and
1248 Final thanks go to Richard Stallman, without whose fine implementations
1249 of the Emacs editor, language, and environment, Calc would have been
1250 finished in two weeks.
1255 @c This node is accessed by the `C-x * t' command.
1256 @node Interactive Tutorial, Tutorial, Getting Started, Top
1260 Some brief instructions on using the Emacs Info system for this tutorial:
1262 Press the space bar and Delete keys to go forward and backward in a
1263 section by screenfuls (or use the regular Emacs scrolling commands
1266 Press @kbd{n} or @kbd{p} to go to the Next or Previous section.
1267 If the section has a @dfn{menu}, press a digit key like @kbd{1}
1268 or @kbd{2} to go to a sub-section from the menu. Press @kbd{u} to
1269 go back up from a sub-section to the menu it is part of.
1271 Exercises in the tutorial all have cross-references to the
1272 appropriate page of the ``answers'' section. Press @kbd{f}, then
1273 the exercise number, to see the answer to an exercise. After
1274 you have followed a cross-reference, you can press the letter
1275 @kbd{l} to return to where you were before.
1277 You can press @kbd{?} at any time for a brief summary of Info commands.
1279 Press the number @kbd{1} now to enter the first section of the Tutorial.
1285 @node Tutorial, Introduction, Interactive Tutorial, Top
1288 @node Tutorial, Introduction, Getting Started, Top
1293 This chapter explains how to use Calc and its many features, in
1294 a step-by-step, tutorial way. You are encouraged to run Calc and
1295 work along with the examples as you read (@pxref{Starting Calc}).
1296 If you are already familiar with advanced calculators, you may wish
1298 to skip on to the rest of this manual.
1300 @c to skip on to volume II of this manual, the @dfn{Calc Reference}.
1302 @c [fix-ref Embedded Mode]
1303 This tutorial describes the standard user interface of Calc only.
1304 The Quick mode and Keypad mode interfaces are fairly
1305 self-explanatory. @xref{Embedded Mode}, for a description of
1306 the Embedded mode interface.
1308 The easiest way to read this tutorial on-line is to have two windows on
1309 your Emacs screen, one with Calc and one with the Info system. Press
1310 @kbd{C-x * t} to set this up; the on-line tutorial will be opened in the
1311 current window and Calc will be started in another window. From the
1312 Info window, the command @kbd{C-x * c} can be used to switch to the Calc
1313 window and @kbd{C-x * o} can be used to switch back to the Info window.
1314 (If you have a printed copy of the manual you can use that instead; in
1315 that case you only need to press @kbd{C-x * c} to start Calc.)
1317 This tutorial is designed to be done in sequence. But the rest of this
1318 manual does not assume you have gone through the tutorial. The tutorial
1319 does not cover everything in the Calculator, but it touches on most
1323 You may wish to print out a copy of the Calc Summary and keep notes on
1324 it as you learn Calc. @xref{About This Manual}, to see how to make a
1325 printed summary. @xref{Summary}.
1328 The Calc Summary at the end of the reference manual includes some blank
1329 space for your own use. You may wish to keep notes there as you learn
1335 * Arithmetic Tutorial::
1336 * Vector/Matrix Tutorial::
1338 * Algebra Tutorial::
1339 * Programming Tutorial::
1341 * Answers to Exercises::
1344 @node Basic Tutorial, Arithmetic Tutorial, Tutorial, Tutorial
1345 @section Basic Tutorial
1348 In this section, we learn how RPN and algebraic-style calculations
1349 work, how to undo and redo an operation done by mistake, and how
1350 to control various modes of the Calculator.
1353 * RPN Tutorial:: Basic operations with the stack.
1354 * Algebraic Tutorial:: Algebraic entry; variables.
1355 * Undo Tutorial:: If you make a mistake: Undo and the trail.
1356 * Modes Tutorial:: Common mode-setting commands.
1359 @node RPN Tutorial, Algebraic Tutorial, Basic Tutorial, Basic Tutorial
1360 @subsection RPN Calculations and the Stack
1362 @cindex RPN notation
1365 Calc normally uses RPN notation. You may be familiar with the RPN
1366 system from Hewlett-Packard calculators, FORTH, or PostScript.
1367 (Reverse Polish Notation, RPN, is named after the Polish mathematician
1372 Calc normally uses RPN notation. You may be familiar with the RPN
1373 system from Hewlett-Packard calculators, FORTH, or PostScript.
1374 (Reverse Polish Notation, RPN, is named after the Polish mathematician
1378 The central component of an RPN calculator is the @dfn{stack}. A
1379 calculator stack is like a stack of dishes. New dishes (numbers) are
1380 added at the top of the stack, and numbers are normally only removed
1381 from the top of the stack.
1385 In an operation like @expr{2+3}, the 2 and 3 are called the @dfn{operands}
1386 and the @expr{+} is the @dfn{operator}. In an RPN calculator you always
1387 enter the operands first, then the operator. Each time you type a
1388 number, Calc adds or @dfn{pushes} it onto the top of the Stack.
1389 When you press an operator key like @kbd{+}, Calc @dfn{pops} the appropriate
1390 number of operands from the stack and pushes back the result.
1392 Thus we could add the numbers 2 and 3 in an RPN calculator by typing:
1393 @kbd{2 @key{RET} 3 @key{RET} +}. (The @key{RET} key, Return, corresponds to
1394 the @key{ENTER} key on traditional RPN calculators.) Try this now if
1395 you wish; type @kbd{C-x * c} to switch into the Calc window (you can type
1396 @kbd{C-x * c} again or @kbd{C-x * o} to switch back to the Tutorial window).
1397 The first four keystrokes ``push'' the numbers 2 and 3 onto the stack.
1398 The @kbd{+} key ``pops'' the top two numbers from the stack, adds them,
1399 and pushes the result (5) back onto the stack. Here's how the stack
1400 will look at various points throughout the calculation:
1408 C-x * c 2 @key{RET} 3 @key{RET} + @key{DEL}
1412 The @samp{.} symbol is a marker that represents the top of the stack.
1413 Note that the ``top'' of the stack is really shown at the bottom of
1414 the Stack window. This may seem backwards, but it turns out to be
1415 less distracting in regular use.
1417 @cindex Stack levels
1418 @cindex Levels of stack
1419 The numbers @samp{1:} and @samp{2:} on the left are @dfn{stack level
1420 numbers}. Old RPN calculators always had four stack levels called
1421 @expr{x}, @expr{y}, @expr{z}, and @expr{t}. Calc's stack can grow
1422 as large as you like, so it uses numbers instead of letters. Some
1423 stack-manipulation commands accept a numeric argument that says
1424 which stack level to work on. Normal commands like @kbd{+} always
1425 work on the top few levels of the stack.
1427 @c [fix-ref Truncating the Stack]
1428 The Stack buffer is just an Emacs buffer, and you can move around in
1429 it using the regular Emacs motion commands. But no matter where the
1430 cursor is, even if you have scrolled the @samp{.} marker out of
1431 view, most Calc commands always move the cursor back down to level 1
1432 before doing anything. It is possible to move the @samp{.} marker
1433 upwards through the stack, temporarily ``hiding'' some numbers from
1434 commands like @kbd{+}. This is called @dfn{stack truncation} and
1435 we will not cover it in this tutorial; @pxref{Truncating the Stack},
1436 if you are interested.
1438 You don't really need the second @key{RET} in @kbd{2 @key{RET} 3
1439 @key{RET} +}. That's because if you type any operator name or
1440 other non-numeric key when you are entering a number, the Calculator
1441 automatically enters that number and then does the requested command.
1442 Thus @kbd{2 @key{RET} 3 +} will work just as well.
1444 Examples in this tutorial will often omit @key{RET} even when the
1445 stack displays shown would only happen if you did press @key{RET}:
1458 Here, after pressing @kbd{3} the stack would really show @samp{1: 2}
1459 with @samp{Calc:@: 3} in the minibuffer. In these situations, you can
1460 press the optional @key{RET} to see the stack as the figure shows.
1462 (@bullet{}) @strong{Exercise 1.} (This tutorial will include exercises
1463 at various points. Try them if you wish. Answers to all the exercises
1464 are located at the end of the Tutorial chapter. Each exercise will
1465 include a cross-reference to its particular answer. If you are
1466 reading with the Emacs Info system, press @kbd{f} and the
1467 exercise number to go to the answer, then the letter @kbd{l} to
1468 return to where you were.)
1471 Here's the first exercise: What will the keystrokes @kbd{1 @key{RET} 2
1472 @key{RET} 3 @key{RET} 4 + * -} compute? (@samp{*} is the symbol for
1473 multiplication.) Figure it out by hand, then try it with Calc to see
1474 if you're right. @xref{RPN Answer 1, 1}. (@bullet{})
1476 (@bullet{}) @strong{Exercise 2.} Compute
1477 @texline @math{(2\times4) + (7\times9.4) + {5\over4}}
1478 @infoline @expr{2*4 + 7*9.5 + 5/4}
1479 using the stack. @xref{RPN Answer 2, 2}. (@bullet{})
1481 The @key{DEL} key is called Backspace on some keyboards. It is
1482 whatever key you would use to correct a simple typing error when
1483 regularly using Emacs. The @key{DEL} key pops and throws away the
1484 top value on the stack. (You can still get that value back from
1485 the Trail if you should need it later on.) There are many places
1486 in this tutorial where we assume you have used @key{DEL} to erase the
1487 results of the previous example at the beginning of a new example.
1488 In the few places where it is really important to use @key{DEL} to
1489 clear away old results, the text will remind you to do so.
1491 (It won't hurt to let things accumulate on the stack, except that
1492 whenever you give a display-mode-changing command Calc will have to
1493 spend a long time reformatting such a large stack.)
1495 Since the @kbd{-} key is also an operator (it subtracts the top two
1496 stack elements), how does one enter a negative number? Calc uses
1497 the @kbd{_} (underscore) key to act like the minus sign in a number.
1498 So, typing @kbd{-5 @key{RET}} won't work because the @kbd{-} key
1499 will try to do a subtraction, but @kbd{_5 @key{RET}} works just fine.
1501 You can also press @kbd{n}, which means ``change sign.'' It changes
1502 the number at the top of the stack (or the number being entered)
1503 from positive to negative or vice-versa: @kbd{5 n @key{RET}}.
1505 @cindex Duplicating a stack entry
1506 If you press @key{RET} when you're not entering a number, the effect
1507 is to duplicate the top number on the stack. Consider this calculation:
1511 1: 3 2: 3 1: 9 2: 9 1: 81
1515 3 @key{RET} @key{RET} * @key{RET} *
1520 (Of course, an easier way to do this would be @kbd{3 @key{RET} 4 ^},
1521 to raise 3 to the fourth power.)
1523 The space-bar key (denoted @key{SPC} here) performs the same function
1524 as @key{RET}; you could replace all three occurrences of @key{RET} in
1525 the above example with @key{SPC} and the effect would be the same.
1527 @cindex Exchanging stack entries
1528 Another stack manipulation key is @key{TAB}. This exchanges the top
1529 two stack entries. Suppose you have computed @kbd{2 @key{RET} 3 +}
1530 to get 5, and then you realize what you really wanted to compute
1531 was @expr{20 / (2+3)}.
1535 1: 5 2: 5 2: 20 1: 4
1539 2 @key{RET} 3 + 20 @key{TAB} /
1544 Planning ahead, the calculation would have gone like this:
1548 1: 20 2: 20 3: 20 2: 20 1: 4
1553 20 @key{RET} 2 @key{RET} 3 + /
1557 A related stack command is @kbd{M-@key{TAB}} (hold @key{META} and type
1558 @key{TAB}). It rotates the top three elements of the stack upward,
1559 bringing the object in level 3 to the top.
1563 1: 10 2: 10 3: 10 3: 20 3: 30
1564 . 1: 20 2: 20 2: 30 2: 10
1568 10 @key{RET} 20 @key{RET} 30 @key{RET} M-@key{TAB} M-@key{TAB}
1572 (@bullet{}) @strong{Exercise 3.} Suppose the numbers 10, 20, and 30 are
1573 on the stack. Figure out how to add one to the number in level 2
1574 without affecting the rest of the stack. Also figure out how to add
1575 one to the number in level 3. @xref{RPN Answer 3, 3}. (@bullet{})
1577 Operations like @kbd{+}, @kbd{-}, @kbd{*}, @kbd{/}, and @kbd{^} pop two
1578 arguments from the stack and push a result. Operations like @kbd{n} and
1579 @kbd{Q} (square root) pop a single number and push the result. You can
1580 think of them as simply operating on the top element of the stack.
1584 1: 3 1: 9 2: 9 1: 25 1: 5
1588 3 @key{RET} @key{RET} * 4 @key{RET} @key{RET} * + Q
1593 (Note that capital @kbd{Q} means to hold down the Shift key while
1594 typing @kbd{q}. Remember, plain unshifted @kbd{q} is the Quit command.)
1596 @cindex Pythagorean Theorem
1597 Here we've used the Pythagorean Theorem to determine the hypotenuse of a
1598 right triangle. Calc actually has a built-in command for that called
1599 @kbd{f h}, but let's suppose we can't remember the necessary keystrokes.
1600 We can still enter it by its full name using @kbd{M-x} notation:
1608 3 @key{RET} 4 @key{RET} M-x calc-hypot
1612 All Calculator commands begin with the word @samp{calc-}. Since it
1613 gets tiring to type this, Calc provides an @kbd{x} key which is just
1614 like the regular Emacs @kbd{M-x} key except that it types the @samp{calc-}
1623 3 @key{RET} 4 @key{RET} x hypot
1627 What happens if you take the square root of a negative number?
1631 1: 4 1: -4 1: (0, 2)
1639 The notation @expr{(a, b)} represents a complex number.
1640 Complex numbers are more traditionally written @expr{a + b i};
1641 Calc can display in this format, too, but for now we'll stick to the
1642 @expr{(a, b)} notation.
1644 If you don't know how complex numbers work, you can safely ignore this
1645 feature. Complex numbers only arise from operations that would be
1646 errors in a calculator that didn't have complex numbers. (For example,
1647 taking the square root or logarithm of a negative number produces a
1650 Complex numbers are entered in the notation shown. The @kbd{(} and
1651 @kbd{,} and @kbd{)} keys manipulate ``incomplete complex numbers.''
1655 1: ( ... 2: ( ... 1: (2, ... 1: (2, ... 1: (2, 3)
1663 You can perform calculations while entering parts of incomplete objects.
1664 However, an incomplete object cannot actually participate in a calculation:
1668 1: ( ... 2: ( ... 3: ( ... 1: ( ... 1: ( ...
1678 Adding 5 to an incomplete object makes no sense, so the last command
1679 produces an error message and leaves the stack the same.
1681 Incomplete objects can't participate in arithmetic, but they can be
1682 moved around by the regular stack commands.
1686 2: 2 3: 2 3: 3 1: ( ... 1: (2, 3)
1687 1: 3 2: 3 2: ( ... 2 .
1691 2 @key{RET} 3 @key{RET} ( M-@key{TAB} M-@key{TAB} )
1696 Note that the @kbd{,} (comma) key did not have to be used here.
1697 When you press @kbd{)} all the stack entries between the incomplete
1698 entry and the top are collected, so there's never really a reason
1699 to use the comma. It's up to you.
1701 (@bullet{}) @strong{Exercise 4.} To enter the complex number @expr{(2, 3)},
1702 your friend Joe typed @kbd{( 2 , @key{SPC} 3 )}. What happened?
1703 (Joe thought of a clever way to correct his mistake in only two
1704 keystrokes, but it didn't quite work. Try it to find out why.)
1705 @xref{RPN Answer 4, 4}. (@bullet{})
1707 Vectors are entered the same way as complex numbers, but with square
1708 brackets in place of parentheses. We'll meet vectors again later in
1711 Any Emacs command can be given a @dfn{numeric prefix argument} by
1712 typing a series of @key{META}-digits beforehand. If @key{META} is
1713 awkward for you, you can instead type @kbd{C-u} followed by the
1714 necessary digits. Numeric prefix arguments can be negative, as in
1715 @kbd{M-- M-3 M-5} or @w{@kbd{C-u - 3 5}}. Calc commands use numeric
1716 prefix arguments in a variety of ways. For example, a numeric prefix
1717 on the @kbd{+} operator adds any number of stack entries at once:
1721 1: 10 2: 10 3: 10 3: 10 1: 60
1722 . 1: 20 2: 20 2: 20 .
1726 10 @key{RET} 20 @key{RET} 30 @key{RET} C-u 3 +
1730 For stack manipulation commands like @key{RET}, a positive numeric
1731 prefix argument operates on the top @var{n} stack entries at once. A
1732 negative argument operates on the entry in level @var{n} only. An
1733 argument of zero operates on the entire stack. In this example, we copy
1734 the second-to-top element of the stack:
1738 1: 10 2: 10 3: 10 3: 10 4: 10
1739 . 1: 20 2: 20 2: 20 3: 20
1744 10 @key{RET} 20 @key{RET} 30 @key{RET} C-u -2 @key{RET}
1748 @cindex Clearing the stack
1749 @cindex Emptying the stack
1750 Another common idiom is @kbd{M-0 @key{DEL}}, which clears the stack.
1751 (The @kbd{M-0} numeric prefix tells @key{DEL} to operate on the
1754 @node Algebraic Tutorial, Undo Tutorial, RPN Tutorial, Basic Tutorial
1755 @subsection Algebraic-Style Calculations
1758 If you are not used to RPN notation, you may prefer to operate the
1759 Calculator in Algebraic mode, which is closer to the way
1760 non-RPN calculators work. In Algebraic mode, you enter formulas
1761 in traditional @expr{2+3} notation.
1763 @strong{Notice:} Calc gives @samp{/} lower precedence than @samp{*}, so
1764 that @samp{a/b*c} is interpreted as @samp{a/(b*c)}; this is not
1765 standard across all computer languages. See below for details.
1767 You don't really need any special ``mode'' to enter algebraic formulas.
1768 You can enter a formula at any time by pressing the apostrophe (@kbd{'})
1769 key. Answer the prompt with the desired formula, then press @key{RET}.
1770 The formula is evaluated and the result is pushed onto the RPN stack.
1771 If you don't want to think in RPN at all, you can enter your whole
1772 computation as a formula, read the result from the stack, then press
1773 @key{DEL} to delete it from the stack.
1775 Try pressing the apostrophe key, then @kbd{2+3+4}, then @key{RET}.
1776 The result should be the number 9.
1778 Algebraic formulas use the operators @samp{+}, @samp{-}, @samp{*},
1779 @samp{/}, and @samp{^}. You can use parentheses to make the order
1780 of evaluation clear. In the absence of parentheses, @samp{^} is
1781 evaluated first, then @samp{*}, then @samp{/}, then finally
1782 @samp{+} and @samp{-}. For example, the expression
1785 2 + 3*4*5 / 6*7^8 - 9
1792 2 + ((3*4*5) / (6*(7^8)) - 9
1796 or, in large mathematical notation,
1810 $$ 2 + { 3 \times 4 \times 5 \over 6 \times 7^8 } - 9 $$
1815 The result of this expression will be the number @mathit{-6.99999826533}.
1817 Calc's order of evaluation is the same as for most computer languages,
1818 except that @samp{*} binds more strongly than @samp{/}, as the above
1819 example shows. As in normal mathematical notation, the @samp{*} symbol
1820 can often be omitted: @samp{2 a} is the same as @samp{2*a}.
1822 Operators at the same level are evaluated from left to right, except
1823 that @samp{^} is evaluated from right to left. Thus, @samp{2-3-4} is
1824 equivalent to @samp{(2-3)-4} or @mathit{-5}, whereas @samp{2^3^4} is equivalent
1825 to @samp{2^(3^4)} (a very large integer; try it!).
1827 If you tire of typing the apostrophe all the time, there is
1828 Algebraic mode, where Calc automatically senses
1829 when you are about to type an algebraic expression. To enter this
1830 mode, press the two letters @w{@kbd{m a}}. (An @samp{Alg} indicator
1831 should appear in the Calc window's mode line.)
1833 Press @kbd{m a}, then @kbd{2+3+4} with no apostrophe, then @key{RET}.
1835 In Algebraic mode, when you press any key that would normally begin
1836 entering a number (such as a digit, a decimal point, or the @kbd{_}
1837 key), or if you press @kbd{(} or @kbd{[}, Calc automatically begins
1840 Functions which do not have operator symbols like @samp{+} and @samp{*}
1841 must be entered in formulas using function-call notation. For example,
1842 the function name corresponding to the square-root key @kbd{Q} is
1843 @code{sqrt}. To compute a square root in a formula, you would use
1844 the notation @samp{sqrt(@var{x})}.
1846 Press the apostrophe, then type @kbd{sqrt(5*2) - 3}. The result should
1847 be @expr{0.16227766017}.
1849 Note that if the formula begins with a function name, you need to use
1850 the apostrophe even if you are in Algebraic mode. If you type @kbd{arcsin}
1851 out of the blue, the @kbd{a r} will be taken as an Algebraic Rewrite
1852 command, and the @kbd{csin} will be taken as the name of the rewrite
1855 Some people prefer to enter complex numbers and vectors in algebraic
1856 form because they find RPN entry with incomplete objects to be too
1857 distracting, even though they otherwise use Calc as an RPN calculator.
1859 Still in Algebraic mode, type:
1863 1: (2, 3) 2: (2, 3) 1: (8, -1) 2: (8, -1) 1: (9, -1)
1864 . 1: (1, -2) . 1: 1 .
1867 (2,3) @key{RET} (1,-2) @key{RET} * 1 @key{RET} +
1871 Algebraic mode allows us to enter complex numbers without pressing
1872 an apostrophe first, but it also means we need to press @key{RET}
1873 after every entry, even for a simple number like @expr{1}.
1875 (You can type @kbd{C-u m a} to enable a special Incomplete Algebraic
1876 mode in which the @kbd{(} and @kbd{[} keys use algebraic entry even
1877 though regular numeric keys still use RPN numeric entry. There is also
1878 Total Algebraic mode, started by typing @kbd{m t}, in which all
1879 normal keys begin algebraic entry. You must then use the @key{META} key
1880 to type Calc commands: @kbd{M-m t} to get back out of Total Algebraic
1881 mode, @kbd{M-q} to quit, etc.)
1883 If you're still in Algebraic mode, press @kbd{m a} again to turn it off.
1885 Actual non-RPN calculators use a mixture of algebraic and RPN styles.
1886 In general, operators of two numbers (like @kbd{+} and @kbd{*})
1887 use algebraic form, but operators of one number (like @kbd{n} and @kbd{Q})
1888 use RPN form. Also, a non-RPN calculator allows you to see the
1889 intermediate results of a calculation as you go along. You can
1890 accomplish this in Calc by performing your calculation as a series
1891 of algebraic entries, using the @kbd{$} sign to tie them together.
1892 In an algebraic formula, @kbd{$} represents the number on the top
1893 of the stack. Here, we perform the calculation
1894 @texline @math{\sqrt{2\times4+1}},
1895 @infoline @expr{sqrt(2*4+1)},
1896 which on a traditional calculator would be done by pressing
1897 @kbd{2 * 4 + 1 =} and then the square-root key.
1904 ' 2*4 @key{RET} $+1 @key{RET} Q
1909 Notice that we didn't need to press an apostrophe for the @kbd{$+1},
1910 because the dollar sign always begins an algebraic entry.
1912 (@bullet{}) @strong{Exercise 1.} How could you get the same effect as
1913 pressing @kbd{Q} but using an algebraic entry instead? How about
1914 if the @kbd{Q} key on your keyboard were broken?
1915 @xref{Algebraic Answer 1, 1}. (@bullet{})
1917 The notations @kbd{$$}, @kbd{$$$}, and so on stand for higher stack
1918 entries. For example, @kbd{' $$+$ @key{RET}} is just like typing @kbd{+}.
1920 Algebraic formulas can include @dfn{variables}. To store in a
1921 variable, press @kbd{s s}, then type the variable name, then press
1922 @key{RET}. (There are actually two flavors of store command:
1923 @kbd{s s} stores a number in a variable but also leaves the number
1924 on the stack, while @w{@kbd{s t}} removes a number from the stack and
1925 stores it in the variable.) A variable name should consist of one
1926 or more letters or digits, beginning with a letter.
1930 1: 17 . 1: a + a^2 1: 306
1933 17 s t a @key{RET} ' a+a^2 @key{RET} =
1938 The @kbd{=} key @dfn{evaluates} a formula by replacing all its
1939 variables by the values that were stored in them.
1941 For RPN calculations, you can recall a variable's value on the
1942 stack either by entering its name as a formula and pressing @kbd{=},
1943 or by using the @kbd{s r} command.
1947 1: 17 2: 17 3: 17 2: 17 1: 306
1948 . 1: 17 2: 17 1: 289 .
1952 s r a @key{RET} ' a @key{RET} = 2 ^ +
1956 If you press a single digit for a variable name (as in @kbd{s t 3}, you
1957 get one of ten @dfn{quick variables} @code{q0} through @code{q9}.
1958 They are ``quick'' simply because you don't have to type the letter
1959 @code{q} or the @key{RET} after their names. In fact, you can type
1960 simply @kbd{s 3} as a shorthand for @kbd{s s 3}, and likewise for
1961 @kbd{t 3} and @w{@kbd{r 3}}.
1963 Any variables in an algebraic formula for which you have not stored
1964 values are left alone, even when you evaluate the formula.
1968 1: 2 a + 2 b 1: 34 + 2 b
1975 Calls to function names which are undefined in Calc are also left
1976 alone, as are calls for which the value is undefined.
1980 1: 2 + log10(0) + log10(x) + log10(5, 6) + foo(3)
1983 ' log10(100) + log10(0) + log10(x) + log10(5,6) + foo(3) @key{RET}
1988 In this example, the first call to @code{log10} works, but the other
1989 calls are not evaluated. In the second call, the logarithm is
1990 undefined for that value of the argument; in the third, the argument
1991 is symbolic, and in the fourth, there are too many arguments. In the
1992 fifth case, there is no function called @code{foo}. You will see a
1993 ``Wrong number of arguments'' message referring to @samp{log10(5,6)}.
1994 Press the @kbd{w} (``why'') key to see any other messages that may
1995 have arisen from the last calculation. In this case you will get
1996 ``logarithm of zero,'' then ``number expected: @code{x}''. Calc
1997 automatically displays the first message only if the message is
1998 sufficiently important; for example, Calc considers ``wrong number
1999 of arguments'' and ``logarithm of zero'' to be important enough to
2000 report automatically, while a message like ``number expected: @code{x}''
2001 will only show up if you explicitly press the @kbd{w} key.
2003 (@bullet{}) @strong{Exercise 2.} Joe entered the formula @samp{2 x y},
2004 stored 5 in @code{x}, pressed @kbd{=}, and got the expected result,
2005 @samp{10 y}. He then tried the same for the formula @samp{2 x (1+y)},
2006 expecting @samp{10 (1+y)}, but it didn't work. Why not?
2007 @xref{Algebraic Answer 2, 2}. (@bullet{})
2009 (@bullet{}) @strong{Exercise 3.} What result would you expect
2010 @kbd{1 @key{RET} 0 /} to give? What if you then type @kbd{0 *}?
2011 @xref{Algebraic Answer 3, 3}. (@bullet{})
2013 One interesting way to work with variables is to use the
2014 @dfn{evaluates-to} (@samp{=>}) operator. It works like this:
2015 Enter a formula algebraically in the usual way, but follow
2016 the formula with an @samp{=>} symbol. (There is also an @kbd{s =}
2017 command which builds an @samp{=>} formula using the stack.) On
2018 the stack, you will see two copies of the formula with an @samp{=>}
2019 between them. The lefthand formula is exactly like you typed it;
2020 the righthand formula has been evaluated as if by typing @kbd{=}.
2024 2: 2 + 3 => 5 2: 2 + 3 => 5
2025 1: 2 a + 2 b => 34 + 2 b 1: 2 a + 2 b => 20 + 2 b
2028 ' 2+3 => @key{RET} ' 2a+2b @key{RET} s = 10 s t a @key{RET}
2033 Notice that the instant we stored a new value in @code{a}, all
2034 @samp{=>} operators already on the stack that referred to @expr{a}
2035 were updated to use the new value. With @samp{=>}, you can push a
2036 set of formulas on the stack, then change the variables experimentally
2037 to see the effects on the formulas' values.
2039 You can also ``unstore'' a variable when you are through with it:
2044 1: 2 a + 2 b => 2 a + 2 b
2051 We will encounter formulas involving variables and functions again
2052 when we discuss the algebra and calculus features of the Calculator.
2054 @node Undo Tutorial, Modes Tutorial, Algebraic Tutorial, Basic Tutorial
2055 @subsection Undo and Redo
2058 If you make a mistake, you can usually correct it by pressing shift-@kbd{U},
2059 the ``undo'' command. First, clear the stack (@kbd{M-0 @key{DEL}}) and exit
2060 and restart Calc (@kbd{C-x * * C-x * *}) to make sure things start off
2061 with a clean slate. Now:
2065 1: 2 2: 2 1: 8 2: 2 1: 6
2073 You can undo any number of times. Calc keeps a complete record of
2074 all you have done since you last opened the Calc window. After the
2075 above example, you could type:
2087 You can also type @kbd{D} to ``redo'' a command that you have undone
2092 . 1: 2 2: 2 1: 6 1: 6
2101 It was not possible to redo past the @expr{6}, since that was placed there
2102 by something other than an undo command.
2105 You can think of undo and redo as a sort of ``time machine.'' Press
2106 @kbd{U} to go backward in time, @kbd{D} to go forward. If you go
2107 backward and do something (like @kbd{*}) then, as any science fiction
2108 reader knows, you have changed your future and you cannot go forward
2109 again. Thus, the inability to redo past the @expr{6} even though there
2110 was an earlier undo command.
2112 You can always recall an earlier result using the Trail. We've ignored
2113 the trail so far, but it has been faithfully recording everything we
2114 did since we loaded the Calculator. If the Trail is not displayed,
2115 press @kbd{t d} now to turn it on.
2117 Let's try grabbing an earlier result. The @expr{8} we computed was
2118 undone by a @kbd{U} command, and was lost even to Redo when we pressed
2119 @kbd{*}, but it's still there in the trail. There should be a little
2120 @samp{>} arrow (the @dfn{trail pointer}) resting on the last trail
2121 entry. If there isn't, press @kbd{t ]} to reset the trail pointer.
2122 Now, press @w{@kbd{t p}} to move the arrow onto the line containing
2123 @expr{8}, and press @w{@kbd{t y}} to ``yank'' that number back onto the
2126 If you press @kbd{t ]} again, you will see that even our Yank command
2127 went into the trail.
2129 Let's go further back in time. Earlier in the tutorial we computed
2130 a huge integer using the formula @samp{2^3^4}. We don't remember
2131 what it was, but the first digits were ``241''. Press @kbd{t r}
2132 (which stands for trail-search-reverse), then type @kbd{241}.
2133 The trail cursor will jump back to the next previous occurrence of
2134 the string ``241'' in the trail. This is just a regular Emacs
2135 incremental search; you can now press @kbd{C-s} or @kbd{C-r} to
2136 continue the search forwards or backwards as you like.
2138 To finish the search, press @key{RET}. This halts the incremental
2139 search and leaves the trail pointer at the thing we found. Now we
2140 can type @kbd{t y} to yank that number onto the stack. If we hadn't
2141 remembered the ``241'', we could simply have searched for @kbd{2^3^4},
2142 then pressed @kbd{@key{RET} t n} to halt and then move to the next item.
2144 You may have noticed that all the trail-related commands begin with
2145 the letter @kbd{t}. (The store-and-recall commands, on the other hand,
2146 all began with @kbd{s}.) Calc has so many commands that there aren't
2147 enough keys for all of them, so various commands are grouped into
2148 two-letter sequences where the first letter is called the @dfn{prefix}
2149 key. If you type a prefix key by accident, you can press @kbd{C-g}
2150 to cancel it. (In fact, you can press @kbd{C-g} to cancel almost
2151 anything in Emacs.) To get help on a prefix key, press that key
2152 followed by @kbd{?}. Some prefixes have several lines of help,
2153 so you need to press @kbd{?} repeatedly to see them all.
2154 You can also type @kbd{h h} to see all the help at once.
2156 Try pressing @kbd{t ?} now. You will see a line of the form,
2159 trail/time: Display; Fwd, Back; Next, Prev, Here, [, ]; Yank: [MORE] t-
2163 The word ``trail'' indicates that the @kbd{t} prefix key contains
2164 trail-related commands. Each entry on the line shows one command,
2165 with a single capital letter showing which letter you press to get
2166 that command. We have used @kbd{t n}, @kbd{t p}, @kbd{t ]}, and
2167 @kbd{t y} so far. The @samp{[MORE]} means you can press @kbd{?}
2168 again to see more @kbd{t}-prefix commands. Notice that the commands
2169 are roughly divided (by semicolons) into related groups.
2171 When you are in the help display for a prefix key, the prefix is
2172 still active. If you press another key, like @kbd{y} for example,
2173 it will be interpreted as a @kbd{t y} command. If all you wanted
2174 was to look at the help messages, press @kbd{C-g} afterwards to cancel
2177 One more way to correct an error is by editing the stack entries.
2178 The actual Stack buffer is marked read-only and must not be edited
2179 directly, but you can press @kbd{`} (the backquote or accent grave)
2180 to edit a stack entry.
2182 Try entering @samp{3.141439} now. If this is supposed to represent
2183 @cpi{}, it's got several errors. Press @kbd{`} to edit this number.
2184 Now use the normal Emacs cursor motion and editing keys to change
2185 the second 4 to a 5, and to transpose the 3 and the 9. When you
2186 press @key{RET}, the number on the stack will be replaced by your
2187 new number. This works for formulas, vectors, and all other types
2188 of values you can put on the stack. The @kbd{`} key also works
2189 during entry of a number or algebraic formula.
2191 @node Modes Tutorial, , Undo Tutorial, Basic Tutorial
2192 @subsection Mode-Setting Commands
2195 Calc has many types of @dfn{modes} that affect the way it interprets
2196 your commands or the way it displays data. We have already seen one
2197 mode, namely Algebraic mode. There are many others, too; we'll
2198 try some of the most common ones here.
2200 Perhaps the most fundamental mode in Calc is the current @dfn{precision}.
2201 Notice the @samp{12} on the Calc window's mode line:
2204 --%*-Calc: 12 Deg (Calculator)----All------
2208 Most of the symbols there are Emacs things you don't need to worry
2209 about, but the @samp{12} and the @samp{Deg} are mode indicators.
2210 The @samp{12} means that calculations should always be carried to
2211 12 significant figures. That is why, when we type @kbd{1 @key{RET} 7 /},
2212 we get @expr{0.142857142857} with exactly 12 digits, not counting
2213 leading and trailing zeros.
2215 You can set the precision to anything you like by pressing @kbd{p},
2216 then entering a suitable number. Try pressing @kbd{p 30 @key{RET}},
2217 then doing @kbd{1 @key{RET} 7 /} again:
2222 2: 0.142857142857142857142857142857
2227 Although the precision can be set arbitrarily high, Calc always
2228 has to have @emph{some} value for the current precision. After
2229 all, the true value @expr{1/7} is an infinitely repeating decimal;
2230 Calc has to stop somewhere.
2232 Of course, calculations are slower the more digits you request.
2233 Press @w{@kbd{p 12}} now to set the precision back down to the default.
2235 Calculations always use the current precision. For example, even
2236 though we have a 30-digit value for @expr{1/7} on the stack, if
2237 we use it in a calculation in 12-digit mode it will be rounded
2238 down to 12 digits before it is used. Try it; press @key{RET} to
2239 duplicate the number, then @w{@kbd{1 +}}. Notice that the @key{RET}
2240 key didn't round the number, because it doesn't do any calculation.
2241 But the instant we pressed @kbd{+}, the number was rounded down.
2246 2: 0.142857142857142857142857142857
2253 In fact, since we added a digit on the left, we had to lose one
2254 digit on the right from even the 12-digit value of @expr{1/7}.
2256 How did we get more than 12 digits when we computed @samp{2^3^4}? The
2257 answer is that Calc makes a distinction between @dfn{integers} and
2258 @dfn{floating-point} numbers, or @dfn{floats}. An integer is a number
2259 that does not contain a decimal point. There is no such thing as an
2260 ``infinitely repeating fraction integer,'' so Calc doesn't have to limit
2261 itself. If you asked for @samp{2^10000} (don't try this!), you would
2262 have to wait a long time but you would eventually get an exact answer.
2263 If you ask for @samp{2.^10000}, you will quickly get an answer which is
2264 correct only to 12 places. The decimal point tells Calc that it should
2265 use floating-point arithmetic to get the answer, not exact integer
2268 You can use the @kbd{F} (@code{calc-floor}) command to convert a
2269 floating-point value to an integer, and @kbd{c f} (@code{calc-float})
2270 to convert an integer to floating-point form.
2272 Let's try entering that last calculation:
2276 1: 2. 2: 2. 1: 1.99506311689e3010
2280 2.0 @key{RET} 10000 @key{RET} ^
2285 @cindex Scientific notation, entry of
2286 Notice the letter @samp{e} in there. It represents ``times ten to the
2287 power of,'' and is used by Calc automatically whenever writing the
2288 number out fully would introduce more extra zeros than you probably
2289 want to see. You can enter numbers in this notation, too.
2293 1: 2. 2: 2. 1: 1.99506311678e3010
2297 2.0 @key{RET} 1e4 @key{RET} ^
2301 @cindex Round-off errors
2303 Hey, the answer is different! Look closely at the middle columns
2304 of the two examples. In the first, the stack contained the
2305 exact integer @expr{10000}, but in the second it contained
2306 a floating-point value with a decimal point. When you raise a
2307 number to an integer power, Calc uses repeated squaring and
2308 multiplication to get the answer. When you use a floating-point
2309 power, Calc uses logarithms and exponentials. As you can see,
2310 a slight error crept in during one of these methods. Which
2311 one should we trust? Let's raise the precision a bit and find
2316 . 1: 2. 2: 2. 1: 1.995063116880828e3010
2320 p 16 @key{RET} 2. @key{RET} 1e4 ^ p 12 @key{RET}
2325 @cindex Guard digits
2326 Presumably, it doesn't matter whether we do this higher-precision
2327 calculation using an integer or floating-point power, since we
2328 have added enough ``guard digits'' to trust the first 12 digits
2329 no matter what. And the verdict is@dots{} Integer powers were more
2330 accurate; in fact, the result was only off by one unit in the
2333 @cindex Guard digits
2334 Calc does many of its internal calculations to a slightly higher
2335 precision, but it doesn't always bump the precision up enough.
2336 In each case, Calc added about two digits of precision during
2337 its calculation and then rounded back down to 12 digits
2338 afterward. In one case, it was enough; in the other, it
2339 wasn't. If you really need @var{x} digits of precision, it
2340 never hurts to do the calculation with a few extra guard digits.
2342 What if we want guard digits but don't want to look at them?
2343 We can set the @dfn{float format}. Calc supports four major
2344 formats for floating-point numbers, called @dfn{normal},
2345 @dfn{fixed-point}, @dfn{scientific notation}, and @dfn{engineering
2346 notation}. You get them by pressing @w{@kbd{d n}}, @kbd{d f},
2347 @kbd{d s}, and @kbd{d e}, respectively. In each case, you can
2348 supply a numeric prefix argument which says how many digits
2349 should be displayed. As an example, let's put a few numbers
2350 onto the stack and try some different display modes. First,
2351 use @kbd{M-0 @key{DEL}} to clear the stack, then enter the four
2356 4: 12345 4: 12345 4: 12345 4: 12345 4: 12345
2357 3: 12345. 3: 12300. 3: 1.2345e4 3: 1.23e4 3: 12345.000
2358 2: 123.45 2: 123. 2: 1.2345e2 2: 1.23e2 2: 123.450
2359 1: 12.345 1: 12.3 1: 1.2345e1 1: 1.23e1 1: 12.345
2362 d n M-3 d n d s M-3 d s M-3 d f
2367 Notice that when we typed @kbd{M-3 d n}, the numbers were rounded down
2368 to three significant digits, but then when we typed @kbd{d s} all
2369 five significant figures reappeared. The float format does not
2370 affect how numbers are stored, it only affects how they are
2371 displayed. Only the current precision governs the actual rounding
2372 of numbers in the Calculator's memory.
2374 Engineering notation, not shown here, is like scientific notation
2375 except the exponent (the power-of-ten part) is always adjusted to be
2376 a multiple of three (as in ``kilo,'' ``micro,'' etc.). As a result
2377 there will be one, two, or three digits before the decimal point.
2379 Whenever you change a display-related mode, Calc redraws everything
2380 in the stack. This may be slow if there are many things on the stack,
2381 so Calc allows you to type shift-@kbd{H} before any mode command to
2382 prevent it from updating the stack. Anything Calc displays after the
2383 mode-changing command will appear in the new format.
2387 4: 12345 4: 12345 4: 12345 4: 12345 4: 12345
2388 3: 12345.000 3: 12345.000 3: 12345.000 3: 1.2345e4 3: 12345.
2389 2: 123.450 2: 123.450 2: 1.2345e1 2: 1.2345e1 2: 123.45
2390 1: 12.345 1: 1.2345e1 1: 1.2345e2 1: 1.2345e2 1: 12.345
2393 H d s @key{DEL} U @key{TAB} d @key{SPC} d n
2398 Here the @kbd{H d s} command changes to scientific notation but without
2399 updating the screen. Deleting the top stack entry and undoing it back
2400 causes it to show up in the new format; swapping the top two stack
2401 entries reformats both entries. The @kbd{d @key{SPC}} command refreshes the
2402 whole stack. The @kbd{d n} command changes back to the normal float
2403 format; since it doesn't have an @kbd{H} prefix, it also updates all
2404 the stack entries to be in @kbd{d n} format.
2406 Notice that the integer @expr{12345} was not affected by any
2407 of the float formats. Integers are integers, and are always
2410 @cindex Large numbers, readability
2411 Large integers have their own problems. Let's look back at
2412 the result of @kbd{2^3^4}.
2415 2417851639229258349412352
2419 Quick---how many digits does this have? Try typing @kbd{d g}:
2422 2,417,851,639,229,258,349,412,352
2426 Now how many digits does this have? It's much easier to tell!
2427 We can actually group digits into clumps of any size. Some
2428 people prefer @kbd{M-5 d g}:
2431 24178,51639,22925,83494,12352
2434 Let's see what happens to floating-point numbers when they are grouped.
2435 First, type @kbd{p 25 @key{RET}} to make sure we have enough precision
2436 to get ourselves into trouble. Now, type @kbd{1e13 /}:
2439 24,17851,63922.9258349412352
2443 The integer part is grouped but the fractional part isn't. Now try
2444 @kbd{M-- M-5 d g} (that's meta-minus-sign, meta-five):
2447 24,17851,63922.92583,49412,352
2450 If you find it hard to tell the decimal point from the commas, try
2451 changing the grouping character to a space with @kbd{d , @key{SPC}}:
2454 24 17851 63922.92583 49412 352
2457 Type @kbd{d , ,} to restore the normal grouping character, then
2458 @kbd{d g} again to turn grouping off. Also, press @kbd{p 12} to
2459 restore the default precision.
2461 Press @kbd{U} enough times to get the original big integer back.
2462 (Notice that @kbd{U} does not undo each mode-setting command; if
2463 you want to undo a mode-setting command, you have to do it yourself.)
2464 Now, type @kbd{d r 16 @key{RET}}:
2467 16#200000000000000000000
2471 The number is now displayed in @dfn{hexadecimal}, or ``base-16'' form.
2472 Suddenly it looks pretty simple; this should be no surprise, since we
2473 got this number by computing a power of two, and 16 is a power of 2.
2474 In fact, we can use @w{@kbd{d r 2 @key{RET}}} to see it in actual binary
2478 2#1000000000000000000000000000000000000000000000000000000 @dots{}
2482 We don't have enough space here to show all the zeros! They won't
2483 fit on a typical screen, either, so you will have to use horizontal
2484 scrolling to see them all. Press @kbd{<} and @kbd{>} to scroll the
2485 stack window left and right by half its width. Another way to view
2486 something large is to press @kbd{`} (back-quote) to edit the top of
2487 stack in a separate window. (Press @kbd{C-c C-c} when you are done.)
2489 You can enter non-decimal numbers using the @kbd{#} symbol, too.
2490 Let's see what the hexadecimal number @samp{5FE} looks like in
2491 binary. Type @kbd{16#5FE} (the letters can be typed in upper or
2492 lower case; they will always appear in upper case). It will also
2493 help to turn grouping on with @kbd{d g}:
2499 Notice that @kbd{d g} groups by fours by default if the display radix
2500 is binary or hexadecimal, but by threes if it is decimal, octal, or any
2503 Now let's see that number in decimal; type @kbd{d r 10}:
2509 Numbers are not @emph{stored} with any particular radix attached. They're
2510 just numbers; they can be entered in any radix, and are always displayed
2511 in whatever radix you've chosen with @kbd{d r}. The current radix applies
2512 to integers, fractions, and floats.
2514 @cindex Roundoff errors, in non-decimal numbers
2515 (@bullet{}) @strong{Exercise 1.} Your friend Joe tried to enter one-third
2516 as @samp{3#0.1} in @kbd{d r 3} mode with a precision of 12. He got
2517 @samp{3#0.0222222...} (with 25 2's) in the display. When he multiplied
2518 that by three, he got @samp{3#0.222222...} instead of the expected
2519 @samp{3#1}. Next, Joe entered @samp{3#0.2} and, to his great relief,
2520 saw @samp{3#0.2} on the screen. But when he typed @kbd{2 /}, he got
2521 @samp{3#0.10000001} (some zeros omitted). What's going on here?
2522 @xref{Modes Answer 1, 1}. (@bullet{})
2524 @cindex Scientific notation, in non-decimal numbers
2525 (@bullet{}) @strong{Exercise 2.} Scientific notation works in non-decimal
2526 modes in the natural way (the exponent is a power of the radix instead of
2527 a power of ten, although the exponent itself is always written in decimal).
2528 Thus @samp{8#1.23e3 = 8#1230.0}. Suppose we have the hexadecimal number
2529 @samp{f.e8f} times 16 to the 15th power: We write @samp{16#f.e8fe15}.
2530 What is wrong with this picture? What could we write instead that would
2531 work better? @xref{Modes Answer 2, 2}. (@bullet{})
2533 The @kbd{m} prefix key has another set of modes, relating to the way
2534 Calc interprets your inputs and does computations. Whereas @kbd{d}-prefix
2535 modes generally affect the way things look, @kbd{m}-prefix modes affect
2536 the way they are actually computed.
2538 The most popular @kbd{m}-prefix mode is the @dfn{angular mode}. Notice
2539 the @samp{Deg} indicator in the mode line. This means that if you use
2540 a command that interprets a number as an angle, it will assume the
2541 angle is measured in degrees. For example,
2545 1: 45 1: 0.707106781187 1: 0.500000000001 1: 0.5
2553 The shift-@kbd{S} command computes the sine of an angle. The sine
2555 @texline @math{\sqrt{2}/2};
2556 @infoline @expr{sqrt(2)/2};
2557 squaring this yields @expr{2/4 = 0.5}. However, there has been a slight
2558 roundoff error because the representation of
2559 @texline @math{\sqrt{2}/2}
2560 @infoline @expr{sqrt(2)/2}
2561 wasn't exact. The @kbd{c 1} command is a handy way to clean up numbers
2562 in this case; it temporarily reduces the precision by one digit while it
2563 re-rounds the number on the top of the stack.
2565 @cindex Roundoff errors, examples
2566 (@bullet{}) @strong{Exercise 3.} Your friend Joe computed the sine
2567 of 45 degrees as shown above, then, hoping to avoid an inexact
2568 result, he increased the precision to 16 digits before squaring.
2569 What happened? @xref{Modes Answer 3, 3}. (@bullet{})
2571 To do this calculation in radians, we would type @kbd{m r} first.
2572 (The indicator changes to @samp{Rad}.) 45 degrees corresponds to
2573 @cpiover{4} radians. To get @cpi{}, press the @kbd{P} key. (Once
2574 again, this is a shifted capital @kbd{P}. Remember, unshifted
2575 @kbd{p} sets the precision.)
2579 1: 3.14159265359 1: 0.785398163398 1: 0.707106781187
2586 Likewise, inverse trigonometric functions generate results in
2587 either radians or degrees, depending on the current angular mode.
2591 1: 0.707106781187 1: 0.785398163398 1: 45.
2594 .5 Q m r I S m d U I S
2599 Here we compute the Inverse Sine of
2600 @texline @math{\sqrt{0.5}},
2601 @infoline @expr{sqrt(0.5)},
2602 first in radians, then in degrees.
2604 Use @kbd{c d} and @kbd{c r} to convert a number from radians to degrees
2609 1: 45 1: 0.785398163397 1: 45.
2616 Another interesting mode is @dfn{Fraction mode}. Normally,
2617 dividing two integers produces a floating-point result if the
2618 quotient can't be expressed as an exact integer. Fraction mode
2619 causes integer division to produce a fraction, i.e., a rational
2624 2: 12 1: 1.33333333333 1: 4:3
2628 12 @key{RET} 9 / m f U / m f
2633 In the first case, we get an approximate floating-point result.
2634 In the second case, we get an exact fractional result (four-thirds).
2636 You can enter a fraction at any time using @kbd{:} notation.
2637 (Calc uses @kbd{:} instead of @kbd{/} as the fraction separator
2638 because @kbd{/} is already used to divide the top two stack
2639 elements.) Calculations involving fractions will always
2640 produce exact fractional results; Fraction mode only says
2641 what to do when dividing two integers.
2643 @cindex Fractions vs. floats
2644 @cindex Floats vs. fractions
2645 (@bullet{}) @strong{Exercise 4.} If fractional arithmetic is exact,
2646 why would you ever use floating-point numbers instead?
2647 @xref{Modes Answer 4, 4}. (@bullet{})
2649 Typing @kbd{m f} doesn't change any existing values in the stack.
2650 In the above example, we had to Undo the division and do it over
2651 again when we changed to Fraction mode. But if you use the
2652 evaluates-to operator you can get commands like @kbd{m f} to
2657 1: 12 / 9 => 1.33333333333 1: 12 / 9 => 1.333 1: 12 / 9 => 4:3
2660 ' 12/9 => @key{RET} p 4 @key{RET} m f
2665 In this example, the righthand side of the @samp{=>} operator
2666 on the stack is recomputed when we change the precision, then
2667 again when we change to Fraction mode. All @samp{=>} expressions
2668 on the stack are recomputed every time you change any mode that
2669 might affect their values.
2671 @node Arithmetic Tutorial, Vector/Matrix Tutorial, Basic Tutorial, Tutorial
2672 @section Arithmetic Tutorial
2675 In this section, we explore the arithmetic and scientific functions
2676 available in the Calculator.
2678 The standard arithmetic commands are @kbd{+}, @kbd{-}, @kbd{*}, @kbd{/},
2679 and @kbd{^}. Each normally takes two numbers from the top of the stack
2680 and pushes back a result. The @kbd{n} and @kbd{&} keys perform
2681 change-sign and reciprocal operations, respectively.
2685 1: 5 1: 0.2 1: 5. 1: -5. 1: 5.
2692 @cindex Binary operators
2693 You can apply a ``binary operator'' like @kbd{+} across any number of
2694 stack entries by giving it a numeric prefix. You can also apply it
2695 pairwise to several stack elements along with the top one if you use
2700 3: 2 1: 9 3: 2 4: 2 3: 12
2701 2: 3 . 2: 3 3: 3 2: 13
2702 1: 4 1: 4 2: 4 1: 14
2706 2 @key{RET} 3 @key{RET} 4 M-3 + U 10 M-- M-3 +
2710 @cindex Unary operators
2711 You can apply a ``unary operator'' like @kbd{&} to the top @var{n}
2712 stack entries with a numeric prefix, too.
2717 2: 3 2: 0.333333333333 2: 3.
2721 2 @key{RET} 3 @key{RET} 4 M-3 & M-2 &
2725 Notice that the results here are left in floating-point form.
2726 We can convert them back to integers by pressing @kbd{F}, the
2727 ``floor'' function. This function rounds down to the next lower
2728 integer. There is also @kbd{R}, which rounds to the nearest
2746 Since dividing-and-flooring (i.e., ``integer quotient'') is such a
2747 common operation, Calc provides a special command for that purpose, the
2748 backslash @kbd{\}. Another common arithmetic operator is @kbd{%}, which
2749 computes the remainder that would arise from a @kbd{\} operation, i.e.,
2750 the ``modulo'' of two numbers. For example,
2754 2: 1234 1: 12 2: 1234 1: 34
2758 1234 @key{RET} 100 \ U %
2762 These commands actually work for any real numbers, not just integers.
2766 2: 3.1415 1: 3 2: 3.1415 1: 0.1415
2770 3.1415 @key{RET} 1 \ U %
2774 (@bullet{}) @strong{Exercise 1.} The @kbd{\} command would appear to be a
2775 frill, since you could always do the same thing with @kbd{/ F}. Think
2776 of a situation where this is not true---@kbd{/ F} would be inadequate.
2777 Now think of a way you could get around the problem if Calc didn't
2778 provide a @kbd{\} command. @xref{Arithmetic Answer 1, 1}. (@bullet{})
2780 We've already seen the @kbd{Q} (square root) and @kbd{S} (sine)
2781 commands. Other commands along those lines are @kbd{C} (cosine),
2782 @kbd{T} (tangent), @kbd{E} (@expr{e^x}) and @kbd{L} (natural
2783 logarithm). These can be modified by the @kbd{I} (inverse) and
2784 @kbd{H} (hyperbolic) prefix keys.
2786 Let's compute the sine and cosine of an angle, and verify the
2788 @texline @math{\sin^2x + \cos^2x = 1}.
2789 @infoline @expr{sin(x)^2 + cos(x)^2 = 1}.
2790 We'll arbitrarily pick @mathit{-64} degrees as a good value for @expr{x}.
2791 With the angular mode set to degrees (type @w{@kbd{m d}}), do:
2795 2: -64 2: -64 2: -0.89879 2: -0.89879 1: 1.
2796 1: -64 1: -0.89879 1: -64 1: 0.43837 .
2799 64 n @key{RET} @key{RET} S @key{TAB} C f h
2804 (For brevity, we're showing only five digits of the results here.
2805 You can of course do these calculations to any precision you like.)
2807 Remember, @kbd{f h} is the @code{calc-hypot}, or square-root of sum
2808 of squares, command.
2811 @texline @math{\displaystyle\tan x = {\sin x \over \cos x}}.
2812 @infoline @expr{tan(x) = sin(x) / cos(x)}.
2816 2: -0.89879 1: -2.0503 1: -64.
2824 A physical interpretation of this calculation is that if you move
2825 @expr{0.89879} units downward and @expr{0.43837} units to the right,
2826 your direction of motion is @mathit{-64} degrees from horizontal. Suppose
2827 we move in the opposite direction, up and to the left:
2831 2: -0.89879 2: 0.89879 1: -2.0503 1: -64.
2832 1: 0.43837 1: -0.43837 . .
2840 How can the angle be the same? The answer is that the @kbd{/} operation
2841 loses information about the signs of its inputs. Because the quotient
2842 is negative, we know exactly one of the inputs was negative, but we
2843 can't tell which one. There is an @kbd{f T} [@code{arctan2}] function which
2844 computes the inverse tangent of the quotient of a pair of numbers.
2845 Since you feed it the two original numbers, it has enough information
2846 to give you a full 360-degree answer.
2850 2: 0.89879 1: 116. 3: 116. 2: 116. 1: 180.
2851 1: -0.43837 . 2: -0.89879 1: -64. .
2855 U U f T M-@key{RET} M-2 n f T -
2860 The resulting angles differ by 180 degrees; in other words, they
2861 point in opposite directions, just as we would expect.
2863 The @key{META}-@key{RET} we used in the third step is the
2864 ``last-arguments'' command. It is sort of like Undo, except that it
2865 restores the arguments of the last command to the stack without removing
2866 the command's result. It is useful in situations like this one,
2867 where we need to do several operations on the same inputs. We could
2868 have accomplished the same thing by using @kbd{M-2 @key{RET}} to duplicate
2869 the top two stack elements right after the @kbd{U U}, then a pair of
2870 @kbd{M-@key{TAB}} commands to cycle the 116 up around the duplicates.
2872 A similar identity is supposed to hold for hyperbolic sines and cosines,
2873 except that it is the @emph{difference}
2874 @texline @math{\cosh^2x - \sinh^2x}
2875 @infoline @expr{cosh(x)^2 - sinh(x)^2}
2876 that always equals one. Let's try to verify this identity.
2880 2: -64 2: -64 2: -64 2: 9.7192e54 2: 9.7192e54
2881 1: -64 1: -3.1175e27 1: 9.7192e54 1: -64 1: 9.7192e54
2884 64 n @key{RET} @key{RET} H C 2 ^ @key{TAB} H S 2 ^
2889 @cindex Roundoff errors, examples
2890 Something's obviously wrong, because when we subtract these numbers
2891 the answer will clearly be zero! But if you think about it, if these
2892 numbers @emph{did} differ by one, it would be in the 55th decimal
2893 place. The difference we seek has been lost entirely to roundoff
2896 We could verify this hypothesis by doing the actual calculation with,
2897 say, 60 decimal places of precision. This will be slow, but not
2898 enormously so. Try it if you wish; sure enough, the answer is
2899 0.99999, reasonably close to 1.
2901 Of course, a more reasonable way to verify the identity is to use
2902 a more reasonable value for @expr{x}!
2904 @cindex Common logarithm
2905 Some Calculator commands use the Hyperbolic prefix for other purposes.
2906 The logarithm and exponential functions, for example, work to the base
2907 @expr{e} normally but use base-10 instead if you use the Hyperbolic
2912 1: 1000 1: 6.9077 1: 1000 1: 3
2920 First, we mistakenly compute a natural logarithm. Then we undo
2921 and compute a common logarithm instead.
2923 The @kbd{B} key computes a general base-@var{b} logarithm for any
2928 2: 1000 1: 3 1: 1000. 2: 1000. 1: 6.9077
2929 1: 10 . . 1: 2.71828 .
2932 1000 @key{RET} 10 B H E H P B
2937 Here we first use @kbd{B} to compute the base-10 logarithm, then use
2938 the ``hyperbolic'' exponential as a cheap hack to recover the number
2939 1000, then use @kbd{B} again to compute the natural logarithm. Note
2940 that @kbd{P} with the hyperbolic prefix pushes the constant @expr{e}
2943 You may have noticed that both times we took the base-10 logarithm
2944 of 1000, we got an exact integer result. Calc always tries to give
2945 an exact rational result for calculations involving rational numbers
2946 where possible. But when we used @kbd{H E}, the result was a
2947 floating-point number for no apparent reason. In fact, if we had
2948 computed @kbd{10 @key{RET} 3 ^} we @emph{would} have gotten an
2949 exact integer 1000. But the @kbd{H E} command is rigged to generate
2950 a floating-point result all of the time so that @kbd{1000 H E} will
2951 not waste time computing a thousand-digit integer when all you
2952 probably wanted was @samp{1e1000}.
2954 (@bullet{}) @strong{Exercise 2.} Find a pair of integer inputs to
2955 the @kbd{B} command for which Calc could find an exact rational
2956 result but doesn't. @xref{Arithmetic Answer 2, 2}. (@bullet{})
2958 The Calculator also has a set of functions relating to combinatorics
2959 and statistics. You may be familiar with the @dfn{factorial} function,
2960 which computes the product of all the integers up to a given number.
2964 1: 100 1: 93326215443... 1: 100. 1: 9.3326e157
2972 Recall, the @kbd{c f} command converts the integer or fraction at the
2973 top of the stack to floating-point format. If you take the factorial
2974 of a floating-point number, you get a floating-point result
2975 accurate to the current precision. But if you give @kbd{!} an
2976 exact integer, you get an exact integer result (158 digits long
2979 If you take the factorial of a non-integer, Calc uses a generalized
2980 factorial function defined in terms of Euler's Gamma function
2981 @texline @math{\Gamma(n)}
2982 @infoline @expr{gamma(n)}
2983 (which is itself available as the @kbd{f g} command).
2987 3: 4. 3: 24. 1: 5.5 1: 52.342777847
2988 2: 4.5 2: 52.3427777847 . .
2992 M-3 ! M-0 @key{DEL} 5.5 f g
2997 Here we verify the identity
2998 @texline @math{n! = \Gamma(n+1)}.
2999 @infoline @expr{@var{n}!@: = gamma(@var{n}+1)}.
3001 The binomial coefficient @var{n}-choose-@var{m}
3002 @texline or @math{\displaystyle {n \choose m}}
3004 @texline @math{\displaystyle {n! \over m! \, (n-m)!}}
3005 @infoline @expr{n!@: / m!@: (n-m)!}
3006 for all reals @expr{n} and @expr{m}. The intermediate results in this
3007 formula can become quite large even if the final result is small; the
3008 @kbd{k c} command computes a binomial coefficient in a way that avoids
3009 large intermediate values.
3011 The @kbd{k} prefix key defines several common functions out of
3012 combinatorics and number theory. Here we compute the binomial
3013 coefficient 30-choose-20, then determine its prime factorization.
3017 2: 30 1: 30045015 1: [3, 3, 5, 7, 11, 13, 23, 29]
3021 30 @key{RET} 20 k c k f
3026 You can verify these prime factors by using @kbd{V R *} to multiply
3027 together the elements of this vector. The result is the original
3031 Suppose a program you are writing needs a hash table with at least
3032 10000 entries. It's best to use a prime number as the actual size
3033 of a hash table. Calc can compute the next prime number after 10000:
3037 1: 10000 1: 10007 1: 9973
3045 Just for kicks we've also computed the next prime @emph{less} than
3048 @c [fix-ref Financial Functions]
3049 @xref{Financial Functions}, for a description of the Calculator
3050 commands that deal with business and financial calculations (functions
3051 like @code{pv}, @code{rate}, and @code{sln}).
3053 @c [fix-ref Binary Number Functions]
3054 @xref{Binary Functions}, to read about the commands for operating
3055 on binary numbers (like @code{and}, @code{xor}, and @code{lsh}).
3057 @node Vector/Matrix Tutorial, Types Tutorial, Arithmetic Tutorial, Tutorial
3058 @section Vector/Matrix Tutorial
3061 A @dfn{vector} is a list of numbers or other Calc data objects.
3062 Calc provides a large set of commands that operate on vectors. Some
3063 are familiar operations from vector analysis. Others simply treat
3064 a vector as a list of objects.
3067 * Vector Analysis Tutorial::
3072 @node Vector Analysis Tutorial, Matrix Tutorial, Vector/Matrix Tutorial, Vector/Matrix Tutorial
3073 @subsection Vector Analysis
3076 If you add two vectors, the result is a vector of the sums of the
3077 elements, taken pairwise.
3081 1: [1, 2, 3] 2: [1, 2, 3] 1: [8, 8, 3]
3085 [1,2,3] s 1 [7 6 0] s 2 +
3090 Note that we can separate the vector elements with either commas or
3091 spaces. This is true whether we are using incomplete vectors or
3092 algebraic entry. The @kbd{s 1} and @kbd{s 2} commands save these
3093 vectors so we can easily reuse them later.
3095 If you multiply two vectors, the result is the sum of the products
3096 of the elements taken pairwise. This is called the @dfn{dot product}
3110 The dot product of two vectors is equal to the product of their
3111 lengths times the cosine of the angle between them. (Here the vector
3112 is interpreted as a line from the origin @expr{(0,0,0)} to the
3113 specified point in three-dimensional space.) The @kbd{A}
3114 (absolute value) command can be used to compute the length of a
3119 3: 19 3: 19 1: 0.550782 1: 56.579
3120 2: [1, 2, 3] 2: 3.741657 . .
3121 1: [7, 6, 0] 1: 9.219544
3124 M-@key{RET} M-2 A * / I C
3129 First we recall the arguments to the dot product command, then
3130 we compute the absolute values of the top two stack entries to
3131 obtain the lengths of the vectors, then we divide the dot product
3132 by the product of the lengths to get the cosine of the angle.
3133 The inverse cosine finds that the angle between the vectors
3134 is about 56 degrees.
3136 @cindex Cross product
3137 @cindex Perpendicular vectors
3138 The @dfn{cross product} of two vectors is a vector whose length
3139 is the product of the lengths of the inputs times the sine of the
3140 angle between them, and whose direction is perpendicular to both
3141 input vectors. Unlike the dot product, the cross product is
3142 defined only for three-dimensional vectors. Let's double-check
3143 our computation of the angle using the cross product.
3147 2: [1, 2, 3] 3: [-18, 21, -8] 1: [-0.52, 0.61, -0.23] 1: 56.579
3148 1: [7, 6, 0] 2: [1, 2, 3] . .
3152 r 1 r 2 V C s 3 M-@key{RET} M-2 A * / A I S
3157 First we recall the original vectors and compute their cross product,
3158 which we also store for later reference. Now we divide the vector
3159 by the product of the lengths of the original vectors. The length of
3160 this vector should be the sine of the angle; sure enough, it is!
3162 @c [fix-ref General Mode Commands]
3163 Vector-related commands generally begin with the @kbd{v} prefix key.
3164 Some are uppercase letters and some are lowercase. To make it easier
3165 to type these commands, the shift-@kbd{V} prefix key acts the same as
3166 the @kbd{v} key. (@xref{General Mode Commands}, for a way to make all
3167 prefix keys have this property.)
3169 If we take the dot product of two perpendicular vectors we expect
3170 to get zero, since the cosine of 90 degrees is zero. Let's check
3171 that the cross product is indeed perpendicular to both inputs:
3175 2: [1, 2, 3] 1: 0 2: [7, 6, 0] 1: 0
3176 1: [-18, 21, -8] . 1: [-18, 21, -8] .
3179 r 1 r 3 * @key{DEL} r 2 r 3 *
3183 @cindex Normalizing a vector
3184 @cindex Unit vectors
3185 (@bullet{}) @strong{Exercise 1.} Given a vector on the top of the
3186 stack, what keystrokes would you use to @dfn{normalize} the
3187 vector, i.e., to reduce its length to one without changing its
3188 direction? @xref{Vector Answer 1, 1}. (@bullet{})
3190 (@bullet{}) @strong{Exercise 2.} Suppose a certain particle can be
3191 at any of several positions along a ruler. You have a list of
3192 those positions in the form of a vector, and another list of the
3193 probabilities for the particle to be at the corresponding positions.
3194 Find the average position of the particle.
3195 @xref{Vector Answer 2, 2}. (@bullet{})
3197 @node Matrix Tutorial, List Tutorial, Vector Analysis Tutorial, Vector/Matrix Tutorial
3198 @subsection Matrices
3201 A @dfn{matrix} is just a vector of vectors, all the same length.
3202 This means you can enter a matrix using nested brackets. You can
3203 also use the semicolon character to enter a matrix. We'll show
3208 1: [ [ 1, 2, 3 ] 1: [ [ 1, 2, 3 ]
3209 [ 4, 5, 6 ] ] [ 4, 5, 6 ] ]
3212 [[1 2 3] [4 5 6]] ' [1 2 3; 4 5 6] @key{RET}
3217 We'll be using this matrix again, so type @kbd{s 4} to save it now.
3219 Note that semicolons work with incomplete vectors, but they work
3220 better in algebraic entry. That's why we use the apostrophe in
3223 When two matrices are multiplied, the lefthand matrix must have
3224 the same number of columns as the righthand matrix has rows.
3225 Row @expr{i}, column @expr{j} of the result is effectively the
3226 dot product of row @expr{i} of the left matrix by column @expr{j}
3227 of the right matrix.
3229 If we try to duplicate this matrix and multiply it by itself,
3230 the dimensions are wrong and the multiplication cannot take place:
3234 1: [ [ 1, 2, 3 ] * [ [ 1, 2, 3 ]
3235 [ 4, 5, 6 ] ] [ 4, 5, 6 ] ]
3243 Though rather hard to read, this is a formula which shows the product
3244 of two matrices. The @samp{*} function, having invalid arguments, has
3245 been left in symbolic form.
3247 We can multiply the matrices if we @dfn{transpose} one of them first.
3251 2: [ [ 1, 2, 3 ] 1: [ [ 14, 32 ] 1: [ [ 17, 22, 27 ]
3252 [ 4, 5, 6 ] ] [ 32, 77 ] ] [ 22, 29, 36 ]
3253 1: [ [ 1, 4 ] . [ 27, 36, 45 ] ]
3258 U v t * U @key{TAB} *
3262 Matrix multiplication is not commutative; indeed, switching the
3263 order of the operands can even change the dimensions of the result
3264 matrix, as happened here!
3266 If you multiply a plain vector by a matrix, it is treated as a
3267 single row or column depending on which side of the matrix it is
3268 on. The result is a plain vector which should also be interpreted
3269 as a row or column as appropriate.
3273 2: [ [ 1, 2, 3 ] 1: [14, 32]
3282 Multiplying in the other order wouldn't work because the number of
3283 rows in the matrix is different from the number of elements in the
3286 (@bullet{}) @strong{Exercise 1.} Use @samp{*} to sum along the rows
3288 @texline @math{2\times3}
3290 matrix to get @expr{[6, 15]}. Now use @samp{*} to sum along the columns
3291 to get @expr{[5, 7, 9]}.
3292 @xref{Matrix Answer 1, 1}. (@bullet{})
3294 @cindex Identity matrix
3295 An @dfn{identity matrix} is a square matrix with ones along the
3296 diagonal and zeros elsewhere. It has the property that multiplication
3297 by an identity matrix, on the left or on the right, always produces
3298 the original matrix.
3302 1: [ [ 1, 2, 3 ] 2: [ [ 1, 2, 3 ] 1: [ [ 1, 2, 3 ]
3303 [ 4, 5, 6 ] ] [ 4, 5, 6 ] ] [ 4, 5, 6 ] ]
3304 . 1: [ [ 1, 0, 0 ] .
3309 r 4 v i 3 @key{RET} *
3313 If a matrix is square, it is often possible to find its @dfn{inverse},
3314 that is, a matrix which, when multiplied by the original matrix, yields
3315 an identity matrix. The @kbd{&} (reciprocal) key also computes the
3316 inverse of a matrix.
3320 1: [ [ 1, 2, 3 ] 1: [ [ -2.4, 1.2, -0.2 ]
3321 [ 4, 5, 6 ] [ 2.8, -1.4, 0.4 ]
3322 [ 7, 6, 0 ] ] [ -0.73333, 0.53333, -0.2 ] ]
3330 The vertical bar @kbd{|} @dfn{concatenates} numbers, vectors, and
3331 matrices together. Here we have used it to add a new row onto
3332 our matrix to make it square.
3334 We can multiply these two matrices in either order to get an identity.
3338 1: [ [ 1., 0., 0. ] 1: [ [ 1., 0., 0. ]
3339 [ 0., 1., 0. ] [ 0., 1., 0. ]
3340 [ 0., 0., 1. ] ] [ 0., 0., 1. ] ]
3343 M-@key{RET} * U @key{TAB} *
3347 @cindex Systems of linear equations
3348 @cindex Linear equations, systems of
3349 Matrix inverses are related to systems of linear equations in algebra.
3350 Suppose we had the following set of equations:
3363 $$ \openup1\jot \tabskip=0pt plus1fil
3364 \halign to\displaywidth{\tabskip=0pt
3365 $\hfil#$&$\hfil{}#{}$&
3366 $\hfil#$&$\hfil{}#{}$&
3367 $\hfil#$&${}#\hfil$\tabskip=0pt plus1fil\cr
3376 This can be cast into the matrix equation,
3381 [ [ 1, 2, 3 ] [ [ a ] [ [ 6 ]
3382 [ 4, 5, 6 ] * [ b ] = [ 2 ]
3383 [ 7, 6, 0 ] ] [ c ] ] [ 3 ] ]
3389 $$ \pmatrix{ 1 & 2 & 3 \cr 4 & 5 & 6 \cr 7 & 6 & 0 }
3391 \pmatrix{ a \cr b \cr c } = \pmatrix{ 6 \cr 2 \cr 3 }
3396 We can solve this system of equations by multiplying both sides by the
3397 inverse of the matrix. Calc can do this all in one step:
3401 2: [6, 2, 3] 1: [-12.6, 15.2, -3.93333]
3412 The result is the @expr{[a, b, c]} vector that solves the equations.
3413 (Dividing by a square matrix is equivalent to multiplying by its
3416 Let's verify this solution:
3420 2: [ [ 1, 2, 3 ] 1: [6., 2., 3.]
3423 1: [-12.6, 15.2, -3.93333]
3431 Note that we had to be careful about the order in which we multiplied
3432 the matrix and vector. If we multiplied in the other order, Calc would
3433 assume the vector was a row vector in order to make the dimensions
3434 come out right, and the answer would be incorrect. If you
3435 don't feel safe letting Calc take either interpretation of your
3436 vectors, use explicit
3437 @texline @math{N\times1}
3440 @texline @math{1\times N}
3442 matrices instead. In this case, you would enter the original column
3443 vector as @samp{[[6], [2], [3]]} or @samp{[6; 2; 3]}.
3445 (@bullet{}) @strong{Exercise 2.} Algebraic entry allows you to make
3446 vectors and matrices that include variables. Solve the following
3447 system of equations to get expressions for @expr{x} and @expr{y}
3448 in terms of @expr{a} and @expr{b}.
3460 $$ \eqalign{ x &+ a y = 6 \cr
3467 @xref{Matrix Answer 2, 2}. (@bullet{})
3469 @cindex Least-squares for over-determined systems
3470 @cindex Over-determined systems of equations
3471 (@bullet{}) @strong{Exercise 3.} A system of equations is ``over-determined''
3472 if it has more equations than variables. It is often the case that
3473 there are no values for the variables that will satisfy all the
3474 equations at once, but it is still useful to find a set of values
3475 which ``nearly'' satisfy all the equations. In terms of matrix equations,
3476 you can't solve @expr{A X = B} directly because the matrix @expr{A}
3477 is not square for an over-determined system. Matrix inversion works
3478 only for square matrices. One common trick is to multiply both sides
3479 on the left by the transpose of @expr{A}:
3481 @samp{trn(A)*A*X = trn(A)*B}.
3484 $A^T A \, X = A^T B$, where $A^T$ is the transpose \samp{trn(A)}.
3487 @texline @math{A^T A}
3488 @infoline @expr{trn(A)*A}
3489 is a square matrix so a solution is possible. It turns out that the
3490 @expr{X} vector you compute in this way will be a ``least-squares''
3491 solution, which can be regarded as the ``closest'' solution to the set
3492 of equations. Use Calc to solve the following over-determined
3507 $$ \openup1\jot \tabskip=0pt plus1fil
3508 \halign to\displaywidth{\tabskip=0pt
3509 $\hfil#$&$\hfil{}#{}$&
3510 $\hfil#$&$\hfil{}#{}$&
3511 $\hfil#$&${}#\hfil$\tabskip=0pt plus1fil\cr
3515 2a&+&4b&+&6c&=11 \cr}
3521 @xref{Matrix Answer 3, 3}. (@bullet{})
3523 @node List Tutorial, , Matrix Tutorial, Vector/Matrix Tutorial
3524 @subsection Vectors as Lists
3528 Although Calc has a number of features for manipulating vectors and
3529 matrices as mathematical objects, you can also treat vectors as
3530 simple lists of values. For example, we saw that the @kbd{k f}
3531 command returns a vector which is a list of the prime factors of a
3534 You can pack and unpack stack entries into vectors:
3538 3: 10 1: [10, 20, 30] 3: 10
3547 You can also build vectors out of consecutive integers, or out
3548 of many copies of a given value:
3552 1: [1, 2, 3, 4] 2: [1, 2, 3, 4] 2: [1, 2, 3, 4]
3553 . 1: 17 1: [17, 17, 17, 17]
3556 v x 4 @key{RET} 17 v b 4 @key{RET}
3560 You can apply an operator to every element of a vector using the
3565 1: [17, 34, 51, 68] 1: [289, 1156, 2601, 4624] 1: [17, 34, 51, 68]
3573 In the first step, we multiply the vector of integers by the vector
3574 of 17's elementwise. In the second step, we raise each element to
3575 the power two. (The general rule is that both operands must be
3576 vectors of the same length, or else one must be a vector and the
3577 other a plain number.) In the final step, we take the square root
3580 (@bullet{}) @strong{Exercise 1.} Compute a vector of powers of two
3582 @texline @math{2^{-4}}
3583 @infoline @expr{2^-4}
3584 to @expr{2^4}. @xref{List Answer 1, 1}. (@bullet{})
3586 You can also @dfn{reduce} a binary operator across a vector.
3587 For example, reducing @samp{*} computes the product of all the
3588 elements in the vector:
3592 1: 123123 1: [3, 7, 11, 13, 41] 1: 123123
3600 In this example, we decompose 123123 into its prime factors, then
3601 multiply those factors together again to yield the original number.
3603 We could compute a dot product ``by hand'' using mapping and
3608 2: [1, 2, 3] 1: [7, 12, 0] 1: 19
3617 Recalling two vectors from the previous section, we compute the
3618 sum of pairwise products of the elements to get the same answer
3619 for the dot product as before.
3621 A slight variant of vector reduction is the @dfn{accumulate} operation,
3622 @kbd{V U}. This produces a vector of the intermediate results from
3623 a corresponding reduction. Here we compute a table of factorials:
3627 1: [1, 2, 3, 4, 5, 6] 1: [1, 2, 6, 24, 120, 720]
3630 v x 6 @key{RET} V U *
3634 Calc allows vectors to grow as large as you like, although it gets
3635 rather slow if vectors have more than about a hundred elements.
3636 Actually, most of the time is spent formatting these large vectors
3637 for display, not calculating on them. Try the following experiment
3638 (if your computer is very fast you may need to substitute a larger
3643 1: [1, 2, 3, 4, ... 1: [2, 3, 4, 5, ...
3646 v x 500 @key{RET} 1 V M +
3650 Now press @kbd{v .} (the letter @kbd{v}, then a period) and try the
3651 experiment again. In @kbd{v .} mode, long vectors are displayed
3652 ``abbreviated'' like this:
3656 1: [1, 2, 3, ..., 500] 1: [2, 3, 4, ..., 501]
3659 v x 500 @key{RET} 1 V M +
3664 (where now the @samp{...} is actually part of the Calc display).
3665 You will find both operations are now much faster. But notice that
3666 even in @w{@kbd{v .}} mode, the full vectors are still shown in the Trail.
3667 Type @w{@kbd{t .}} to cause the trail to abbreviate as well, and try the
3668 experiment one more time. Operations on long vectors are now quite
3669 fast! (But of course if you use @kbd{t .} you will lose the ability
3670 to get old vectors back using the @kbd{t y} command.)
3672 An easy way to view a full vector when @kbd{v .} mode is active is
3673 to press @kbd{`} (back-quote) to edit the vector; editing always works
3674 with the full, unabbreviated value.
3676 @cindex Least-squares for fitting a straight line
3677 @cindex Fitting data to a line
3678 @cindex Line, fitting data to
3679 @cindex Data, extracting from buffers
3680 @cindex Columns of data, extracting
3681 As a larger example, let's try to fit a straight line to some data,
3682 using the method of least squares. (Calc has a built-in command for
3683 least-squares curve fitting, but we'll do it by hand here just to
3684 practice working with vectors.) Suppose we have the following list
3685 of values in a file we have loaded into Emacs:
3712 If you are reading this tutorial in printed form, you will find it
3713 easiest to press @kbd{C-x * i} to enter the on-line Info version of
3714 the manual and find this table there. (Press @kbd{g}, then type
3715 @kbd{List Tutorial}, to jump straight to this section.)
3717 Position the cursor at the upper-left corner of this table, just
3718 to the left of the @expr{1.34}. Press @kbd{C-@@} to set the mark.
3719 (On your system this may be @kbd{C-2}, @kbd{C-@key{SPC}}, or @kbd{NUL}.)
3720 Now position the cursor to the lower-right, just after the @expr{1.354}.
3721 You have now defined this region as an Emacs ``rectangle.'' Still
3722 in the Info buffer, type @kbd{C-x * r}. This command
3723 (@code{calc-grab-rectangle}) will pop you back into the Calculator, with
3724 the contents of the rectangle you specified in the form of a matrix.
3728 1: [ [ 1.34, 0.234 ]
3735 (You may wish to use @kbd{v .} mode to abbreviate the display of this
3738 We want to treat this as a pair of lists. The first step is to
3739 transpose this matrix into a pair of rows. Remember, a matrix is
3740 just a vector of vectors. So we can unpack the matrix into a pair
3741 of row vectors on the stack.
3745 1: [ [ 1.34, 1.41, 1.49, ... ] 2: [1.34, 1.41, 1.49, ... ]
3746 [ 0.234, 0.298, 0.402, ... ] ] 1: [0.234, 0.298, 0.402, ... ]
3754 Let's store these in quick variables 1 and 2, respectively.
3758 1: [1.34, 1.41, 1.49, ... ] .
3766 (Recall that @kbd{t 2} is a variant of @kbd{s 2} that removes the
3767 stored value from the stack.)
3769 In a least squares fit, the slope @expr{m} is given by the formula
3773 m = (N sum(x y) - sum(x) sum(y)) / (N sum(x^2) - sum(x)^2)
3778 $$ m = {N \sum x y - \sum x \sum y \over
3779 N \sum x^2 - \left( \sum x \right)^2} $$
3785 @texline @math{\sum x}
3786 @infoline @expr{sum(x)}
3787 represents the sum of all the values of @expr{x}. While there is an
3788 actual @code{sum} function in Calc, it's easier to sum a vector using a
3789 simple reduction. First, let's compute the four different sums that
3797 r 1 V R + t 3 r 1 2 V M ^ V R + t 4
3804 1: 13.613 1: 33.36554
3807 r 2 V R + t 5 r 1 r 2 V M * V R + t 6
3813 These are @samp{sum(x)}, @samp{sum(x^2)}, @samp{sum(y)}, and @samp{sum(x y)},
3814 respectively. (We could have used @kbd{*} to compute @samp{sum(x^2)} and
3818 These are $\sum x$, $\sum x^2$, $\sum y$, and $\sum x y$,
3819 respectively. (We could have used \kbd{*} to compute $\sum x^2$ and
3823 Finally, we also need @expr{N}, the number of data points. This is just
3824 the length of either of our lists.
3836 (That's @kbd{v} followed by a lower-case @kbd{l}.)
3838 Now we grind through the formula:
3842 1: 633.94526 2: 633.94526 1: 67.23607
3846 r 7 r 6 * r 3 r 5 * -
3853 2: 67.23607 3: 67.23607 2: 67.23607 1: 0.52141679
3854 1: 1862.0057 2: 1862.0057 1: 128.9488 .
3858 r 7 r 4 * r 3 2 ^ - / t 8
3862 That gives us the slope @expr{m}. The y-intercept @expr{b} can now
3863 be found with the simple formula,
3867 b = (sum(y) - m sum(x)) / N
3872 $$ b = {\sum y - m \sum x \over N} $$
3879 1: 13.613 2: 13.613 1: -8.09358 1: -0.425978
3883 r 5 r 8 r 3 * - r 7 / t 9
3887 Let's ``plot'' this straight line approximation,
3888 @texline @math{y \approx m x + b},
3889 @infoline @expr{m x + b},
3890 and compare it with the original data.
3894 1: [0.699, 0.735, ... ] 1: [0.273, 0.309, ... ]
3902 Notice that multiplying a vector by a constant, and adding a constant
3903 to a vector, can be done without mapping commands since these are
3904 common operations from vector algebra. As far as Calc is concerned,
3905 we've just been doing geometry in 19-dimensional space!
3907 We can subtract this vector from our original @expr{y} vector to get
3908 a feel for the error of our fit. Let's find the maximum error:
3912 1: [0.0387, 0.0112, ... ] 1: [0.0387, 0.0112, ... ] 1: 0.0897
3920 First we compute a vector of differences, then we take the absolute
3921 values of these differences, then we reduce the @code{max} function
3922 across the vector. (The @code{max} function is on the two-key sequence
3923 @kbd{f x}; because it is so common to use @code{max} in a vector
3924 operation, the letters @kbd{X} and @kbd{N} are also accepted for
3925 @code{max} and @code{min} in this context. In general, you answer
3926 the @kbd{V M} or @kbd{V R} prompt with the actual key sequence that
3927 invokes the function you want. You could have typed @kbd{V R f x} or
3928 even @kbd{V R x max @key{RET}} if you had preferred.)
3930 If your system has the GNUPLOT program, you can see graphs of your
3931 data and your straight line to see how well they match. (If you have
3932 GNUPLOT 3.0 or higher, the following instructions will work regardless
3933 of the kind of display you have. Some GNUPLOT 2.0, non-X-windows systems
3934 may require additional steps to view the graphs.)
3936 Let's start by plotting the original data. Recall the ``@var{x}'' and ``@var{y}''
3937 vectors onto the stack and press @kbd{g f}. This ``fast'' graphing
3938 command does everything you need to do for simple, straightforward
3943 2: [1.34, 1.41, 1.49, ... ]
3944 1: [0.234, 0.298, 0.402, ... ]
3951 If all goes well, you will shortly get a new window containing a graph
3952 of the data. (If not, contact your GNUPLOT or Calc installer to find
3953 out what went wrong.) In the X window system, this will be a separate
3954 graphics window. For other kinds of displays, the default is to
3955 display the graph in Emacs itself using rough character graphics.
3956 Press @kbd{q} when you are done viewing the character graphics.
3958 Next, let's add the line we got from our least-squares fit.
3960 (If you are reading this tutorial on-line while running Calc, typing
3961 @kbd{g a} may cause the tutorial to disappear from its window and be
3962 replaced by a buffer named @samp{*Gnuplot Commands*}. The tutorial
3963 will reappear when you terminate GNUPLOT by typing @kbd{g q}.)
3968 2: [1.34, 1.41, 1.49, ... ]
3969 1: [0.273, 0.309, 0.351, ... ]
3972 @key{DEL} r 0 g a g p
3976 It's not very useful to get symbols to mark the data points on this
3977 second curve; you can type @kbd{g S g p} to remove them. Type @kbd{g q}
3978 when you are done to remove the X graphics window and terminate GNUPLOT.
3980 (@bullet{}) @strong{Exercise 2.} An earlier exercise showed how to do
3981 least squares fitting to a general system of equations. Our 19 data
3982 points are really 19 equations of the form @expr{y_i = m x_i + b} for
3983 different pairs of @expr{(x_i,y_i)}. Use the matrix-transpose method
3984 to solve for @expr{m} and @expr{b}, duplicating the above result.
3985 @xref{List Answer 2, 2}. (@bullet{})
3987 @cindex Geometric mean
3988 (@bullet{}) @strong{Exercise 3.} If the input data do not form a
3989 rectangle, you can use @w{@kbd{C-x * g}} (@code{calc-grab-region})
3990 to grab the data the way Emacs normally works with regions---it reads
3991 left-to-right, top-to-bottom, treating line breaks the same as spaces.
3992 Use this command to find the geometric mean of the following numbers.
3993 (The geometric mean is the @var{n}th root of the product of @var{n} numbers.)
4002 The @kbd{C-x * g} command accepts numbers separated by spaces or commas,
4003 with or without surrounding vector brackets.
4004 @xref{List Answer 3, 3}. (@bullet{})
4007 As another example, a theorem about binomial coefficients tells
4008 us that the alternating sum of binomial coefficients
4009 @var{n}-choose-0 minus @var{n}-choose-1 plus @var{n}-choose-2, and so
4010 on up to @var{n}-choose-@var{n},
4011 always comes out to zero. Let's verify this
4015 As another example, a theorem about binomial coefficients tells
4016 us that the alternating sum of binomial coefficients
4017 ${n \choose 0} - {n \choose 1} + {n \choose 2} - \cdots \pm {n \choose n}$
4018 always comes out to zero. Let's verify this
4024 1: [1, 2, 3, 4, 5, 6, 7] 1: [0, 1, 2, 3, 4, 5, 6]
4034 1: [1, -6, 15, -20, 15, -6, 1] 1: 0
4037 V M ' (-1)^$ choose(6,$) @key{RET} V R +
4041 The @kbd{V M '} command prompts you to enter any algebraic expression
4042 to define the function to map over the vector. The symbol @samp{$}
4043 inside this expression represents the argument to the function.
4044 The Calculator applies this formula to each element of the vector,
4045 substituting each element's value for the @samp{$} sign(s) in turn.
4047 To define a two-argument function, use @samp{$$} for the first
4048 argument and @samp{$} for the second: @kbd{V M ' $$-$ @key{RET}} is
4049 equivalent to @kbd{V M -}. This is analogous to regular algebraic
4050 entry, where @samp{$$} would refer to the next-to-top stack entry
4051 and @samp{$} would refer to the top stack entry, and @kbd{' $$-$ @key{RET}}
4052 would act exactly like @kbd{-}.
4054 Notice that the @kbd{V M '} command has recorded two things in the
4055 trail: The result, as usual, and also a funny-looking thing marked
4056 @samp{oper} that represents the operator function you typed in.
4057 The function is enclosed in @samp{< >} brackets, and the argument is
4058 denoted by a @samp{#} sign. If there were several arguments, they
4059 would be shown as @samp{#1}, @samp{#2}, and so on. (For example,
4060 @kbd{V M ' $$-$} will put the function @samp{<#1 - #2>} on the
4061 trail.) This object is a ``nameless function''; you can use nameless
4062 @w{@samp{< >}} notation to answer the @kbd{V M '} prompt if you like.
4063 Nameless function notation has the interesting, occasionally useful
4064 property that a nameless function is not actually evaluated until
4065 it is used. For example, @kbd{V M ' $+random(2.0)} evaluates
4066 @samp{random(2.0)} once and adds that random number to all elements
4067 of the vector, but @kbd{V M ' <#+random(2.0)>} evaluates the
4068 @samp{random(2.0)} separately for each vector element.
4070 Another group of operators that are often useful with @kbd{V M} are
4071 the relational operators: @kbd{a =}, for example, compares two numbers
4072 and gives the result 1 if they are equal, or 0 if not. Similarly,
4073 @w{@kbd{a <}} checks for one number being less than another.
4075 Other useful vector operations include @kbd{v v}, to reverse a
4076 vector end-for-end; @kbd{V S}, to sort the elements of a vector
4077 into increasing order; and @kbd{v r} and @w{@kbd{v c}}, to extract
4078 one row or column of a matrix, or (in both cases) to extract one
4079 element of a plain vector. With a negative argument, @kbd{v r}
4080 and @kbd{v c} instead delete one row, column, or vector element.
4082 @cindex Divisor functions
4083 (@bullet{}) @strong{Exercise 4.} The @expr{k}th @dfn{divisor function}
4087 is the sum of the @expr{k}th powers of all the divisors of an
4088 integer @expr{n}. Figure out a method for computing the divisor
4089 function for reasonably small values of @expr{n}. As a test,
4090 the 0th and 1st divisor functions of 30 are 8 and 72, respectively.
4091 @xref{List Answer 4, 4}. (@bullet{})
4093 @cindex Square-free numbers
4094 @cindex Duplicate values in a list
4095 (@bullet{}) @strong{Exercise 5.} The @kbd{k f} command produces a
4096 list of prime factors for a number. Sometimes it is important to
4097 know that a number is @dfn{square-free}, i.e., that no prime occurs
4098 more than once in its list of prime factors. Find a sequence of
4099 keystrokes to tell if a number is square-free; your method should
4100 leave 1 on the stack if it is, or 0 if it isn't.
4101 @xref{List Answer 5, 5}. (@bullet{})
4103 @cindex Triangular lists
4104 (@bullet{}) @strong{Exercise 6.} Build a list of lists that looks
4105 like the following diagram. (You may wish to use the @kbd{v /}
4106 command to enable multi-line display of vectors.)
4115 [1, 2, 3, 4, 5, 6] ]
4120 @xref{List Answer 6, 6}. (@bullet{})
4122 (@bullet{}) @strong{Exercise 7.} Build the following list of lists.
4130 [10, 11, 12, 13, 14],
4131 [15, 16, 17, 18, 19, 20] ]
4136 @xref{List Answer 7, 7}. (@bullet{})
4138 @cindex Maximizing a function over a list of values
4139 @c [fix-ref Numerical Solutions]
4140 (@bullet{}) @strong{Exercise 8.} Compute a list of values of Bessel's
4141 @texline @math{J_1(x)}
4143 function @samp{besJ(1,x)} for @expr{x} from 0 to 5 in steps of 0.25.
4144 Find the value of @expr{x} (from among the above set of values) for
4145 which @samp{besJ(1,x)} is a maximum. Use an ``automatic'' method,
4146 i.e., just reading along the list by hand to find the largest value
4147 is not allowed! (There is an @kbd{a X} command which does this kind
4148 of thing automatically; @pxref{Numerical Solutions}.)
4149 @xref{List Answer 8, 8}. (@bullet{})
4151 @cindex Digits, vectors of
4152 (@bullet{}) @strong{Exercise 9.} You are given an integer in the range
4153 @texline @math{0 \le N < 10^m}
4154 @infoline @expr{0 <= N < 10^m}
4155 for @expr{m=12} (i.e., an integer of less than
4156 twelve digits). Convert this integer into a vector of @expr{m}
4157 digits, each in the range from 0 to 9. In vector-of-digits notation,
4158 add one to this integer to produce a vector of @expr{m+1} digits
4159 (since there could be a carry out of the most significant digit).
4160 Convert this vector back into a regular integer. A good integer
4161 to try is 25129925999. @xref{List Answer 9, 9}. (@bullet{})
4163 (@bullet{}) @strong{Exercise 10.} Your friend Joe tried to use
4164 @kbd{V R a =} to test if all numbers in a list were equal. What
4165 happened? How would you do this test? @xref{List Answer 10, 10}. (@bullet{})
4167 (@bullet{}) @strong{Exercise 11.} The area of a circle of radius one
4168 is @cpi{}. The area of the
4169 @texline @math{2\times2}
4171 square that encloses that circle is 4. So if we throw @var{n} darts at
4172 random points in the square, about @cpiover{4} of them will land inside
4173 the circle. This gives us an entertaining way to estimate the value of
4174 @cpi{}. The @w{@kbd{k r}}
4175 command picks a random number between zero and the value on the stack.
4176 We could get a random floating-point number between @mathit{-1} and 1 by typing
4177 @w{@kbd{2.0 k r 1 -}}. Build a vector of 100 random @expr{(x,y)} points in
4178 this square, then use vector mapping and reduction to count how many
4179 points lie inside the unit circle. Hint: Use the @kbd{v b} command.
4180 @xref{List Answer 11, 11}. (@bullet{})
4182 @cindex Matchstick problem
4183 (@bullet{}) @strong{Exercise 12.} The @dfn{matchstick problem} provides
4184 another way to calculate @cpi{}. Say you have an infinite field
4185 of vertical lines with a spacing of one inch. Toss a one-inch matchstick
4186 onto the field. The probability that the matchstick will land crossing
4187 a line turns out to be
4188 @texline @math{2/\pi}.
4189 @infoline @expr{2/pi}.
4190 Toss 100 matchsticks to estimate @cpi{}. (If you want still more fun,
4191 the probability that the GCD (@w{@kbd{k g}}) of two large integers is
4193 @texline @math{6/\pi^2}.
4194 @infoline @expr{6/pi^2}.
4195 That provides yet another way to estimate @cpi{}.)
4196 @xref{List Answer 12, 12}. (@bullet{})
4198 (@bullet{}) @strong{Exercise 13.} An algebraic entry of a string in
4199 double-quote marks, @samp{"hello"}, creates a vector of the numerical
4200 (ASCII) codes of the characters (here, @expr{[104, 101, 108, 108, 111]}).
4201 Sometimes it is convenient to compute a @dfn{hash code} of a string,
4202 which is just an integer that represents the value of that string.
4203 Two equal strings have the same hash code; two different strings
4204 @dfn{probably} have different hash codes. (For example, Calc has
4205 over 400 function names, but Emacs can quickly find the definition for
4206 any given name because it has sorted the functions into ``buckets'' by
4207 their hash codes. Sometimes a few names will hash into the same bucket,
4208 but it is easier to search among a few names than among all the names.)
4209 One popular hash function is computed as follows: First set @expr{h = 0}.
4210 Then, for each character from the string in turn, set @expr{h = 3h + c_i}
4211 where @expr{c_i} is the character's ASCII code. If we have 511 buckets,
4212 we then take the hash code modulo 511 to get the bucket number. Develop a
4213 simple command or commands for converting string vectors into hash codes.
4214 The hash code for @samp{"Testing, 1, 2, 3"} is 1960915098, which modulo
4215 511 is 121. @xref{List Answer 13, 13}. (@bullet{})
4217 (@bullet{}) @strong{Exercise 14.} The @kbd{H V R} and @kbd{H V U}
4218 commands do nested function evaluations. @kbd{H V U} takes a starting
4219 value and a number of steps @var{n} from the stack; it then applies the
4220 function you give to the starting value 0, 1, 2, up to @var{n} times
4221 and returns a vector of the results. Use this command to create a
4222 ``random walk'' of 50 steps. Start with the two-dimensional point
4223 @expr{(0,0)}; then take one step a random distance between @mathit{-1} and 1
4224 in both @expr{x} and @expr{y}; then take another step, and so on. Use the
4225 @kbd{g f} command to display this random walk. Now modify your random
4226 walk to walk a unit distance, but in a random direction, at each step.
4227 (Hint: The @code{sincos} function returns a vector of the cosine and
4228 sine of an angle.) @xref{List Answer 14, 14}. (@bullet{})
4230 @node Types Tutorial, Algebra Tutorial, Vector/Matrix Tutorial, Tutorial
4231 @section Types Tutorial
4234 Calc understands a variety of data types as well as simple numbers.
4235 In this section, we'll experiment with each of these types in turn.
4237 The numbers we've been using so far have mainly been either @dfn{integers}
4238 or @dfn{floats}. We saw that floats are usually a good approximation to
4239 the mathematical concept of real numbers, but they are only approximations
4240 and are susceptible to roundoff error. Calc also supports @dfn{fractions},
4241 which can exactly represent any rational number.
4245 1: 3628800 2: 3628800 1: 518400:7 1: 518414:7 1: 7:518414
4249 10 ! 49 @key{RET} : 2 + &
4254 The @kbd{:} command divides two integers to get a fraction; @kbd{/}
4255 would normally divide integers to get a floating-point result.
4256 Notice we had to type @key{RET} between the @kbd{49} and the @kbd{:}
4257 since the @kbd{:} would otherwise be interpreted as part of a
4258 fraction beginning with 49.
4260 You can convert between floating-point and fractional format using
4261 @kbd{c f} and @kbd{c F}:
4265 1: 1.35027217629e-5 1: 7:518414
4272 The @kbd{c F} command replaces a floating-point number with the
4273 ``simplest'' fraction whose floating-point representation is the
4274 same, to within the current precision.
4278 1: 3.14159265359 1: 1146408:364913 1: 3.1416 1: 355:113
4281 P c F @key{DEL} p 5 @key{RET} P c F
4285 (@bullet{}) @strong{Exercise 1.} A calculation has produced the
4286 result 1.26508260337. You suspect it is the square root of the
4287 product of @cpi{} and some rational number. Is it? (Be sure
4288 to allow for roundoff error!) @xref{Types Answer 1, 1}. (@bullet{})
4290 @dfn{Complex numbers} can be stored in both rectangular and polar form.
4294 1: -9 1: (0, 3) 1: (3; 90.) 1: (6; 90.) 1: (2.4495; 45.)
4302 The square root of @mathit{-9} is by default rendered in rectangular form
4303 (@w{@expr{0 + 3i}}), but we can convert it to polar form (3 with a
4304 phase angle of 90 degrees). All the usual arithmetic and scientific
4305 operations are defined on both types of complex numbers.
4307 Another generalized kind of number is @dfn{infinity}. Infinity
4308 isn't really a number, but it can sometimes be treated like one.
4309 Calc uses the symbol @code{inf} to represent positive infinity,
4310 i.e., a value greater than any real number. Naturally, you can
4311 also write @samp{-inf} for minus infinity, a value less than any
4312 real number. The word @code{inf} can only be input using
4317 2: inf 2: -inf 2: -inf 2: -inf 1: nan
4318 1: -17 1: -inf 1: -inf 1: inf .
4321 ' inf @key{RET} 17 n * @key{RET} 72 + A +
4326 Since infinity is infinitely large, multiplying it by any finite
4327 number (like @mathit{-17}) has no effect, except that since @mathit{-17}
4328 is negative, it changes a plus infinity to a minus infinity.
4329 (``A huge positive number, multiplied by @mathit{-17}, yields a huge
4330 negative number.'') Adding any finite number to infinity also
4331 leaves it unchanged. Taking an absolute value gives us plus
4332 infinity again. Finally, we add this plus infinity to the minus
4333 infinity we had earlier. If you work it out, you might expect
4334 the answer to be @mathit{-72} for this. But the 72 has been completely
4335 lost next to the infinities; by the time we compute @w{@samp{inf - inf}}
4336 the finite difference between them, if any, is undetectable.
4337 So we say the result is @dfn{indeterminate}, which Calc writes
4338 with the symbol @code{nan} (for Not A Number).
4340 Dividing by zero is normally treated as an error, but you can get
4341 Calc to write an answer in terms of infinity by pressing @kbd{m i}
4342 to turn on Infinite mode.
4346 3: nan 2: nan 2: nan 2: nan 1: nan
4347 2: 1 1: 1 / 0 1: uinf 1: uinf .
4351 1 @key{RET} 0 / m i U / 17 n * +
4356 Dividing by zero normally is left unevaluated, but after @kbd{m i}
4357 it instead gives an infinite result. The answer is actually
4358 @code{uinf}, ``undirected infinity.'' If you look at a graph of
4359 @expr{1 / x} around @w{@expr{x = 0}}, you'll see that it goes toward
4360 plus infinity as you approach zero from above, but toward minus
4361 infinity as you approach from below. Since we said only @expr{1 / 0},
4362 Calc knows that the answer is infinite but not in which direction.
4363 That's what @code{uinf} means. Notice that multiplying @code{uinf}
4364 by a negative number still leaves plain @code{uinf}; there's no
4365 point in saying @samp{-uinf} because the sign of @code{uinf} is
4366 unknown anyway. Finally, we add @code{uinf} to our @code{nan},
4367 yielding @code{nan} again. It's easy to see that, because
4368 @code{nan} means ``totally unknown'' while @code{uinf} means
4369 ``unknown sign but known to be infinite,'' the more mysterious
4370 @code{nan} wins out when it is combined with @code{uinf}, or, for
4371 that matter, with anything else.
4373 (@bullet{}) @strong{Exercise 2.} Predict what Calc will answer
4374 for each of these formulas: @samp{inf / inf}, @samp{exp(inf)},
4375 @samp{exp(-inf)}, @samp{sqrt(-inf)}, @samp{sqrt(uinf)},
4376 @samp{abs(uinf)}, @samp{ln(0)}.
4377 @xref{Types Answer 2, 2}. (@bullet{})
4379 (@bullet{}) @strong{Exercise 3.} We saw that @samp{inf - inf = nan},
4380 which stands for an unknown value. Can @code{nan} stand for
4381 a complex number? Can it stand for infinity?
4382 @xref{Types Answer 3, 3}. (@bullet{})
4384 @dfn{HMS forms} represent a value in terms of hours, minutes, and
4389 1: 2@@ 30' 0" 1: 3@@ 30' 0" 2: 3@@ 30' 0" 1: 2.
4390 . . 1: 1@@ 45' 0." .
4393 2@@ 30' @key{RET} 1 + @key{RET} 2 / /
4397 HMS forms can also be used to hold angles in degrees, minutes, and
4402 1: 0.5 1: 26.56505 1: 26@@ 33' 54.18" 1: 0.44721
4410 First we convert the inverse tangent of 0.5 to degrees-minutes-seconds
4411 form, then we take the sine of that angle. Note that the trigonometric
4412 functions will accept HMS forms directly as input.
4415 (@bullet{}) @strong{Exercise 4.} The Beatles' @emph{Abbey Road} is
4416 47 minutes and 26 seconds long, and contains 17 songs. What is the
4417 average length of a song on @emph{Abbey Road}? If the Extended Disco
4418 Version of @emph{Abbey Road} added 20 seconds to the length of each
4419 song, how long would the album be? @xref{Types Answer 4, 4}. (@bullet{})
4421 A @dfn{date form} represents a date, or a date and time. Dates must
4422 be entered using algebraic entry. Date forms are surrounded by
4423 @samp{< >} symbols; most standard formats for dates are recognized.
4427 2: <Sun Jan 13, 1991> 1: 2.25
4428 1: <6:00pm Thu Jan 10, 1991> .
4431 ' <13 Jan 1991>, <1/10/91, 6pm> @key{RET} -
4436 In this example, we enter two dates, then subtract to find the
4437 number of days between them. It is also possible to add an
4438 HMS form or a number (of days) to a date form to get another
4443 1: <4:45:59pm Mon Jan 14, 1991> 1: <2:50:59am Thu Jan 17, 1991>
4450 @c [fix-ref Date Arithmetic]
4452 The @kbd{t N} (``now'') command pushes the current date and time on the
4453 stack; then we add two days, ten hours and five minutes to the date and
4454 time. Other date-and-time related commands include @kbd{t J}, which
4455 does Julian day conversions, @kbd{t W}, which finds the beginning of
4456 the week in which a date form lies, and @kbd{t I}, which increments a
4457 date by one or several months. @xref{Date Arithmetic}, for more.
4459 (@bullet{}) @strong{Exercise 5.} How many days until the next
4460 Friday the 13th? @xref{Types Answer 5, 5}. (@bullet{})
4462 (@bullet{}) @strong{Exercise 6.} How many leap years will there be
4463 between now and the year 10001 A.D.? @xref{Types Answer 6, 6}. (@bullet{})
4465 @cindex Slope and angle of a line
4466 @cindex Angle and slope of a line
4467 An @dfn{error form} represents a mean value with an attached standard
4468 deviation, or error estimate. Suppose our measurements indicate that
4469 a certain telephone pole is about 30 meters away, with an estimated
4470 error of 1 meter, and 8 meters tall, with an estimated error of 0.2
4471 meters. What is the slope of a line from here to the top of the
4472 pole, and what is the equivalent angle in degrees?
4476 1: 8 +/- 0.2 2: 8 +/- 0.2 1: 0.266 +/- 0.011 1: 14.93 +/- 0.594
4480 8 p .2 @key{RET} 30 p 1 / I T
4485 This means that the angle is about 15 degrees, and, assuming our
4486 original error estimates were valid standard deviations, there is about
4487 a 60% chance that the result is correct within 0.59 degrees.
4489 @cindex Torus, volume of
4490 (@bullet{}) @strong{Exercise 7.} The volume of a torus (a donut shape) is
4491 @texline @math{2 \pi^2 R r^2}
4492 @infoline @w{@expr{2 pi^2 R r^2}}
4493 where @expr{R} is the radius of the circle that
4494 defines the center of the tube and @expr{r} is the radius of the tube
4495 itself. Suppose @expr{R} is 20 cm and @expr{r} is 4 cm, each known to
4496 within 5 percent. What is the volume and the relative uncertainty of
4497 the volume? @xref{Types Answer 7, 7}. (@bullet{})
4499 An @dfn{interval form} represents a range of values. While an
4500 error form is best for making statistical estimates, intervals give
4501 you exact bounds on an answer. Suppose we additionally know that
4502 our telephone pole is definitely between 28 and 31 meters away,
4503 and that it is between 7.7 and 8.1 meters tall.
4507 1: [7.7 .. 8.1] 2: [7.7 .. 8.1] 1: [0.24 .. 0.28] 1: [13.9 .. 16.1]
4511 [ 7.7 .. 8.1 ] [ 28 .. 31 ] / I T
4516 If our bounds were correct, then the angle to the top of the pole
4517 is sure to lie in the range shown.
4519 The square brackets around these intervals indicate that the endpoints
4520 themselves are allowable values. In other words, the distance to the
4521 telephone pole is between 28 and 31, @emph{inclusive}. You can also
4522 make an interval that is exclusive of its endpoints by writing
4523 parentheses instead of square brackets. You can even make an interval
4524 which is inclusive (``closed'') on one end and exclusive (``open'') on
4529 1: [1 .. 10) 1: (0.1 .. 1] 2: (0.1 .. 1] 1: (0.2 .. 3)
4533 [ 1 .. 10 ) & [ 2 .. 3 ) *
4538 The Calculator automatically keeps track of which end values should
4539 be open and which should be closed. You can also make infinite or
4540 semi-infinite intervals by using @samp{-inf} or @samp{inf} for one
4543 (@bullet{}) @strong{Exercise 8.} What answer would you expect from
4544 @samp{@w{1 /} @w{(0 .. 10)}}? What about @samp{@w{1 /} @w{(-10 .. 0)}}? What
4545 about @samp{@w{1 /} @w{[0 .. 10]}} (where the interval actually includes
4546 zero)? What about @samp{@w{1 /} @w{(-10 .. 10)}}?
4547 @xref{Types Answer 8, 8}. (@bullet{})
4549 (@bullet{}) @strong{Exercise 9.} Two easy ways of squaring a number
4550 are @kbd{@key{RET} *} and @w{@kbd{2 ^}}. Normally these produce the same
4551 answer. Would you expect this still to hold true for interval forms?
4552 If not, which of these will result in a larger interval?
4553 @xref{Types Answer 9, 9}. (@bullet{})
4555 A @dfn{modulo form} is used for performing arithmetic modulo @var{m}.
4556 For example, arithmetic involving time is generally done modulo 12
4561 1: 17 mod 24 1: 3 mod 24 1: 21 mod 24 1: 9 mod 24
4564 17 M 24 @key{RET} 10 + n 5 /
4569 In this last step, Calc has divided by 5 modulo 24; i.e., it has found a
4570 new number which, when multiplied by 5 modulo 24, produces the original
4571 number, 21. If @var{m} is prime and the divisor is not a multiple of
4572 @var{m}, it is always possible to find such a number. For non-prime
4573 @var{m} like 24, it is only sometimes possible.
4577 1: 10 mod 24 1: 16 mod 24 1: 1000000... 1: 16
4580 10 M 24 @key{RET} 100 ^ 10 @key{RET} 100 ^ 24 %
4585 These two calculations get the same answer, but the first one is
4586 much more efficient because it avoids the huge intermediate value
4587 that arises in the second one.
4589 @cindex Fermat, primality test of
4590 (@bullet{}) @strong{Exercise 10.} A theorem of Pierre de Fermat
4592 @texline @w{@math{x^{n-1} \bmod n = 1}}
4593 @infoline @expr{x^(n-1) mod n = 1}
4594 if @expr{n} is a prime number and @expr{x} is an integer less than
4595 @expr{n}. If @expr{n} is @emph{not} a prime number, this will
4596 @emph{not} be true for most values of @expr{x}. Thus we can test
4597 informally if a number is prime by trying this formula for several
4598 values of @expr{x}. Use this test to tell whether the following numbers
4599 are prime: 811749613, 15485863. @xref{Types Answer 10, 10}. (@bullet{})
4601 It is possible to use HMS forms as parts of error forms, intervals,
4602 modulo forms, or as the phase part of a polar complex number.
4603 For example, the @code{calc-time} command pushes the current time
4604 of day on the stack as an HMS/modulo form.
4608 1: 17@@ 34' 45" mod 24@@ 0' 0" 1: 6@@ 22' 15" mod 24@@ 0' 0"
4616 This calculation tells me it is six hours and 22 minutes until midnight.
4618 (@bullet{}) @strong{Exercise 11.} A rule of thumb is that one year
4620 @texline @math{\pi \times 10^7}
4621 @infoline @w{@expr{pi * 10^7}}
4622 seconds. What time will it be that many seconds from right now?
4623 @xref{Types Answer 11, 11}. (@bullet{})
4625 (@bullet{}) @strong{Exercise 12.} You are preparing to order packaging
4626 for the CD release of the Extended Disco Version of @emph{Abbey Road}.
4627 You are told that the songs will actually be anywhere from 20 to 60
4628 seconds longer than the originals. One CD can hold about 75 minutes
4629 of music. Should you order single or double packages?
4630 @xref{Types Answer 12, 12}. (@bullet{})
4632 Another kind of data the Calculator can manipulate is numbers with
4633 @dfn{units}. This isn't strictly a new data type; it's simply an
4634 application of algebraic expressions, where we use variables with
4635 suggestive names like @samp{cm} and @samp{in} to represent units
4636 like centimeters and inches.
4640 1: 2 in 1: 5.08 cm 1: 0.027778 fath 1: 0.0508 m
4643 ' 2in @key{RET} u c cm @key{RET} u c fath @key{RET} u b
4648 We enter the quantity ``2 inches'' (actually an algebraic expression
4649 which means two times the variable @samp{in}), then we convert it
4650 first to centimeters, then to fathoms, then finally to ``base'' units,
4651 which in this case means meters.
4655 1: 9 acre 1: 3 sqrt(acre) 1: 190.84 m 1: 190.84 m + 30 cm
4658 ' 9 acre @key{RET} Q u s ' $+30 cm @key{RET}
4665 1: 191.14 m 1: 36536.3046 m^2 1: 365363046 cm^2
4673 Since units expressions are really just formulas, taking the square
4674 root of @samp{acre} is undefined. After all, @code{acre} might be an
4675 algebraic variable that you will someday assign a value. We use the
4676 ``units-simplify'' command to simplify the expression with variables
4677 being interpreted as unit names.
4679 In the final step, we have converted not to a particular unit, but to a
4680 units system. The ``cgs'' system uses centimeters instead of meters
4681 as its standard unit of length.
4683 There is a wide variety of units defined in the Calculator.
4687 1: 55 mph 1: 88.5139 kph 1: 88.5139 km / hr 1: 8.201407e-8 c
4690 ' 55 mph @key{RET} u c kph @key{RET} u c km/hr @key{RET} u c c @key{RET}
4695 We express a speed first in miles per hour, then in kilometers per
4696 hour, then again using a slightly more explicit notation, then
4697 finally in terms of fractions of the speed of light.
4699 Temperature conversions are a bit more tricky. There are two ways to
4700 interpret ``20 degrees Fahrenheit''---it could mean an actual
4701 temperature, or it could mean a change in temperature. For normal
4702 units there is no difference, but temperature units have an offset
4703 as well as a scale factor and so there must be two explicit commands
4708 1: 20 degF 1: 11.1111 degC 1: -20:3 degC 1: -6.666 degC
4711 ' 20 degF @key{RET} u c degC @key{RET} U u t degC @key{RET} c f
4716 First we convert a change of 20 degrees Fahrenheit into an equivalent
4717 change in degrees Celsius (or Centigrade). Then, we convert the
4718 absolute temperature 20 degrees Fahrenheit into Celsius. Since
4719 this comes out as an exact fraction, we then convert to floating-point
4720 for easier comparison with the other result.
4722 For simple unit conversions, you can put a plain number on the stack.
4723 Then @kbd{u c} and @kbd{u t} will prompt for both old and new units.
4724 When you use this method, you're responsible for remembering which
4725 numbers are in which units:
4729 1: 55 1: 88.5139 1: 8.201407e-8
4732 55 u c mph @key{RET} kph @key{RET} u c km/hr @key{RET} c @key{RET}
4736 To see a complete list of built-in units, type @kbd{u v}. Press
4737 @w{@kbd{C-x * c}} again to re-enter the Calculator when you're done looking
4740 (@bullet{}) @strong{Exercise 13.} How many seconds are there really
4741 in a year? @xref{Types Answer 13, 13}. (@bullet{})
4743 @cindex Speed of light
4744 (@bullet{}) @strong{Exercise 14.} Supercomputer designs are limited by
4745 the speed of light (and of electricity, which is nearly as fast).
4746 Suppose a computer has a 4.1 ns (nanosecond) clock cycle, and its
4747 cabinet is one meter across. Is speed of light going to be a
4748 significant factor in its design? @xref{Types Answer 14, 14}. (@bullet{})
4750 (@bullet{}) @strong{Exercise 15.} Sam the Slug normally travels about
4751 five yards in an hour. He has obtained a supply of Power Pills; each
4752 Power Pill he eats doubles his speed. How many Power Pills can he
4753 swallow and still travel legally on most US highways?
4754 @xref{Types Answer 15, 15}. (@bullet{})
4756 @node Algebra Tutorial, Programming Tutorial, Types Tutorial, Tutorial
4757 @section Algebra and Calculus Tutorial
4760 This section shows how to use Calc's algebra facilities to solve
4761 equations, do simple calculus problems, and manipulate algebraic
4765 * Basic Algebra Tutorial::
4766 * Rewrites Tutorial::
4769 @node Basic Algebra Tutorial, Rewrites Tutorial, Algebra Tutorial, Algebra Tutorial
4770 @subsection Basic Algebra
4773 If you enter a formula in Algebraic mode that refers to variables,
4774 the formula itself is pushed onto the stack. You can manipulate
4775 formulas as regular data objects.
4779 1: 2 x^2 - 6 1: 6 - 2 x^2 1: (6 - 2 x^2) (3 x^2 + y)
4782 ' 2x^2-6 @key{RET} n ' 3x^2+y @key{RET} *
4786 (@bullet{}) @strong{Exercise 1.} Do @kbd{' x @key{RET} Q 2 ^} and
4787 @kbd{' x @key{RET} 2 ^ Q} both wind up with the same result (@samp{x})?
4788 Why or why not? @xref{Algebra Answer 1, 1}. (@bullet{})
4790 There are also commands for doing common algebraic operations on
4791 formulas. Continuing with the formula from the last example,
4795 1: 18 x^2 + 6 y - 6 x^4 - 2 x^2 y 1: (18 - 2 y) x^2 - 6 x^4 + 6 y
4803 First we ``expand'' using the distributive law, then we ``collect''
4804 terms involving like powers of @expr{x}.
4806 Let's find the value of this expression when @expr{x} is 2 and @expr{y}
4811 1: 17 x^2 - 6 x^4 + 3 1: -25
4814 1:2 s l y @key{RET} 2 s l x @key{RET}
4819 The @kbd{s l} command means ``let''; it takes a number from the top of
4820 the stack and temporarily assigns it as the value of the variable
4821 you specify. It then evaluates (as if by the @kbd{=} key) the
4822 next expression on the stack. After this command, the variable goes
4823 back to its original value, if any.
4825 (An earlier exercise in this tutorial involved storing a value in the
4826 variable @code{x}; if this value is still there, you will have to
4827 unstore it with @kbd{s u x @key{RET}} before the above example will work
4830 @cindex Maximum of a function using Calculus
4831 Let's find the maximum value of our original expression when @expr{y}
4832 is one-half and @expr{x} ranges over all possible values. We can
4833 do this by taking the derivative with respect to @expr{x} and examining
4834 values of @expr{x} for which the derivative is zero. If the second
4835 derivative of the function at that value of @expr{x} is negative,
4836 the function has a local maximum there.
4840 1: 17 x^2 - 6 x^4 + 3 1: 34 x - 24 x^3
4843 U @key{DEL} s 1 a d x @key{RET} s 2
4848 Well, the derivative is clearly zero when @expr{x} is zero. To find
4849 the other root(s), let's divide through by @expr{x} and then solve:
4853 1: (34 x - 24 x^3) / x 1: 34 x / x - 24 x^3 / x 1: 34 - 24 x^2
4856 ' x @key{RET} / a x a s
4863 1: 34 - 24 x^2 = 0 1: x = 1.19023
4866 0 a = s 3 a S x @key{RET}
4871 Notice the use of @kbd{a s} to ``simplify'' the formula. When the
4872 default algebraic simplifications don't do enough, you can use
4873 @kbd{a s} to tell Calc to spend more time on the job.
4875 Now we compute the second derivative and plug in our values of @expr{x}:
4879 1: 1.19023 2: 1.19023 2: 1.19023
4880 . 1: 34 x - 24 x^3 1: 34 - 72 x^2
4883 a . r 2 a d x @key{RET} s 4
4888 (The @kbd{a .} command extracts just the righthand side of an equation.
4889 Another method would have been to use @kbd{v u} to unpack the equation
4890 @w{@samp{x = 1.19}} to @samp{x} and @samp{1.19}, then use @kbd{M-- M-2 @key{DEL}}
4891 to delete the @samp{x}.)
4895 2: 34 - 72 x^2 1: -68. 2: 34 - 72 x^2 1: 34
4899 @key{TAB} s l x @key{RET} U @key{DEL} 0 s l x @key{RET}
4904 The first of these second derivatives is negative, so we know the function
4905 has a maximum value at @expr{x = 1.19023}. (The function also has a
4906 local @emph{minimum} at @expr{x = 0}.)
4908 When we solved for @expr{x}, we got only one value even though
4909 @expr{34 - 24 x^2 = 0} is a quadratic equation that ought to have
4910 two solutions. The reason is that @w{@kbd{a S}} normally returns a
4911 single ``principal'' solution. If it needs to come up with an
4912 arbitrary sign (as occurs in the quadratic formula) it picks @expr{+}.
4913 If it needs an arbitrary integer, it picks zero. We can get a full
4914 solution by pressing @kbd{H} (the Hyperbolic flag) before @kbd{a S}.
4918 1: 34 - 24 x^2 = 0 1: x = 1.19023 s1 1: x = -1.19023
4921 r 3 H a S x @key{RET} s 5 1 n s l s1 @key{RET}
4926 Calc has invented the variable @samp{s1} to represent an unknown sign;
4927 it is supposed to be either @mathit{+1} or @mathit{-1}. Here we have used
4928 the ``let'' command to evaluate the expression when the sign is negative.
4929 If we plugged this into our second derivative we would get the same,
4930 negative, answer, so @expr{x = -1.19023} is also a maximum.
4932 To find the actual maximum value, we must plug our two values of @expr{x}
4933 into the original formula.
4937 2: 17 x^2 - 6 x^4 + 3 1: 24.08333 s1^2 - 12.04166 s1^4 + 3
4941 r 1 r 5 s l @key{RET}
4946 (Here we see another way to use @kbd{s l}; if its input is an equation
4947 with a variable on the lefthand side, then @kbd{s l} treats the equation
4948 like an assignment to that variable if you don't give a variable name.)
4950 It's clear that this will have the same value for either sign of
4951 @code{s1}, but let's work it out anyway, just for the exercise:
4955 2: [-1, 1] 1: [15.04166, 15.04166]
4956 1: 24.08333 s1^2 ... .
4959 [ 1 n , 1 ] @key{TAB} V M $ @key{RET}
4964 Here we have used a vector mapping operation to evaluate the function
4965 at several values of @samp{s1} at once. @kbd{V M $} is like @kbd{V M '}
4966 except that it takes the formula from the top of the stack. The
4967 formula is interpreted as a function to apply across the vector at the
4968 next-to-top stack level. Since a formula on the stack can't contain
4969 @samp{$} signs, Calc assumes the variables in the formula stand for
4970 different arguments. It prompts you for an @dfn{argument list}, giving
4971 the list of all variables in the formula in alphabetical order as the
4972 default list. In this case the default is @samp{(s1)}, which is just
4973 what we want so we simply press @key{RET} at the prompt.
4975 If there had been several different values, we could have used
4976 @w{@kbd{V R X}} to find the global maximum.
4978 Calc has a built-in @kbd{a P} command that solves an equation using
4979 @w{@kbd{H a S}} and returns a vector of all the solutions. It simply
4980 automates the job we just did by hand. Applied to our original
4981 cubic polynomial, it would produce the vector of solutions
4982 @expr{[1.19023, -1.19023, 0]}. (There is also an @kbd{a X} command
4983 which finds a local maximum of a function. It uses a numerical search
4984 method rather than examining the derivatives, and thus requires you
4985 to provide some kind of initial guess to show it where to look.)
4987 (@bullet{}) @strong{Exercise 2.} Given a vector of the roots of a
4988 polynomial (such as the output of an @kbd{a P} command), what
4989 sequence of commands would you use to reconstruct the original
4990 polynomial? (The answer will be unique to within a constant
4991 multiple; choose the solution where the leading coefficient is one.)
4992 @xref{Algebra Answer 2, 2}. (@bullet{})
4994 The @kbd{m s} command enables Symbolic mode, in which formulas
4995 like @samp{sqrt(5)} that can't be evaluated exactly are left in
4996 symbolic form rather than giving a floating-point approximate answer.
4997 Fraction mode (@kbd{m f}) is also useful when doing algebra.
5001 2: 34 x - 24 x^3 2: 34 x - 24 x^3
5002 1: 34 x - 24 x^3 1: [sqrt(51) / 6, sqrt(51) / -6, 0]
5005 r 2 @key{RET} m s m f a P x @key{RET}
5009 One more mode that makes reading formulas easier is Big mode.
5018 1: [-----, -----, 0]
5027 Here things like powers, square roots, and quotients and fractions
5028 are displayed in a two-dimensional pictorial form. Calc has other
5029 language modes as well, such as C mode, FORTRAN mode, @TeX{} mode
5034 2: 34*x - 24*pow(x, 3) 2: 34*x - 24*x**3
5035 1: @{sqrt(51) / 6, sqrt(51) / -6, 0@} 1: /sqrt(51) / 6, sqrt(51) / -6, 0/
5046 2: [@{\sqrt@{51@} \over 6@}, @{\sqrt@{51@} \over -6@}, 0]
5047 1: @{2 \over 3@} \sqrt@{5@}
5050 d T ' 2 \sqrt@{5@} \over 3 @key{RET}
5055 As you can see, language modes affect both entry and display of
5056 formulas. They affect such things as the names used for built-in
5057 functions, the set of arithmetic operators and their precedences,
5058 and notations for vectors and matrices.
5060 Notice that @samp{sqrt(51)} may cause problems with older
5061 implementations of C and FORTRAN, which would require something more
5062 like @samp{sqrt(51.0)}. It is always wise to check over the formulas
5063 produced by the various language modes to make sure they are fully
5066 Type @kbd{m s}, @kbd{m f}, and @kbd{d N} to reset these modes. (You
5067 may prefer to remain in Big mode, but all the examples in the tutorial
5068 are shown in normal mode.)
5070 @cindex Area under a curve
5071 What is the area under the portion of this curve from @expr{x = 1} to @expr{2}?
5072 This is simply the integral of the function:
5076 1: 17 x^2 - 6 x^4 + 3 1: 5.6666 x^3 - 1.2 x^5 + 3 x
5084 We want to evaluate this at our two values for @expr{x} and subtract.
5085 One way to do it is again with vector mapping and reduction:
5089 2: [2, 1] 1: [12.93333, 7.46666] 1: 5.46666
5090 1: 5.6666 x^3 ... . .
5092 [ 2 , 1 ] @key{TAB} V M $ @key{RET} V R -
5096 (@bullet{}) @strong{Exercise 3.} Find the integral from 1 to @expr{y}
5098 @texline @math{x \sin \pi x}
5099 @infoline @w{@expr{x sin(pi x)}}
5100 (where the sine is calculated in radians). Find the values of the
5101 integral for integers @expr{y} from 1 to 5. @xref{Algebra Answer 3,
5104 Calc's integrator can do many simple integrals symbolically, but many
5105 others are beyond its capabilities. Suppose we wish to find the area
5107 @texline @math{\sin x \ln x}
5108 @infoline @expr{sin(x) ln(x)}
5109 over the same range of @expr{x}. If you entered this formula and typed
5110 @kbd{a i x @key{RET}} (don't bother to try this), Calc would work for a
5111 long time but would be unable to find a solution. In fact, there is no
5112 closed-form solution to this integral. Now what do we do?
5114 @cindex Integration, numerical
5115 @cindex Numerical integration
5116 One approach would be to do the integral numerically. It is not hard
5117 to do this by hand using vector mapping and reduction. It is rather
5118 slow, though, since the sine and logarithm functions take a long time.
5119 We can save some time by reducing the working precision.
5123 3: 10 1: [1, 1.1, 1.2, ... , 1.8, 1.9]
5128 10 @key{RET} 1 @key{RET} .1 @key{RET} C-u v x
5133 (Note that we have used the extended version of @kbd{v x}; we could
5134 also have used plain @kbd{v x} as follows: @kbd{v x 10 @key{RET} 9 + .1 *}.)
5138 2: [1, 1.1, ... ] 1: [0., 0.084941, 0.16993, ... ]
5142 ' sin(x) ln(x) @key{RET} s 1 m r p 5 @key{RET} V M $ @key{RET}
5157 (If you got wildly different results, did you remember to switch
5160 Here we have divided the curve into ten segments of equal width;
5161 approximating these segments as rectangular boxes (i.e., assuming
5162 the curve is nearly flat at that resolution), we compute the areas
5163 of the boxes (height times width), then sum the areas. (It is
5164 faster to sum first, then multiply by the width, since the width
5165 is the same for every box.)
5167 The true value of this integral turns out to be about 0.374, so
5168 we're not doing too well. Let's try another approach.
5172 1: sin(x) ln(x) 1: 0.84147 x - 0.84147 + 0.11957 (x - 1)^2 - ...
5175 r 1 a t x=1 @key{RET} 4 @key{RET}
5180 Here we have computed the Taylor series expansion of the function
5181 about the point @expr{x=1}. We can now integrate this polynomial
5182 approximation, since polynomials are easy to integrate.
5186 1: 0.42074 x^2 + ... 1: [-0.0446, -0.42073] 1: 0.3761
5189 a i x @key{RET} [ 2 , 1 ] @key{TAB} V M $ @key{RET} V R -
5194 Better! By increasing the precision and/or asking for more terms
5195 in the Taylor series, we can get a result as accurate as we like.
5196 (Taylor series converge better away from singularities in the
5197 function such as the one at @code{ln(0)}, so it would also help to
5198 expand the series about the points @expr{x=2} or @expr{x=1.5} instead
5201 @cindex Simpson's rule
5202 @cindex Integration by Simpson's rule
5203 (@bullet{}) @strong{Exercise 4.} Our first method approximated the
5204 curve by stairsteps of width 0.1; the total area was then the sum
5205 of the areas of the rectangles under these stairsteps. Our second
5206 method approximated the function by a polynomial, which turned out
5207 to be a better approximation than stairsteps. A third method is
5208 @dfn{Simpson's rule}, which is like the stairstep method except
5209 that the steps are not required to be flat. Simpson's rule boils
5210 down to the formula,
5214 (h/3) * (f(a) + 4 f(a+h) + 2 f(a+2h) + 4 f(a+3h) + ...
5215 + 2 f(a+(n-2)*h) + 4 f(a+(n-1)*h) + f(a+n*h))
5221 \qquad {h \over 3} (f(a) + 4 f(a+h) + 2 f(a+2h) + 4 f(a+3h) + \cdots
5222 \hfill \cr \hfill {} + 2 f(a+(n-2)h) + 4 f(a+(n-1)h) + f(a+n h)) \qquad
5228 where @expr{n} (which must be even) is the number of slices and @expr{h}
5229 is the width of each slice. These are 10 and 0.1 in our example.
5230 For reference, here is the corresponding formula for the stairstep
5235 h * (f(a) + f(a+h) + f(a+2h) + f(a+3h) + ...
5236 + f(a+(n-2)*h) + f(a+(n-1)*h))
5241 $$ h (f(a) + f(a+h) + f(a+2h) + f(a+3h) + \cdots
5242 + f(a+(n-2)h) + f(a+(n-1)h)) $$
5246 Compute the integral from 1 to 2 of
5247 @texline @math{\sin x \ln x}
5248 @infoline @expr{sin(x) ln(x)}
5249 using Simpson's rule with 10 slices.
5250 @xref{Algebra Answer 4, 4}. (@bullet{})
5252 Calc has a built-in @kbd{a I} command for doing numerical integration.
5253 It uses @dfn{Romberg's method}, which is a more sophisticated cousin
5254 of Simpson's rule. In particular, it knows how to keep refining the
5255 result until the current precision is satisfied.
5257 @c [fix-ref Selecting Sub-Formulas]
5258 Aside from the commands we've seen so far, Calc also provides a
5259 large set of commands for operating on parts of formulas. You
5260 indicate the desired sub-formula by placing the cursor on any part
5261 of the formula before giving a @dfn{selection} command. Selections won't
5262 be covered in the tutorial; @pxref{Selecting Subformulas}, for
5263 details and examples.
5265 @c hard exercise: simplify (2^(n r) - 2^(r*(n - 1))) / (2^r - 1) 2^(n - 1)
5266 @c to 2^((n-1)*(r-1)).
5268 @node Rewrites Tutorial, , Basic Algebra Tutorial, Algebra Tutorial
5269 @subsection Rewrite Rules
5272 No matter how many built-in commands Calc provided for doing algebra,
5273 there would always be something you wanted to do that Calc didn't have
5274 in its repertoire. So Calc also provides a @dfn{rewrite rule} system
5275 that you can use to define your own algebraic manipulations.
5277 Suppose we want to simplify this trigonometric formula:
5281 1: 2 / cos(x)^2 - 2 tan(x)^2
5284 ' 2/cos(x)^2 - 2tan(x)^2 @key{RET} s 1
5289 If we were simplifying this by hand, we'd probably replace the
5290 @samp{tan} with a @samp{sin/cos} first, then combine over a common
5291 denominator. The @kbd{I a s} command will do the former and the @kbd{a n}
5292 algebra command will do the latter, but we'll do both with rewrite
5293 rules just for practice.
5295 Rewrite rules are written with the @samp{:=} symbol.
5299 1: 2 / cos(x)^2 - 2 sin(x)^2 / cos(x)^2
5302 a r tan(a) := sin(a)/cos(a) @key{RET}
5307 (The ``assignment operator'' @samp{:=} has several uses in Calc. All
5308 by itself the formula @samp{tan(a) := sin(a)/cos(a)} doesn't do anything,
5309 but when it is given to the @kbd{a r} command, that command interprets
5310 it as a rewrite rule.)
5312 The lefthand side, @samp{tan(a)}, is called the @dfn{pattern} of the
5313 rewrite rule. Calc searches the formula on the stack for parts that
5314 match the pattern. Variables in a rewrite pattern are called
5315 @dfn{meta-variables}, and when matching the pattern each meta-variable
5316 can match any sub-formula. Here, the meta-variable @samp{a} matched
5317 the actual variable @samp{x}.
5319 When the pattern part of a rewrite rule matches a part of the formula,
5320 that part is replaced by the righthand side with all the meta-variables
5321 substituted with the things they matched. So the result is
5322 @samp{sin(x) / cos(x)}. Calc's normal algebraic simplifications then
5323 mix this in with the rest of the original formula.
5325 To merge over a common denominator, we can use another simple rule:
5329 1: (2 - 2 sin(x)^2) / cos(x)^2
5332 a r a/x + b/x := (a+b)/x @key{RET}
5336 This rule points out several interesting features of rewrite patterns.
5337 First, if a meta-variable appears several times in a pattern, it must
5338 match the same thing everywhere. This rule detects common denominators
5339 because the same meta-variable @samp{x} is used in both of the
5342 Second, meta-variable names are independent from variables in the
5343 target formula. Notice that the meta-variable @samp{x} here matches
5344 the subformula @samp{cos(x)^2}; Calc never confuses the two meanings of
5347 And third, rewrite patterns know a little bit about the algebraic
5348 properties of formulas. The pattern called for a sum of two quotients;
5349 Calc was able to match a difference of two quotients by matching
5350 @samp{a = 2}, @samp{b = -2 sin(x)^2}, and @samp{x = cos(x)^2}.
5352 @c [fix-ref Algebraic Properties of Rewrite Rules]
5353 We could just as easily have written @samp{a/x - b/x := (a-b)/x} for
5354 the rule. It would have worked just the same in all cases. (If we
5355 really wanted the rule to apply only to @samp{+} or only to @samp{-},
5356 we could have used the @code{plain} symbol. @xref{Algebraic Properties
5357 of Rewrite Rules}, for some examples of this.)
5359 One more rewrite will complete the job. We want to use the identity
5360 @samp{sin(x)^2 + cos(x)^2 = 1}, but of course we must first rearrange
5361 the identity in a way that matches our formula. The obvious rule
5362 would be @samp{@w{2 - 2 sin(x)^2} := 2 cos(x)^2}, but a little thought shows
5363 that the rule @samp{sin(x)^2 := 1 - cos(x)^2} will also work. The
5364 latter rule has a more general pattern so it will work in many other
5369 1: (2 + 2 cos(x)^2 - 2) / cos(x)^2 1: 2
5372 a r sin(x)^2 := 1 - cos(x)^2 @key{RET} a s
5376 You may ask, what's the point of using the most general rule if you
5377 have to type it in every time anyway? The answer is that Calc allows
5378 you to store a rewrite rule in a variable, then give the variable
5379 name in the @kbd{a r} command. In fact, this is the preferred way to
5380 use rewrites. For one, if you need a rule once you'll most likely
5381 need it again later. Also, if the rule doesn't work quite right you
5382 can simply Undo, edit the variable, and run the rule again without
5383 having to retype it.
5387 ' tan(x) := sin(x)/cos(x) @key{RET} s t tsc @key{RET}
5388 ' a/x + b/x := (a+b)/x @key{RET} s t merge @key{RET}
5389 ' sin(x)^2 := 1 - cos(x)^2 @key{RET} s t sinsqr @key{RET}
5391 1: 2 / cos(x)^2 - 2 tan(x)^2 1: 2
5394 r 1 a r tsc @key{RET} a r merge @key{RET} a r sinsqr @key{RET} a s
5398 To edit a variable, type @kbd{s e} and the variable name, use regular
5399 Emacs editing commands as necessary, then type @kbd{C-c C-c} to store
5400 the edited value back into the variable.
5401 You can also use @w{@kbd{s e}} to create a new variable if you wish.
5403 Notice that the first time you use each rule, Calc puts up a ``compiling''
5404 message briefly. The pattern matcher converts rules into a special
5405 optimized pattern-matching language rather than using them directly.
5406 This allows @kbd{a r} to apply even rather complicated rules very
5407 efficiently. If the rule is stored in a variable, Calc compiles it
5408 only once and stores the compiled form along with the variable. That's
5409 another good reason to store your rules in variables rather than
5410 entering them on the fly.
5412 (@bullet{}) @strong{Exercise 1.} Type @kbd{m s} to get Symbolic
5413 mode, then enter the formula @samp{@w{(2 + sqrt(2))} / @w{(1 + sqrt(2))}}.
5414 Using a rewrite rule, simplify this formula by multiplying the top and
5415 bottom by the conjugate @w{@samp{1 - sqrt(2)}}. The result will have
5416 to be expanded by the distributive law; do this with another
5417 rewrite. @xref{Rewrites Answer 1, 1}. (@bullet{})
5419 The @kbd{a r} command can also accept a vector of rewrite rules, or
5420 a variable containing a vector of rules.
5424 1: [tsc, merge, sinsqr] 1: [tan(x) := sin(x) / cos(x), ... ]
5427 ' [tsc,merge,sinsqr] @key{RET} =
5434 1: 1 / cos(x) - sin(x) tan(x) 1: cos(x)
5437 s t trig @key{RET} r 1 a r trig @key{RET} a s
5441 @c [fix-ref Nested Formulas with Rewrite Rules]
5442 Calc tries all the rules you give against all parts of the formula,
5443 repeating until no further change is possible. (The exact order in
5444 which things are tried is rather complex, but for simple rules like
5445 the ones we've used here the order doesn't really matter.
5446 @xref{Nested Formulas with Rewrite Rules}.)
5448 Calc actually repeats only up to 100 times, just in case your rule set
5449 has gotten into an infinite loop. You can give a numeric prefix argument
5450 to @kbd{a r} to specify any limit. In particular, @kbd{M-1 a r} does
5451 only one rewrite at a time.
5455 1: 1 / cos(x) - sin(x)^2 / cos(x) 1: (1 - sin(x)^2) / cos(x)
5458 r 1 M-1 a r trig @key{RET} M-1 a r trig @key{RET}
5462 You can type @kbd{M-0 a r} if you want no limit at all on the number
5463 of rewrites that occur.
5465 Rewrite rules can also be @dfn{conditional}. Simply follow the rule
5466 with a @samp{::} symbol and the desired condition. For example,
5470 1: exp(2 pi i) + exp(3 pi i) + exp(4 pi i)
5473 ' exp(2 pi i) + exp(3 pi i) + exp(4 pi i) @key{RET}
5480 1: 1 + exp(3 pi i) + 1
5483 a r exp(k pi i) := 1 :: k % 2 = 0 @key{RET}
5488 (Recall, @samp{k % 2} is the remainder from dividing @samp{k} by 2,
5489 which will be zero only when @samp{k} is an even integer.)
5491 An interesting point is that the variables @samp{pi} and @samp{i}
5492 were matched literally rather than acting as meta-variables.
5493 This is because they are special-constant variables. The special
5494 constants @samp{e}, @samp{phi}, and so on also match literally.
5495 A common error with rewrite
5496 rules is to write, say, @samp{f(a,b,c,d,e) := g(a+b+c+d+e)}, expecting
5497 to match any @samp{f} with five arguments but in fact matching
5498 only when the fifth argument is literally @samp{e}!
5500 @cindex Fibonacci numbers
5505 Rewrite rules provide an interesting way to define your own functions.
5506 Suppose we want to define @samp{fib(n)} to produce the @var{n}th
5507 Fibonacci number. The first two Fibonacci numbers are each 1;
5508 later numbers are formed by summing the two preceding numbers in
5509 the sequence. This is easy to express in a set of three rules:
5513 ' [fib(1) := 1, fib(2) := 1, fib(n) := fib(n-1) + fib(n-2)] @key{RET} s t fib
5518 ' fib(7) @key{RET} a r fib @key{RET}
5522 One thing that is guaranteed about the order that rewrites are tried
5523 is that, for any given subformula, earlier rules in the rule set will
5524 be tried for that subformula before later ones. So even though the
5525 first and third rules both match @samp{fib(1)}, we know the first will
5526 be used preferentially.
5528 This rule set has one dangerous bug: Suppose we apply it to the
5529 formula @samp{fib(x)}? (Don't actually try this.) The third rule
5530 will match @samp{fib(x)} and replace it with @w{@samp{fib(x-1) + fib(x-2)}}.
5531 Each of these will then be replaced to get @samp{fib(x-2) + 2 fib(x-3) +
5532 fib(x-4)}, and so on, expanding forever. What we really want is to apply
5533 the third rule only when @samp{n} is an integer greater than two. Type
5534 @w{@kbd{s e fib @key{RET}}}, then edit the third rule to:
5537 fib(n) := fib(n-1) + fib(n-2) :: integer(n) :: n > 2
5545 1: fib(6) + fib(x) + fib(0) 1: 8 + fib(x) + fib(0)
5548 ' fib(6)+fib(x)+fib(0) @key{RET} a r fib @key{RET}
5553 We've created a new function, @code{fib}, and a new command,
5554 @w{@kbd{a r fib @key{RET}}}, which means ``evaluate all @code{fib} calls in
5555 this formula.'' To make things easier still, we can tell Calc to
5556 apply these rules automatically by storing them in the special
5557 variable @code{EvalRules}.
5561 1: [fib(1) := ...] . 1: [8, 13]
5564 s r fib @key{RET} s t EvalRules @key{RET} ' [fib(6), fib(7)] @key{RET}
5568 It turns out that this rule set has the problem that it does far
5569 more work than it needs to when @samp{n} is large. Consider the
5570 first few steps of the computation of @samp{fib(6)}:
5576 fib(4) + fib(3) + fib(3) + fib(2) =
5577 fib(3) + fib(2) + fib(2) + fib(1) + fib(2) + fib(1) + 1 = ...
5582 Note that @samp{fib(3)} appears three times here. Unless Calc's
5583 algebraic simplifier notices the multiple @samp{fib(3)}s and combines
5584 them (and, as it happens, it doesn't), this rule set does lots of
5585 needless recomputation. To cure the problem, type @code{s e EvalRules}
5586 to edit the rules (or just @kbd{s E}, a shorthand command for editing
5587 @code{EvalRules}) and add another condition:
5590 fib(n) := fib(n-1) + fib(n-2) :: integer(n) :: n > 2 :: remember
5594 If a @samp{:: remember} condition appears anywhere in a rule, then if
5595 that rule succeeds Calc will add another rule that describes that match
5596 to the front of the rule set. (Remembering works in any rule set, but
5597 for technical reasons it is most effective in @code{EvalRules}.) For
5598 example, if the rule rewrites @samp{fib(7)} to something that evaluates
5599 to 13, then the rule @samp{fib(7) := 13} will be added to the rule set.
5601 Type @kbd{' fib(8) @key{RET}} to compute the eighth Fibonacci number, then
5602 type @kbd{s E} again to see what has happened to the rule set.
5604 With the @code{remember} feature, our rule set can now compute
5605 @samp{fib(@var{n})} in just @var{n} steps. In the process it builds
5606 up a table of all Fibonacci numbers up to @var{n}. After we have
5607 computed the result for a particular @var{n}, we can get it back
5608 (and the results for all smaller @var{n}) later in just one step.
5610 All Calc operations will run somewhat slower whenever @code{EvalRules}
5611 contains any rules. You should type @kbd{s u EvalRules @key{RET}} now to
5612 un-store the variable.
5614 (@bullet{}) @strong{Exercise 2.} Sometimes it is possible to reformulate
5615 a problem to reduce the amount of recursion necessary to solve it.
5616 Create a rule that, in about @var{n} simple steps and without recourse
5617 to the @code{remember} option, replaces @samp{fib(@var{n}, 1, 1)} with
5618 @samp{fib(1, @var{x}, @var{y})} where @var{x} and @var{y} are the
5619 @var{n}th and @var{n+1}st Fibonacci numbers, respectively. This rule is
5620 rather clunky to use, so add a couple more rules to make the ``user
5621 interface'' the same as for our first version: enter @samp{fib(@var{n})},
5622 get back a plain number. @xref{Rewrites Answer 2, 2}. (@bullet{})
5624 There are many more things that rewrites can do. For example, there
5625 are @samp{&&&} and @samp{|||} pattern operators that create ``and''
5626 and ``or'' combinations of rules. As one really simple example, we
5627 could combine our first two Fibonacci rules thusly:
5630 [fib(1 ||| 2) := 1, fib(n) := ... ]
5634 That means ``@code{fib} of something matching either 1 or 2 rewrites
5637 You can also make meta-variables optional by enclosing them in @code{opt}.
5638 For example, the pattern @samp{a + b x} matches @samp{2 + 3 x} but not
5639 @samp{2 + x} or @samp{3 x} or @samp{x}. The pattern @samp{opt(a) + opt(b) x}
5640 matches all of these forms, filling in a default of zero for @samp{a}
5641 and one for @samp{b}.
5643 (@bullet{}) @strong{Exercise 3.} Your friend Joe had @samp{2 + 3 x}
5644 on the stack and tried to use the rule
5645 @samp{opt(a) + opt(b) x := f(a, b, x)}. What happened?
5646 @xref{Rewrites Answer 3, 3}. (@bullet{})
5648 (@bullet{}) @strong{Exercise 4.} Starting with a positive integer @expr{a},
5649 divide @expr{a} by two if it is even, otherwise compute @expr{3 a + 1}.
5650 Now repeat this step over and over. A famous unproved conjecture
5651 is that for any starting @expr{a}, the sequence always eventually
5652 reaches 1. Given the formula @samp{seq(@var{a}, 0)}, write a set of
5653 rules that convert this into @samp{seq(1, @var{n})} where @var{n}
5654 is the number of steps it took the sequence to reach the value 1.
5655 Now enhance the rules to accept @samp{seq(@var{a})} as a starting
5656 configuration, and to stop with just the number @var{n} by itself.
5657 Now make the result be a vector of values in the sequence, from @var{a}
5658 to 1. (The formula @samp{@var{x}|@var{y}} appends the vectors @var{x}
5659 and @var{y}.) For example, rewriting @samp{seq(6)} should yield the
5660 vector @expr{[6, 3, 10, 5, 16, 8, 4, 2, 1]}.
5661 @xref{Rewrites Answer 4, 4}. (@bullet{})
5663 (@bullet{}) @strong{Exercise 5.} Define, using rewrite rules, a function
5664 @samp{nterms(@var{x})} that returns the number of terms in the sum
5665 @var{x}, or 1 if @var{x} is not a sum. (A @dfn{sum} for our purposes
5666 is one or more non-sum terms separated by @samp{+} or @samp{-} signs,
5667 so that @expr{2 - 3 (x + y) + x y} is a sum of three terms.)
5668 @xref{Rewrites Answer 5, 5}. (@bullet{})
5670 (@bullet{}) @strong{Exercise 6.} A Taylor series for a function is an
5671 infinite series that exactly equals the value of that function at
5672 values of @expr{x} near zero.
5676 cos(x) = 1 - x^2 / 2! + x^4 / 4! - x^6 / 6! + ...
5681 $$ \cos x = 1 - {x^2 \over 2!} + {x^4 \over 4!} - {x^6 \over 6!} + \cdots $$
5685 The @kbd{a t} command produces a @dfn{truncated Taylor series} which
5686 is obtained by dropping all the terms higher than, say, @expr{x^2}.
5687 Calc represents the truncated Taylor series as a polynomial in @expr{x}.
5688 Mathematicians often write a truncated series using a ``big-O'' notation
5689 that records what was the lowest term that was truncated.
5693 cos(x) = 1 - x^2 / 2! + O(x^3)
5698 $$ \cos x = 1 - {x^2 \over 2!} + O(x^3) $$
5703 The meaning of @expr{O(x^3)} is ``a quantity which is negligibly small
5704 if @expr{x^3} is considered negligibly small as @expr{x} goes to zero.''
5706 The exercise is to create rewrite rules that simplify sums and products of
5707 power series represented as @samp{@var{polynomial} + O(@var{var}^@var{n})}.
5708 For example, given @samp{1 - x^2 / 2 + O(x^3)} and @samp{x - x^3 / 6 + O(x^4)}
5709 on the stack, we want to be able to type @kbd{*} and get the result
5710 @samp{x - 2:3 x^3 + O(x^4)}. Don't worry if the terms of the sum are
5711 rearranged or if @kbd{a s} needs to be typed after rewriting. (This one
5712 is rather tricky; the solution at the end of this chapter uses 6 rewrite
5713 rules. Hint: The @samp{constant(x)} condition tests whether @samp{x} is
5714 a number.) @xref{Rewrites Answer 6, 6}. (@bullet{})
5716 Just for kicks, try adding the rule @code{2+3 := 6} to @code{EvalRules}.
5717 What happens? (Be sure to remove this rule afterward, or you might get
5718 a nasty surprise when you use Calc to balance your checkbook!)
5720 @xref{Rewrite Rules}, for the whole story on rewrite rules.
5722 @node Programming Tutorial, Answers to Exercises, Algebra Tutorial, Tutorial
5723 @section Programming Tutorial
5726 The Calculator is written entirely in Emacs Lisp, a highly extensible
5727 language. If you know Lisp, you can program the Calculator to do
5728 anything you like. Rewrite rules also work as a powerful programming
5729 system. But Lisp and rewrite rules take a while to master, and often
5730 all you want to do is define a new function or repeat a command a few
5731 times. Calc has features that allow you to do these things easily.
5733 One very limited form of programming is defining your own functions.
5734 Calc's @kbd{Z F} command allows you to define a function name and
5735 key sequence to correspond to any formula. Programming commands use
5736 the shift-@kbd{Z} prefix; the user commands they create use the lower
5737 case @kbd{z} prefix.
5741 1: 1 + x + x^2 / 2 + x^3 / 6 1: 1 + x + x^2 / 2 + x^3 / 6
5744 ' 1 + x + x^2/2! + x^3/3! @key{RET} Z F e myexp @key{RET} @key{RET} @key{RET} y
5748 This polynomial is a Taylor series approximation to @samp{exp(x)}.
5749 The @kbd{Z F} command asks a number of questions. The above answers
5750 say that the key sequence for our function should be @kbd{z e}; the
5751 @kbd{M-x} equivalent should be @code{calc-myexp}; the name of the
5752 function in algebraic formulas should also be @code{myexp}; the
5753 default argument list @samp{(x)} is acceptable; and finally @kbd{y}
5754 answers the question ``leave it in symbolic form for non-constant
5759 1: 1.3495 2: 1.3495 3: 1.3495
5760 . 1: 1.34986 2: 1.34986
5764 .3 z e .3 E ' a+1 @key{RET} z e
5769 First we call our new @code{exp} approximation with 0.3 as an
5770 argument, and compare it with the true @code{exp} function. Then
5771 we note that, as requested, if we try to give @kbd{z e} an
5772 argument that isn't a plain number, it leaves the @code{myexp}
5773 function call in symbolic form. If we had answered @kbd{n} to the
5774 final question, @samp{myexp(a + 1)} would have evaluated by plugging
5775 in @samp{a + 1} for @samp{x} in the defining formula.
5777 @cindex Sine integral Si(x)
5782 (@bullet{}) @strong{Exercise 1.} The ``sine integral'' function
5783 @texline @math{{\rm Si}(x)}
5784 @infoline @expr{Si(x)}
5785 is defined as the integral of @samp{sin(t)/t} for
5786 @expr{t = 0} to @expr{x} in radians. (It was invented because this
5787 integral has no solution in terms of basic functions; if you give it
5788 to Calc's @kbd{a i} command, it will ponder it for a long time and then
5789 give up.) We can use the numerical integration command, however,
5790 which in algebraic notation is written like @samp{ninteg(f(t), t, 0, x)}
5791 with any integrand @samp{f(t)}. Define a @kbd{z s} command and
5792 @code{Si} function that implement this. You will need to edit the
5793 default argument list a bit. As a test, @samp{Si(1)} should return
5794 0.946083. (If you don't get this answer, you might want to check that
5795 Calc is in Radians mode. Also, @code{ninteg} will run a lot faster if
5796 you reduce the precision to, say, six digits beforehand.)
5797 @xref{Programming Answer 1, 1}. (@bullet{})
5799 The simplest way to do real ``programming'' of Emacs is to define a
5800 @dfn{keyboard macro}. A keyboard macro is simply a sequence of
5801 keystrokes which Emacs has stored away and can play back on demand.
5802 For example, if you find yourself typing @kbd{H a S x @key{RET}} often,
5803 you may wish to program a keyboard macro to type this for you.
5807 1: y = sqrt(x) 1: x = y^2
5810 ' y=sqrt(x) @key{RET} C-x ( H a S x @key{RET} C-x )
5812 1: y = cos(x) 1: x = s1 arccos(y) + 2 pi n1
5815 ' y=cos(x) @key{RET} X
5820 When you type @kbd{C-x (}, Emacs begins recording. But it is also
5821 still ready to execute your keystrokes, so you're really ``training''
5822 Emacs by walking it through the procedure once. When you type
5823 @w{@kbd{C-x )}}, the macro is recorded. You can now type @kbd{X} to
5824 re-execute the same keystrokes.
5826 You can give a name to your macro by typing @kbd{Z K}.
5830 1: . 1: y = x^4 1: x = s2 sqrt(s1 sqrt(y))
5833 Z K x @key{RET} ' y=x^4 @key{RET} z x
5838 Notice that we use shift-@kbd{Z} to define the command, and lower-case
5839 @kbd{z} to call it up.
5841 Keyboard macros can call other macros.
5845 1: abs(x) 1: x = s1 y 1: 2 / x 1: x = 2 / y
5848 ' abs(x) @key{RET} C-x ( ' y @key{RET} a = z x C-x ) ' 2/x @key{RET} X
5852 (@bullet{}) @strong{Exercise 2.} Define a keyboard macro to negate
5853 the item in level 3 of the stack, without disturbing the rest of
5854 the stack. @xref{Programming Answer 2, 2}. (@bullet{})
5856 (@bullet{}) @strong{Exercise 3.} Define keyboard macros to compute
5857 the following functions:
5862 @texline @math{\displaystyle{\sin x \over x}},
5863 @infoline @expr{sin(x) / x},
5864 where @expr{x} is the number on the top of the stack.
5867 Compute the base-@expr{b} logarithm, just like the @kbd{B} key except
5868 the arguments are taken in the opposite order.
5871 Produce a vector of integers from 1 to the integer on the top of
5875 @xref{Programming Answer 3, 3}. (@bullet{})
5877 (@bullet{}) @strong{Exercise 4.} Define a keyboard macro to compute
5878 the average (mean) value of a list of numbers.
5879 @xref{Programming Answer 4, 4}. (@bullet{})
5881 In many programs, some of the steps must execute several times.
5882 Calc has @dfn{looping} commands that allow this. Loops are useful
5883 inside keyboard macros, but actually work at any time.
5887 1: x^6 2: x^6 1: 360 x^2
5891 ' x^6 @key{RET} 4 Z < a d x @key{RET} Z >
5896 Here we have computed the fourth derivative of @expr{x^6} by
5897 enclosing a derivative command in a ``repeat loop'' structure.
5898 This structure pops a repeat count from the stack, then
5899 executes the body of the loop that many times.
5901 If you make a mistake while entering the body of the loop,
5902 type @w{@kbd{Z C-g}} to cancel the loop command.
5904 @cindex Fibonacci numbers
5905 Here's another example:
5914 1 @key{RET} @key{RET} 20 Z < @key{TAB} C-j + Z >
5919 The numbers in levels 2 and 1 should be the 21st and 22nd Fibonacci
5920 numbers, respectively. (To see what's going on, try a few repetitions
5921 of the loop body by hand; @kbd{C-j}, also on the Line-Feed or @key{LFD}
5922 key if you have one, makes a copy of the number in level 2.)
5924 @cindex Golden ratio
5925 @cindex Phi, golden ratio
5926 A fascinating property of the Fibonacci numbers is that the @expr{n}th
5927 Fibonacci number can be found directly by computing
5928 @texline @math{\phi^n / \sqrt{5}}
5929 @infoline @expr{phi^n / sqrt(5)}
5930 and then rounding to the nearest integer, where
5931 @texline @math{\phi} (``phi''),
5932 @infoline @expr{phi},
5933 the ``golden ratio,'' is
5934 @texline @math{(1 + \sqrt{5}) / 2}.
5935 @infoline @expr{(1 + sqrt(5)) / 2}.
5936 (For convenience, this constant is available from the @code{phi}
5937 variable, or the @kbd{I H P} command.)
5941 1: 1.61803 1: 24476.0000409 1: 10945.9999817 1: 10946
5948 @cindex Continued fractions
5949 (@bullet{}) @strong{Exercise 5.} The @dfn{continued fraction}
5951 @texline @math{\phi}
5952 @infoline @expr{phi}
5954 @texline @math{1 + 1/(1 + 1/(1 + 1/( \ldots )))}.
5955 @infoline @expr{1 + 1/(1 + 1/(1 + 1/( ...@: )))}.
5956 We can compute an approximate value by carrying this however far
5957 and then replacing the innermost
5958 @texline @math{1/( \ldots )}
5959 @infoline @expr{1/( ...@: )}
5961 @texline @math{\phi}
5962 @infoline @expr{phi}
5963 using a twenty-term continued fraction.
5964 @xref{Programming Answer 5, 5}. (@bullet{})
5966 (@bullet{}) @strong{Exercise 6.} Linear recurrences like the one for
5967 Fibonacci numbers can be expressed in terms of matrices. Given a
5968 vector @w{@expr{[a, b]}} determine a matrix which, when multiplied by this
5969 vector, produces the vector @expr{[b, c]}, where @expr{a}, @expr{b} and
5970 @expr{c} are three successive Fibonacci numbers. Now write a program
5971 that, given an integer @expr{n}, computes the @expr{n}th Fibonacci number
5972 using matrix arithmetic. @xref{Programming Answer 6, 6}. (@bullet{})
5974 @cindex Harmonic numbers
5975 A more sophisticated kind of loop is the @dfn{for} loop. Suppose
5976 we wish to compute the 20th ``harmonic'' number, which is equal to
5977 the sum of the reciprocals of the integers from 1 to 20.
5986 0 @key{RET} 1 @key{RET} 20 Z ( & + 1 Z )
5991 The ``for'' loop pops two numbers, the lower and upper limits, then
5992 repeats the body of the loop as an internal counter increases from
5993 the lower limit to the upper one. Just before executing the loop
5994 body, it pushes the current loop counter. When the loop body
5995 finishes, it pops the ``step,'' i.e., the amount by which to
5996 increment the loop counter. As you can see, our loop always
5999 This harmonic number function uses the stack to hold the running
6000 total as well as for the various loop housekeeping functions. If
6001 you find this disorienting, you can sum in a variable instead:
6005 1: 0 2: 1 . 1: 3.597739
6009 0 t 7 1 @key{RET} 20 Z ( & s + 7 1 Z ) r 7
6014 The @kbd{s +} command adds the top-of-stack into the value in a
6015 variable (and removes that value from the stack).
6017 It's worth noting that many jobs that call for a ``for'' loop can
6018 also be done more easily by Calc's high-level operations. Two
6019 other ways to compute harmonic numbers are to use vector mapping
6020 and reduction (@kbd{v x 20}, then @w{@kbd{V M &}}, then @kbd{V R +}),
6021 or to use the summation command @kbd{a +}. Both of these are
6022 probably easier than using loops. However, there are some
6023 situations where loops really are the way to go:
6025 (@bullet{}) @strong{Exercise 7.} Use a ``for'' loop to find the first
6026 harmonic number which is greater than 4.0.
6027 @xref{Programming Answer 7, 7}. (@bullet{})
6029 Of course, if we're going to be using variables in our programs,
6030 we have to worry about the programs clobbering values that the
6031 caller was keeping in those same variables. This is easy to
6036 . 1: 0.6667 1: 0.6667 3: 0.6667
6041 Z ` p 4 @key{RET} 2 @key{RET} 3 / s 7 s s a @key{RET} Z ' r 7 s r a @key{RET}
6046 When we type @kbd{Z `} (that's a back-quote character), Calc saves
6047 its mode settings and the contents of the ten ``quick variables''
6048 for later reference. When we type @kbd{Z '} (that's an apostrophe
6049 now), Calc restores those saved values. Thus the @kbd{p 4} and
6050 @kbd{s 7} commands have no effect outside this sequence. Wrapping
6051 this around the body of a keyboard macro ensures that it doesn't
6052 interfere with what the user of the macro was doing. Notice that
6053 the contents of the stack, and the values of named variables,
6054 survive past the @kbd{Z '} command.
6056 @cindex Bernoulli numbers, approximate
6057 The @dfn{Bernoulli numbers} are a sequence with the interesting
6058 property that all of the odd Bernoulli numbers are zero, and the
6059 even ones, while difficult to compute, can be roughly approximated
6061 @texline @math{\displaystyle{2 n! \over (2 \pi)^n}}.
6062 @infoline @expr{2 n!@: / (2 pi)^n}.
6063 Let's write a keyboard macro to compute (approximate) Bernoulli numbers.
6064 (Calc has a command, @kbd{k b}, to compute exact Bernoulli numbers, but
6065 this command is very slow for large @expr{n} since the higher Bernoulli
6066 numbers are very large fractions.)
6073 10 C-x ( @key{RET} 2 % Z [ @key{DEL} 0 Z : ' 2 $! / (2 pi)^$ @key{RET} = Z ] C-x )
6078 You can read @kbd{Z [} as ``then,'' @kbd{Z :} as ``else,'' and
6079 @kbd{Z ]} as ``end-if.'' There is no need for an explicit ``if''
6080 command. For the purposes of @w{@kbd{Z [}}, the condition is ``true''
6081 if the value it pops from the stack is a nonzero number, or ``false''
6082 if it pops zero or something that is not a number (like a formula).
6083 Here we take our integer argument modulo 2; this will be nonzero
6084 if we're asking for an odd Bernoulli number.
6086 The actual tenth Bernoulli number is @expr{5/66}.
6090 3: 0.0756823 1: 0 1: 0.25305 1: 0 1: 1.16659
6095 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
6099 Just to exercise loops a bit more, let's compute a table of even
6104 3: [] 1: [0.10132, 0.03079, 0.02340, 0.033197, ...]
6109 [ ] 2 @key{RET} 30 Z ( X | 2 Z )
6114 The vertical-bar @kbd{|} is the vector-concatenation command. When
6115 we execute it, the list we are building will be in stack level 2
6116 (initially this is an empty list), and the next Bernoulli number
6117 will be in level 1. The effect is to append the Bernoulli number
6118 onto the end of the list. (To create a table of exact fractional
6119 Bernoulli numbers, just replace @kbd{X} with @kbd{k b} in the above
6120 sequence of keystrokes.)
6122 With loops and conditionals, you can program essentially anything
6123 in Calc. One other command that makes looping easier is @kbd{Z /},
6124 which takes a condition from the stack and breaks out of the enclosing
6125 loop if the condition is true (non-zero). You can use this to make
6126 ``while'' and ``until'' style loops.
6128 If you make a mistake when entering a keyboard macro, you can edit
6129 it using @kbd{Z E}. First, you must attach it to a key with @kbd{Z K}.
6130 One technique is to enter a throwaway dummy definition for the macro,
6131 then enter the real one in the edit command.
6135 1: 3 1: 3 Calc Macro Edit Mode.
6136 . . Original keys: 1 <return> 2 +
6143 C-x ( 1 @key{RET} 2 + C-x ) Z K h @key{RET} Z E h
6148 A keyboard macro is stored as a pure keystroke sequence. The
6149 @file{edmacro} package (invoked by @kbd{Z E}) scans along the
6150 macro and tries to decode it back into human-readable steps.
6151 Descriptions of the keystrokes are given as comments, which begin with
6152 @samp{;;}, and which are ignored when the edited macro is saved.
6153 Spaces and line breaks are also ignored when the edited macro is saved.
6154 To enter a space into the macro, type @code{SPC}. All the special
6155 characters @code{RET}, @code{LFD}, @code{TAB}, @code{SPC}, @code{DEL},
6156 and @code{NUL} must be written in all uppercase, as must the prefixes
6157 @code{C-} and @code{M-}.
6159 Let's edit in a new definition, for computing harmonic numbers.
6160 First, erase the four lines of the old definition. Then, type
6161 in the new definition (or use Emacs @kbd{M-w} and @kbd{C-y} commands
6162 to copy it from this page of the Info file; you can of course skip
6163 typing the comments, which begin with @samp{;;}).
6166 Z` ;; calc-kbd-push (Save local values)
6167 0 ;; calc digits (Push a zero onto the stack)
6168 st ;; calc-store-into (Store it in the following variable)
6169 1 ;; calc quick variable (Quick variable q1)
6170 1 ;; calc digits (Initial value for the loop)
6171 TAB ;; calc-roll-down (Swap initial and final)
6172 Z( ;; calc-kbd-for (Begin the "for" loop)
6173 & ;; calc-inv (Take the reciprocal)
6174 s+ ;; calc-store-plus (Add to the following variable)
6175 1 ;; calc quick variable (Quick variable q1)
6176 1 ;; calc digits (The loop step is 1)
6177 Z) ;; calc-kbd-end-for (End the "for" loop)
6178 sr ;; calc-recall (Recall the final accumulated value)
6179 1 ;; calc quick variable (Quick variable q1)
6180 Z' ;; calc-kbd-pop (Restore values)
6184 Press @kbd{C-c C-c} to finish editing and return to the Calculator.
6195 The @file{edmacro} package defines a handy @code{read-kbd-macro} command
6196 which reads the current region of the current buffer as a sequence of
6197 keystroke names, and defines that sequence on the @kbd{X}
6198 (and @kbd{C-x e}) key. Because this is so useful, Calc puts this
6199 command on the @kbd{C-x * m} key. Try reading in this macro in the
6200 following form: Press @kbd{C-@@} (or @kbd{C-@key{SPC}}) at
6201 one end of the text below, then type @kbd{C-x * m} at the other.
6213 (@bullet{}) @strong{Exercise 8.} A general algorithm for solving
6214 equations numerically is @dfn{Newton's Method}. Given the equation
6215 @expr{f(x) = 0} for any function @expr{f}, and an initial guess
6216 @expr{x_0} which is reasonably close to the desired solution, apply
6217 this formula over and over:
6221 new_x = x - f(x)/f'(x)
6226 $$ x_{\rm new} = x - {f(x) \over f^{\prime}(x)} $$
6231 where @expr{f'(x)} is the derivative of @expr{f}. The @expr{x}
6232 values will quickly converge to a solution, i.e., eventually
6233 @texline @math{x_{\rm new}}
6234 @infoline @expr{new_x}
6235 and @expr{x} will be equal to within the limits
6236 of the current precision. Write a program which takes a formula
6237 involving the variable @expr{x}, and an initial guess @expr{x_0},
6238 on the stack, and produces a value of @expr{x} for which the formula
6239 is zero. Use it to find a solution of
6240 @texline @math{\sin(\cos x) = 0.5}
6241 @infoline @expr{sin(cos(x)) = 0.5}
6242 near @expr{x = 4.5}. (Use angles measured in radians.) Note that
6243 the built-in @w{@kbd{a R}} (@code{calc-find-root}) command uses Newton's
6244 method when it is able. @xref{Programming Answer 8, 8}. (@bullet{})
6246 @cindex Digamma function
6247 @cindex Gamma constant, Euler's
6248 @cindex Euler's gamma constant
6249 (@bullet{}) @strong{Exercise 9.} The @dfn{digamma} function
6250 @texline @math{\psi(z) (``psi'')}
6251 @infoline @expr{psi(z)}
6252 is defined as the derivative of
6253 @texline @math{\ln \Gamma(z)}.
6254 @infoline @expr{ln(gamma(z))}.
6255 For large values of @expr{z}, it can be approximated by the infinite sum
6259 psi(z) ~= ln(z) - 1/2z - sum(bern(2 n) / 2 n z^(2 n), n, 1, inf)
6264 $$ \psi(z) \approx \ln z - {1\over2z} -
6265 \sum_{n=1}^\infty {\code{bern}(2 n) \over 2 n z^{2n}}
6272 @texline @math{\sum}
6273 @infoline @expr{sum}
6274 represents the sum over @expr{n} from 1 to infinity
6275 (or to some limit high enough to give the desired accuracy), and
6276 the @code{bern} function produces (exact) Bernoulli numbers.
6277 While this sum is not guaranteed to converge, in practice it is safe.
6278 An interesting mathematical constant is Euler's gamma, which is equal
6279 to about 0.5772. One way to compute it is by the formula,
6280 @texline @math{\gamma = -\psi(1)}.
6281 @infoline @expr{gamma = -psi(1)}.
6282 Unfortunately, 1 isn't a large enough argument
6283 for the above formula to work (5 is a much safer value for @expr{z}).
6284 Fortunately, we can compute
6285 @texline @math{\psi(1)}
6286 @infoline @expr{psi(1)}
6288 @texline @math{\psi(5)}
6289 @infoline @expr{psi(5)}
6290 using the recurrence
6291 @texline @math{\psi(z+1) = \psi(z) + {1 \over z}}.
6292 @infoline @expr{psi(z+1) = psi(z) + 1/z}.
6293 Your task: Develop a program to compute
6294 @texline @math{\psi(z)};
6295 @infoline @expr{psi(z)};
6296 it should ``pump up'' @expr{z}
6297 if necessary to be greater than 5, then use the above summation
6298 formula. Use looping commands to compute the sum. Use your function
6300 @texline @math{\gamma}
6301 @infoline @expr{gamma}
6302 to twelve decimal places. (Calc has a built-in command
6303 for Euler's constant, @kbd{I P}, which you can use to check your answer.)
6304 @xref{Programming Answer 9, 9}. (@bullet{})
6306 @cindex Polynomial, list of coefficients
6307 (@bullet{}) @strong{Exercise 10.} Given a polynomial in @expr{x} and
6308 a number @expr{m} on the stack, where the polynomial is of degree
6309 @expr{m} or less (i.e., does not have any terms higher than @expr{x^m}),
6310 write a program to convert the polynomial into a list-of-coefficients
6311 notation. For example, @expr{5 x^4 + (x + 1)^2} with @expr{m = 6}
6312 should produce the list @expr{[1, 2, 1, 0, 5, 0, 0]}. Also develop
6313 a way to convert from this form back to the standard algebraic form.
6314 @xref{Programming Answer 10, 10}. (@bullet{})
6317 (@bullet{}) @strong{Exercise 11.} The @dfn{Stirling numbers of the
6318 first kind} are defined by the recurrences,
6322 s(n,n) = 1 for n >= 0,
6323 s(n,0) = 0 for n > 0,
6324 s(n+1,m) = s(n,m-1) - n s(n,m) for n >= m >= 1.
6329 $$ \eqalign{ s(n,n) &= 1 \qquad \hbox{for } n \ge 0, \cr
6330 s(n,0) &= 0 \qquad \hbox{for } n > 0, \cr
6331 s(n+1,m) &= s(n,m-1) - n \, s(n,m) \qquad
6332 \hbox{for } n \ge m \ge 1.}
6336 (These numbers are also sometimes written $\displaystyle{n \brack m}$.)
6339 This can be implemented using a @dfn{recursive} program in Calc; the
6340 program must invoke itself in order to calculate the two righthand
6341 terms in the general formula. Since it always invokes itself with
6342 ``simpler'' arguments, it's easy to see that it must eventually finish
6343 the computation. Recursion is a little difficult with Emacs keyboard
6344 macros since the macro is executed before its definition is complete.
6345 So here's the recommended strategy: Create a ``dummy macro'' and assign
6346 it to a key with, e.g., @kbd{Z K s}. Now enter the true definition,
6347 using the @kbd{z s} command to call itself recursively, then assign it
6348 to the same key with @kbd{Z K s}. Now the @kbd{z s} command will run
6349 the complete recursive program. (Another way is to use @w{@kbd{Z E}}
6350 or @kbd{C-x * m} (@code{read-kbd-macro}) to read the whole macro at once,
6351 thus avoiding the ``training'' phase.) The task: Write a program
6352 that computes Stirling numbers of the first kind, given @expr{n} and
6353 @expr{m} on the stack. Test it with @emph{small} inputs like
6354 @expr{s(4,2)}. (There is a built-in command for Stirling numbers,
6355 @kbd{k s}, which you can use to check your answers.)
6356 @xref{Programming Answer 11, 11}. (@bullet{})
6358 The programming commands we've seen in this part of the tutorial
6359 are low-level, general-purpose operations. Often you will find
6360 that a higher-level function, such as vector mapping or rewrite
6361 rules, will do the job much more easily than a detailed, step-by-step
6364 (@bullet{}) @strong{Exercise 12.} Write another program for
6365 computing Stirling numbers of the first kind, this time using
6366 rewrite rules. Once again, @expr{n} and @expr{m} should be taken
6367 from the stack. @xref{Programming Answer 12, 12}. (@bullet{})
6372 This ends the tutorial section of the Calc manual. Now you know enough
6373 about Calc to use it effectively for many kinds of calculations. But
6374 Calc has many features that were not even touched upon in this tutorial.
6376 The rest of this manual tells the whole story.
6378 @c Volume II of this manual, the @dfn{Calc Reference}, tells the whole story.
6381 @node Answers to Exercises, , Programming Tutorial, Tutorial
6382 @section Answers to Exercises
6385 This section includes answers to all the exercises in the Calc tutorial.
6388 * RPN Answer 1:: 1 @key{RET} 2 @key{RET} 3 @key{RET} 4 + * -
6389 * RPN Answer 2:: 2*4 + 7*9.5 + 5/4
6390 * RPN Answer 3:: Operating on levels 2 and 3
6391 * RPN Answer 4:: Joe's complex problems
6392 * Algebraic Answer 1:: Simulating Q command
6393 * Algebraic Answer 2:: Joe's algebraic woes
6394 * Algebraic Answer 3:: 1 / 0
6395 * Modes Answer 1:: 3#0.1 = 3#0.0222222?
6396 * Modes Answer 2:: 16#f.e8fe15
6397 * Modes Answer 3:: Joe's rounding bug
6398 * Modes Answer 4:: Why floating point?
6399 * Arithmetic Answer 1:: Why the \ command?
6400 * Arithmetic Answer 2:: Tripping up the B command
6401 * Vector Answer 1:: Normalizing a vector
6402 * Vector Answer 2:: Average position
6403 * Matrix Answer 1:: Row and column sums
6404 * Matrix Answer 2:: Symbolic system of equations
6405 * Matrix Answer 3:: Over-determined system
6406 * List Answer 1:: Powers of two
6407 * List Answer 2:: Least-squares fit with matrices
6408 * List Answer 3:: Geometric mean
6409 * List Answer 4:: Divisor function
6410 * List Answer 5:: Duplicate factors
6411 * List Answer 6:: Triangular list
6412 * List Answer 7:: Another triangular list
6413 * List Answer 8:: Maximum of Bessel function
6414 * List Answer 9:: Integers the hard way
6415 * List Answer 10:: All elements equal
6416 * List Answer 11:: Estimating pi with darts
6417 * List Answer 12:: Estimating pi with matchsticks
6418 * List Answer 13:: Hash codes
6419 * List Answer 14:: Random walk
6420 * Types Answer 1:: Square root of pi times rational
6421 * Types Answer 2:: Infinities
6422 * Types Answer 3:: What can "nan" be?
6423 * Types Answer 4:: Abbey Road
6424 * Types Answer 5:: Friday the 13th
6425 * Types Answer 6:: Leap years
6426 * Types Answer 7:: Erroneous donut
6427 * Types Answer 8:: Dividing intervals
6428 * Types Answer 9:: Squaring intervals
6429 * Types Answer 10:: Fermat's primality test
6430 * Types Answer 11:: pi * 10^7 seconds
6431 * Types Answer 12:: Abbey Road on CD
6432 * Types Answer 13:: Not quite pi * 10^7 seconds
6433 * Types Answer 14:: Supercomputers and c
6434 * Types Answer 15:: Sam the Slug
6435 * Algebra Answer 1:: Squares and square roots
6436 * Algebra Answer 2:: Building polynomial from roots
6437 * Algebra Answer 3:: Integral of x sin(pi x)
6438 * Algebra Answer 4:: Simpson's rule
6439 * Rewrites Answer 1:: Multiplying by conjugate
6440 * Rewrites Answer 2:: Alternative fib rule
6441 * Rewrites Answer 3:: Rewriting opt(a) + opt(b) x
6442 * Rewrites Answer 4:: Sequence of integers
6443 * Rewrites Answer 5:: Number of terms in sum
6444 * Rewrites Answer 6:: Truncated Taylor series
6445 * Programming Answer 1:: Fresnel's C(x)
6446 * Programming Answer 2:: Negate third stack element
6447 * Programming Answer 3:: Compute sin(x) / x, etc.
6448 * Programming Answer 4:: Average value of a list
6449 * Programming Answer 5:: Continued fraction phi
6450 * Programming Answer 6:: Matrix Fibonacci numbers
6451 * Programming Answer 7:: Harmonic number greater than 4
6452 * Programming Answer 8:: Newton's method
6453 * Programming Answer 9:: Digamma function
6454 * Programming Answer 10:: Unpacking a polynomial
6455 * Programming Answer 11:: Recursive Stirling numbers
6456 * Programming Answer 12:: Stirling numbers with rewrites
6459 @c The following kludgery prevents the individual answers from
6460 @c being entered on the table of contents.
6462 \global\let\oldwrite=\write
6463 \gdef\skipwrite#1#2{\let\write=\oldwrite}
6464 \global\let\oldchapternofonts=\chapternofonts
6465 \gdef\chapternofonts{\let\write=\skipwrite\oldchapternofonts}
6468 @node RPN Answer 1, RPN Answer 2, Answers to Exercises, Answers to Exercises
6469 @subsection RPN Tutorial Exercise 1
6472 @kbd{1 @key{RET} 2 @key{RET} 3 @key{RET} 4 + * -}
6475 @texline @math{1 - (2 \times (3 + 4)) = -13}.
6476 @infoline @expr{1 - (2 * (3 + 4)) = -13}.
6478 @node RPN Answer 2, RPN Answer 3, RPN Answer 1, Answers to Exercises
6479 @subsection RPN Tutorial Exercise 2
6482 @texline @math{2\times4 + 7\times9.5 + {5\over4} = 75.75}
6483 @infoline @expr{2*4 + 7*9.5 + 5/4 = 75.75}
6485 After computing the intermediate term
6486 @texline @math{2\times4 = 8},
6487 @infoline @expr{2*4 = 8},
6488 you can leave that result on the stack while you compute the second
6489 term. With both of these results waiting on the stack you can then
6490 compute the final term, then press @kbd{+ +} to add everything up.
6499 2 @key{RET} 4 * 7 @key{RET} 9.5 *
6506 4: 8 3: 8 2: 8 1: 75.75
6507 3: 66.5 2: 66.5 1: 67.75 .
6516 Alternatively, you could add the first two terms before going on
6517 with the third term.
6521 2: 8 1: 74.5 3: 74.5 2: 74.5 1: 75.75
6522 1: 66.5 . 2: 5 1: 1.25 .
6526 ... + 5 @key{RET} 4 / +
6530 On an old-style RPN calculator this second method would have the
6531 advantage of using only three stack levels. But since Calc's stack
6532 can grow arbitrarily large this isn't really an issue. Which method
6533 you choose is purely a matter of taste.
6535 @node RPN Answer 3, RPN Answer 4, RPN Answer 2, Answers to Exercises
6536 @subsection RPN Tutorial Exercise 3
6539 The @key{TAB} key provides a way to operate on the number in level 2.
6543 3: 10 3: 10 4: 10 3: 10 3: 10
6544 2: 20 2: 30 3: 30 2: 30 2: 21
6545 1: 30 1: 20 2: 20 1: 21 1: 30
6549 @key{TAB} 1 + @key{TAB}
6553 Similarly, @kbd{M-@key{TAB}} gives you access to the number in level 3.
6557 3: 10 3: 21 3: 21 3: 30 3: 11
6558 2: 21 2: 30 2: 30 2: 11 2: 21
6559 1: 30 1: 10 1: 11 1: 21 1: 30
6562 M-@key{TAB} 1 + M-@key{TAB} M-@key{TAB}
6566 @node RPN Answer 4, Algebraic Answer 1, RPN Answer 3, Answers to Exercises
6567 @subsection RPN Tutorial Exercise 4
6570 Either @kbd{( 2 , 3 )} or @kbd{( 2 @key{SPC} 3 )} would have worked,
6571 but using both the comma and the space at once yields:
6575 1: ( ... 2: ( ... 1: (2, ... 2: (2, ... 2: (2, ...
6576 . 1: 2 . 1: (2, ... 1: (2, 3)
6583 Joe probably tried to type @kbd{@key{TAB} @key{DEL}} to swap the
6584 extra incomplete object to the top of the stack and delete it.
6585 But a feature of Calc is that @key{DEL} on an incomplete object
6586 deletes just one component out of that object, so he had to press
6587 @key{DEL} twice to finish the job.
6591 2: (2, ... 2: (2, 3) 2: (2, 3) 1: (2, 3)
6592 1: (2, 3) 1: (2, ... 1: ( ... .
6595 @key{TAB} @key{DEL} @key{DEL}
6599 (As it turns out, deleting the second-to-top stack entry happens often
6600 enough that Calc provides a special key, @kbd{M-@key{DEL}}, to do just that.
6601 @kbd{M-@key{DEL}} is just like @kbd{@key{TAB} @key{DEL}}, except that it doesn't exhibit
6602 the ``feature'' that tripped poor Joe.)
6604 @node Algebraic Answer 1, Algebraic Answer 2, RPN Answer 4, Answers to Exercises
6605 @subsection Algebraic Entry Tutorial Exercise 1
6608 Type @kbd{' sqrt($) @key{RET}}.
6610 If the @kbd{Q} key is broken, you could use @kbd{' $^0.5 @key{RET}}.
6611 Or, RPN style, @kbd{0.5 ^}.
6613 (Actually, @samp{$^1:2}, using the fraction one-half as the power, is
6614 a closer equivalent, since @samp{9^0.5} yields @expr{3.0} whereas
6615 @samp{sqrt(9)} and @samp{9^1:2} yield the exact integer @expr{3}.)
6617 @node Algebraic Answer 2, Algebraic Answer 3, Algebraic Answer 1, Answers to Exercises
6618 @subsection Algebraic Entry Tutorial Exercise 2
6621 In the formula @samp{2 x (1+y)}, @samp{x} was interpreted as a function
6622 name with @samp{1+y} as its argument. Assigning a value to a variable
6623 has no relation to a function by the same name. Joe needed to use an
6624 explicit @samp{*} symbol here: @samp{2 x*(1+y)}.
6626 @node Algebraic Answer 3, Modes Answer 1, Algebraic Answer 2, Answers to Exercises
6627 @subsection Algebraic Entry Tutorial Exercise 3
6630 The result from @kbd{1 @key{RET} 0 /} will be the formula @expr{1 / 0}.
6631 The ``function'' @samp{/} cannot be evaluated when its second argument
6632 is zero, so it is left in symbolic form. When you now type @kbd{0 *},
6633 the result will be zero because Calc uses the general rule that ``zero
6634 times anything is zero.''
6636 @c [fix-ref Infinities]
6637 The @kbd{m i} command enables an @dfn{Infinite mode} in which @expr{1 / 0}
6638 results in a special symbol that represents ``infinity.'' If you
6639 multiply infinity by zero, Calc uses another special new symbol to
6640 show that the answer is ``indeterminate.'' @xref{Infinities}, for
6641 further discussion of infinite and indeterminate values.
6643 @node Modes Answer 1, Modes Answer 2, Algebraic Answer 3, Answers to Exercises
6644 @subsection Modes Tutorial Exercise 1
6647 Calc always stores its numbers in decimal, so even though one-third has
6648 an exact base-3 representation (@samp{3#0.1}), it is still stored as
6649 0.3333333 (chopped off after 12 or however many decimal digits) inside
6650 the calculator's memory. When this inexact number is converted back
6651 to base 3 for display, it may still be slightly inexact. When we
6652 multiply this number by 3, we get 0.999999, also an inexact value.
6654 When Calc displays a number in base 3, it has to decide how many digits
6655 to show. If the current precision is 12 (decimal) digits, that corresponds
6656 to @samp{12 / log10(3) = 25.15} base-3 digits. Because 25.15 is not an
6657 exact integer, Calc shows only 25 digits, with the result that stored
6658 numbers carry a little bit of extra information that may not show up on
6659 the screen. When Joe entered @samp{3#0.2}, the stored number 0.666666
6660 happened to round to a pleasing value when it lost that last 0.15 of a
6661 digit, but it was still inexact in Calc's memory. When he divided by 2,
6662 he still got the dreaded inexact value 0.333333. (Actually, he divided
6663 0.666667 by 2 to get 0.333334, which is why he got something a little
6664 higher than @code{3#0.1} instead of a little lower.)
6666 If Joe didn't want to be bothered with all this, he could have typed
6667 @kbd{M-24 d n} to display with one less digit than the default. (If
6668 you give @kbd{d n} a negative argument, it uses default-minus-that,
6669 so @kbd{M-- d n} would be an easier way to get the same effect.) Those
6670 inexact results would still be lurking there, but they would now be
6671 rounded to nice, natural-looking values for display purposes. (Remember,
6672 @samp{0.022222} in base 3 is like @samp{0.099999} in base 10; rounding
6673 off one digit will round the number up to @samp{0.1}.) Depending on the
6674 nature of your work, this hiding of the inexactness may be a benefit or
6675 a danger. With the @kbd{d n} command, Calc gives you the choice.
6677 Incidentally, another consequence of all this is that if you type
6678 @kbd{M-30 d n} to display more digits than are ``really there,''
6679 you'll see garbage digits at the end of the number. (In decimal
6680 display mode, with decimally-stored numbers, these garbage digits are
6681 always zero so they vanish and you don't notice them.) Because Calc
6682 rounds off that 0.15 digit, there is the danger that two numbers could
6683 be slightly different internally but still look the same. If you feel
6684 uneasy about this, set the @kbd{d n} precision to be a little higher
6685 than normal; you'll get ugly garbage digits, but you'll always be able
6686 to tell two distinct numbers apart.
6688 An interesting side note is that most computers store their
6689 floating-point numbers in binary, and convert to decimal for display.
6690 Thus everyday programs have the same problem: Decimal 0.1 cannot be
6691 represented exactly in binary (try it: @kbd{0.1 d 2}), so @samp{0.1 * 10}
6692 comes out as an inexact approximation to 1 on some machines (though
6693 they generally arrange to hide it from you by rounding off one digit as
6694 we did above). Because Calc works in decimal instead of binary, you can
6695 be sure that numbers that look exact @emph{are} exact as long as you stay
6696 in decimal display mode.
6698 It's not hard to show that any number that can be represented exactly
6699 in binary, octal, or hexadecimal is also exact in decimal, so the kinds
6700 of problems we saw in this exercise are likely to be severe only when
6701 you use a relatively unusual radix like 3.
6703 @node Modes Answer 2, Modes Answer 3, Modes Answer 1, Answers to Exercises
6704 @subsection Modes Tutorial Exercise 2
6706 If the radix is 15 or higher, we can't use the letter @samp{e} to mark
6707 the exponent because @samp{e} is interpreted as a digit. When Calc
6708 needs to display scientific notation in a high radix, it writes
6709 @samp{16#F.E8F*16.^15}. You can enter a number like this as an
6710 algebraic entry. Also, pressing @kbd{e} without any digits before it
6711 normally types @kbd{1e}, but in a high radix it types @kbd{16.^} and
6712 puts you in algebraic entry: @kbd{16#f.e8f @key{RET} e 15 @key{RET} *} is another
6713 way to enter this number.
6715 The reason Calc puts a decimal point in the @samp{16.^} is to prevent
6716 huge integers from being generated if the exponent is large (consider
6717 @samp{16#1.23*16^1000}, where we compute @samp{16^1000} as a giant
6718 exact integer and then throw away most of the digits when we multiply
6719 it by the floating-point @samp{16#1.23}). While this wouldn't normally
6720 matter for display purposes, it could give you a nasty surprise if you
6721 copied that number into a file and later moved it back into Calc.
6723 @node Modes Answer 3, Modes Answer 4, Modes Answer 2, Answers to Exercises
6724 @subsection Modes Tutorial Exercise 3
6727 The answer he got was @expr{0.5000000000006399}.
6729 The problem is not that the square operation is inexact, but that the
6730 sine of 45 that was already on the stack was accurate to only 12 places.
6731 Arbitrary-precision calculations still only give answers as good as
6734 The real problem is that there is no 12-digit number which, when
6735 squared, comes out to 0.5 exactly. The @kbd{f [} and @kbd{f ]}
6736 commands decrease or increase a number by one unit in the last
6737 place (according to the current precision). They are useful for
6738 determining facts like this.
6742 1: 0.707106781187 1: 0.500000000001
6752 1: 0.707106781187 1: 0.707106781186 1: 0.499999999999
6759 A high-precision calculation must be carried out in high precision
6760 all the way. The only number in the original problem which was known
6761 exactly was the quantity 45 degrees, so the precision must be raised
6762 before anything is done after the number 45 has been entered in order
6763 for the higher precision to be meaningful.
6765 @node Modes Answer 4, Arithmetic Answer 1, Modes Answer 3, Answers to Exercises
6766 @subsection Modes Tutorial Exercise 4
6769 Many calculations involve real-world quantities, like the width and
6770 height of a piece of wood or the volume of a jar. Such quantities
6771 can't be measured exactly anyway, and if the data that is input to
6772 a calculation is inexact, doing exact arithmetic on it is a waste
6775 Fractions become unwieldy after too many calculations have been
6776 done with them. For example, the sum of the reciprocals of the
6777 integers from 1 to 10 is 7381:2520. The sum from 1 to 30 is
6778 9304682830147:2329089562800. After a point it will take a long
6779 time to add even one more term to this sum, but a floating-point
6780 calculation of the sum will not have this problem.
6782 Also, rational numbers cannot express the results of all calculations.
6783 There is no fractional form for the square root of two, so if you type
6784 @w{@kbd{2 Q}}, Calc has no choice but to give you a floating-point answer.
6786 @node Arithmetic Answer 1, Arithmetic Answer 2, Modes Answer 4, Answers to Exercises
6787 @subsection Arithmetic Tutorial Exercise 1
6790 Dividing two integers that are larger than the current precision may
6791 give a floating-point result that is inaccurate even when rounded
6792 down to an integer. Consider @expr{123456789 / 2} when the current
6793 precision is 6 digits. The true answer is @expr{61728394.5}, but
6794 with a precision of 6 this will be rounded to
6795 @texline @math{12345700.0/2.0 = 61728500.0}.
6796 @infoline @expr{12345700.@: / 2.@: = 61728500.}.
6797 The result, when converted to an integer, will be off by 106.
6799 Here are two solutions: Raise the precision enough that the
6800 floating-point round-off error is strictly to the right of the
6801 decimal point. Or, convert to Fraction mode so that @expr{123456789 / 2}
6802 produces the exact fraction @expr{123456789:2}, which can be rounded
6803 down by the @kbd{F} command without ever switching to floating-point
6806 @node Arithmetic Answer 2, Vector Answer 1, Arithmetic Answer 1, Answers to Exercises
6807 @subsection Arithmetic Tutorial Exercise 2
6810 @kbd{27 @key{RET} 9 B} could give the exact result @expr{3:2}, but it
6811 does a floating-point calculation instead and produces @expr{1.5}.
6813 Calc will find an exact result for a logarithm if the result is an integer
6814 or (when in Fraction mode) the reciprocal of an integer. But there is
6815 no efficient way to search the space of all possible rational numbers
6816 for an exact answer, so Calc doesn't try.
6818 @node Vector Answer 1, Vector Answer 2, Arithmetic Answer 2, Answers to Exercises
6819 @subsection Vector Tutorial Exercise 1
6822 Duplicate the vector, compute its length, then divide the vector
6823 by its length: @kbd{@key{RET} A /}.
6827 1: [1, 2, 3] 2: [1, 2, 3] 1: [0.27, 0.53, 0.80] 1: 1.
6828 . 1: 3.74165738677 . .
6835 The final @kbd{A} command shows that the normalized vector does
6836 indeed have unit length.
6838 @node Vector Answer 2, Matrix Answer 1, Vector Answer 1, Answers to Exercises
6839 @subsection Vector Tutorial Exercise 2
6842 The average position is equal to the sum of the products of the
6843 positions times their corresponding probabilities. This is the
6844 definition of the dot product operation. So all you need to do
6845 is to put the two vectors on the stack and press @kbd{*}.
6847 @node Matrix Answer 1, Matrix Answer 2, Vector Answer 2, Answers to Exercises
6848 @subsection Matrix Tutorial Exercise 1
6851 The trick is to multiply by a vector of ones. Use @kbd{r 4 [1 1 1] *} to
6852 get the row sum. Similarly, use @kbd{[1 1] r 4 *} to get the column sum.
6854 @node Matrix Answer 2, Matrix Answer 3, Matrix Answer 1, Answers to Exercises
6855 @subsection Matrix Tutorial Exercise 2
6867 $$ \eqalign{ x &+ a y = 6 \cr
6873 Just enter the righthand side vector, then divide by the lefthand side
6878 1: [6, 10] 2: [6, 10] 1: [6 - 4 a / (b - a), 4 / (b - a) ]
6883 ' [6 10] @key{RET} ' [1 a; 1 b] @key{RET} /
6887 This can be made more readable using @kbd{d B} to enable Big display
6893 1: [6 - -----, -----]
6898 Type @kbd{d N} to return to Normal display mode afterwards.
6900 @node Matrix Answer 3, List Answer 1, Matrix Answer 2, Answers to Exercises
6901 @subsection Matrix Tutorial Exercise 3
6905 @texline @math{A^T A \, X = A^T B},
6906 @infoline @expr{trn(A) * A * X = trn(A) * B},
6908 @texline @math{A' = A^T A}
6909 @infoline @expr{A2 = trn(A) * A}
6911 @texline @math{B' = A^T B};
6912 @infoline @expr{B2 = trn(A) * B};
6913 now, we have a system
6914 @texline @math{A' X = B'}
6915 @infoline @expr{A2 * X = B2}
6916 which we can solve using Calc's @samp{/} command.
6930 $$ \openup1\jot \tabskip=0pt plus1fil
6931 \halign to\displaywidth{\tabskip=0pt
6932 $\hfil#$&$\hfil{}#{}$&
6933 $\hfil#$&$\hfil{}#{}$&
6934 $\hfil#$&${}#\hfil$\tabskip=0pt plus1fil\cr
6938 2a&+&4b&+&6c&=11 \cr}
6943 The first step is to enter the coefficient matrix. We'll store it in
6944 quick variable number 7 for later reference. Next, we compute the
6951 1: [ [ 1, 2, 3 ] 2: [ [ 1, 4, 7, 2 ] 1: [57, 84, 96]
6952 [ 4, 5, 6 ] [ 2, 5, 6, 4 ] .
6953 [ 7, 6, 0 ] [ 3, 6, 0, 6 ] ]
6954 [ 2, 4, 6 ] ] 1: [6, 2, 3, 11]
6957 ' [1 2 3; 4 5 6; 7 6 0; 2 4 6] @key{RET} s 7 v t [6 2 3 11] *
6962 Now we compute the matrix
6969 2: [57, 84, 96] 1: [-11.64, 14.08, -3.64]
6970 1: [ [ 70, 72, 39 ] .
6980 (The actual computed answer will be slightly inexact due to
6983 Notice that the answers are similar to those for the
6984 @texline @math{3\times3}
6986 system solved in the text. That's because the fourth equation that was
6987 added to the system is almost identical to the first one multiplied
6988 by two. (If it were identical, we would have gotten the exact same
6990 @texline @math{4\times3}
6992 system would be equivalent to the original
6993 @texline @math{3\times3}
6997 Since the first and fourth equations aren't quite equivalent, they
6998 can't both be satisfied at once. Let's plug our answers back into
6999 the original system of equations to see how well they match.
7003 2: [-11.64, 14.08, -3.64] 1: [5.6, 2., 3., 11.2]
7015 This is reasonably close to our original @expr{B} vector,
7016 @expr{[6, 2, 3, 11]}.
7018 @node List Answer 1, List Answer 2, Matrix Answer 3, Answers to Exercises
7019 @subsection List Tutorial Exercise 1
7022 We can use @kbd{v x} to build a vector of integers. This needs to be
7023 adjusted to get the range of integers we desire. Mapping @samp{-}
7024 across the vector will accomplish this, although it turns out the
7025 plain @samp{-} key will work just as well.
7030 1: [1, 2, 3, 4, 5, 6, 7, 8, 9] 1: [-4, -3, -2, -1, 0, 1, 2, 3, 4]
7033 2 v x 9 @key{RET} 5 V M - or 5 -
7038 Now we use @kbd{V M ^} to map the exponentiation operator across the
7043 1: [0.0625, 0.125, 0.25, 0.5, 1, 2, 4, 8, 16]
7050 @node List Answer 2, List Answer 3, List Answer 1, Answers to Exercises
7051 @subsection List Tutorial Exercise 2
7054 Given @expr{x} and @expr{y} vectors in quick variables 1 and 2 as before,
7055 the first job is to form the matrix that describes the problem.
7064 $$ m \times x + b \times 1 = y $$
7069 @texline @math{19\times2}
7071 matrix with our @expr{x} vector as one column and
7072 ones as the other column. So, first we build the column of ones, then
7073 we combine the two columns to form our @expr{A} matrix.
7077 2: [1.34, 1.41, 1.49, ... ] 1: [ [ 1.34, 1 ]
7078 1: [1, 1, 1, ...] [ 1.41, 1 ]
7082 r 1 1 v b 19 @key{RET} M-2 v p v t s 3
7088 @texline @math{A^T y}
7089 @infoline @expr{trn(A) * y}
7091 @texline @math{A^T A}
7092 @infoline @expr{trn(A) * A}
7097 1: [33.36554, 13.613] 2: [33.36554, 13.613]
7098 . 1: [ [ 98.0003, 41.63 ]
7102 v t r 2 * r 3 v t r 3 *
7107 (Hey, those numbers look familiar!)
7111 1: [0.52141679, -0.425978]
7118 Since we were solving equations of the form
7119 @texline @math{m \times x + b \times 1 = y},
7120 @infoline @expr{m*x + b*1 = y},
7121 these numbers should be @expr{m} and @expr{b}, respectively. Sure
7122 enough, they agree exactly with the result computed using @kbd{V M} and
7125 The moral of this story: @kbd{V M} and @kbd{V R} will probably solve
7126 your problem, but there is often an easier way using the higher-level
7127 arithmetic functions!
7129 @c [fix-ref Curve Fitting]
7130 In fact, there is a built-in @kbd{a F} command that does least-squares
7131 fits. @xref{Curve Fitting}.
7133 @node List Answer 3, List Answer 4, List Answer 2, Answers to Exercises
7134 @subsection List Tutorial Exercise 3
7137 Move to one end of the list and press @kbd{C-@@} (or @kbd{C-@key{SPC}} or
7138 whatever) to set the mark, then move to the other end of the list
7139 and type @w{@kbd{C-x * g}}.
7143 1: [2.3, 6, 22, 15.1, 7, 15, 14, 7.5, 2.5]
7148 To make things interesting, let's assume we don't know at a glance
7149 how many numbers are in this list. Then we could type:
7153 2: [2.3, 6, 22, ... ] 2: [2.3, 6, 22, ... ]
7154 1: [2.3, 6, 22, ... ] 1: 126356422.5
7164 2: 126356422.5 2: 126356422.5 1: 7.94652913734
7165 1: [2.3, 6, 22, ... ] 1: 9 .
7173 (The @kbd{I ^} command computes the @var{n}th root of a number.
7174 You could also type @kbd{& ^} to take the reciprocal of 9 and
7175 then raise the number to that power.)
7177 @node List Answer 4, List Answer 5, List Answer 3, Answers to Exercises
7178 @subsection List Tutorial Exercise 4
7181 A number @expr{j} is a divisor of @expr{n} if
7182 @texline @math{n \mathbin{\hbox{\code{\%}}} j = 0}.
7183 @infoline @samp{n % j = 0}.
7184 The first step is to get a vector that identifies the divisors.
7188 2: 30 2: [0, 0, 0, 2, ...] 1: [1, 1, 1, 0, ...]
7189 1: [1, 2, 3, 4, ...] 1: 0 .
7192 30 @key{RET} v x 30 @key{RET} s 1 V M % 0 V M a = s 2
7197 This vector has 1's marking divisors of 30 and 0's marking non-divisors.
7199 The zeroth divisor function is just the total number of divisors.
7200 The first divisor function is the sum of the divisors.
7205 2: [1, 2, 3, 4, ...] 1: [1, 2, 3, 0, ...] 1: 72
7206 1: [1, 1, 1, 0, ...] . .
7209 V R + r 1 r 2 V M * V R +
7214 Once again, the last two steps just compute a dot product for which
7215 a simple @kbd{*} would have worked equally well.
7217 @node List Answer 5, List Answer 6, List Answer 4, Answers to Exercises
7218 @subsection List Tutorial Exercise 5
7221 The obvious first step is to obtain the list of factors with @kbd{k f}.
7222 This list will always be in sorted order, so if there are duplicates
7223 they will be right next to each other. A suitable method is to compare
7224 the list with a copy of itself shifted over by one.
7228 1: [3, 7, 7, 7, 19] 2: [3, 7, 7, 7, 19] 2: [3, 7, 7, 7, 19, 0]
7229 . 1: [3, 7, 7, 7, 19, 0] 1: [0, 3, 7, 7, 7, 19]
7232 19551 k f @key{RET} 0 | @key{TAB} 0 @key{TAB} |
7239 1: [0, 0, 1, 1, 0, 0] 1: 2 1: 0
7247 Note that we have to arrange for both vectors to have the same length
7248 so that the mapping operation works; no prime factor will ever be
7249 zero, so adding zeros on the left and right is safe. From then on
7250 the job is pretty straightforward.
7252 Incidentally, Calc provides the
7253 @texline @dfn{M@"obius} @math{\mu}
7254 @infoline @dfn{Moebius mu}
7255 function which is zero if and only if its argument is square-free. It
7256 would be a much more convenient way to do the above test in practice.
7258 @node List Answer 6, List Answer 7, List Answer 5, Answers to Exercises
7259 @subsection List Tutorial Exercise 6
7262 First use @kbd{v x 6 @key{RET}} to get a list of integers, then @kbd{V M v x}
7263 to get a list of lists of integers!
7265 @node List Answer 7, List Answer 8, List Answer 6, Answers to Exercises
7266 @subsection List Tutorial Exercise 7
7269 Here's one solution. First, compute the triangular list from the previous
7270 exercise and type @kbd{1 -} to subtract one from all the elements.
7283 The numbers down the lefthand edge of the list we desire are called
7284 the ``triangular numbers'' (now you know why!). The @expr{n}th
7285 triangular number is the sum of the integers from 1 to @expr{n}, and
7286 can be computed directly by the formula
7287 @texline @math{n (n+1) \over 2}.
7288 @infoline @expr{n * (n+1) / 2}.
7292 2: [ [0], [0, 1], ... ] 2: [ [0], [0, 1], ... ]
7293 1: [0, 1, 2, 3, 4, 5] 1: [0, 1, 3, 6, 10, 15]
7296 v x 6 @key{RET} 1 - V M ' $ ($+1)/2 @key{RET}
7301 Adding this list to the above list of lists produces the desired
7310 [10, 11, 12, 13, 14],
7311 [15, 16, 17, 18, 19, 20] ]
7318 If we did not know the formula for triangular numbers, we could have
7319 computed them using a @kbd{V U +} command. We could also have
7320 gotten them the hard way by mapping a reduction across the original
7325 2: [ [0], [0, 1], ... ] 2: [ [0], [0, 1], ... ]
7326 1: [ [0], [0, 1], ... ] 1: [0, 1, 3, 6, 10, 15]
7334 (This means ``map a @kbd{V R +} command across the vector,'' and
7335 since each element of the main vector is itself a small vector,
7336 @kbd{V R +} computes the sum of its elements.)
7338 @node List Answer 8, List Answer 9, List Answer 7, Answers to Exercises
7339 @subsection List Tutorial Exercise 8
7342 The first step is to build a list of values of @expr{x}.
7346 1: [1, 2, 3, ..., 21] 1: [0, 1, 2, ..., 20] 1: [0, 0.25, 0.5, ..., 5]
7349 v x 21 @key{RET} 1 - 4 / s 1
7353 Next, we compute the Bessel function values.
7357 1: [0., 0.124, 0.242, ..., -0.328]
7360 V M ' besJ(1,$) @key{RET}
7365 (Another way to do this would be @kbd{1 @key{TAB} V M f j}.)
7367 A way to isolate the maximum value is to compute the maximum using
7368 @kbd{V R X}, then compare all the Bessel values with that maximum.
7372 2: [0., 0.124, 0.242, ... ] 1: [0, 0, 0, ... ] 2: [0, 0, 0, ... ]
7376 @key{RET} V R X V M a = @key{RET} V R + @key{DEL}
7381 It's a good idea to verify, as in the last step above, that only
7382 one value is equal to the maximum. (After all, a plot of
7383 @texline @math{\sin x}
7384 @infoline @expr{sin(x)}
7385 might have many points all equal to the maximum value, 1.)
7387 The vector we have now has a single 1 in the position that indicates
7388 the maximum value of @expr{x}. Now it is a simple matter to convert
7389 this back into the corresponding value itself.
7393 2: [0, 0, 0, ... ] 1: [0, 0., 0., ... ] 1: 1.75
7394 1: [0, 0.25, 0.5, ... ] . .
7401 If @kbd{a =} had produced more than one @expr{1} value, this method
7402 would have given the sum of all maximum @expr{x} values; not very
7403 useful! In this case we could have used @kbd{v m} (@code{calc-mask-vector})
7404 instead. This command deletes all elements of a ``data'' vector that
7405 correspond to zeros in a ``mask'' vector, leaving us with, in this
7406 example, a vector of maximum @expr{x} values.
7408 The built-in @kbd{a X} command maximizes a function using more
7409 efficient methods. Just for illustration, let's use @kbd{a X}
7410 to maximize @samp{besJ(1,x)} over this same interval.
7414 2: besJ(1, x) 1: [1.84115, 0.581865]
7418 ' besJ(1,x), [0..5] @key{RET} a X x @key{RET}
7423 The output from @kbd{a X} is a vector containing the value of @expr{x}
7424 that maximizes the function, and the function's value at that maximum.
7425 As you can see, our simple search got quite close to the right answer.
7427 @node List Answer 9, List Answer 10, List Answer 8, Answers to Exercises
7428 @subsection List Tutorial Exercise 9
7431 Step one is to convert our integer into vector notation.
7435 1: 25129925999 3: 25129925999
7437 1: [11, 10, 9, ..., 1, 0]
7440 25129925999 @key{RET} 10 @key{RET} 12 @key{RET} v x 12 @key{RET} -
7447 1: 25129925999 1: [0, 2, 25, 251, 2512, ... ]
7448 2: [100000000000, ... ] .
7456 (Recall, the @kbd{\} command computes an integer quotient.)
7460 1: [0, 2, 5, 1, 2, 9, 9, 2, 5, 9, 9, 9]
7467 Next we must increment this number. This involves adding one to
7468 the last digit, plus handling carries. There is a carry to the
7469 left out of a digit if that digit is a nine and all the digits to
7470 the right of it are nines.
7474 1: [0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1] 1: [1, 1, 1, 0, 0, 1, ... ]
7484 1: [1, 1, 1, 0, 0, 0, ... ] 1: [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1]
7492 Accumulating @kbd{*} across a vector of ones and zeros will preserve
7493 only the initial run of ones. These are the carries into all digits
7494 except the rightmost digit. Concatenating a one on the right takes
7495 care of aligning the carries properly, and also adding one to the
7500 2: [0, 0, 0, 0, ... ] 1: [0, 0, 2, 5, 1, 2, 9, 9, 2, 6, 0, 0, 0]
7501 1: [0, 0, 2, 5, ... ] .
7504 0 r 2 | V M + 10 V M %
7509 Here we have concatenated 0 to the @emph{left} of the original number;
7510 this takes care of shifting the carries by one with respect to the
7511 digits that generated them.
7513 Finally, we must convert this list back into an integer.
7517 3: [0, 0, 2, 5, ... ] 2: [0, 0, 2, 5, ... ]
7518 2: 1000000000000 1: [1000000000000, 100000000000, ... ]
7519 1: [100000000000, ... ] .
7522 10 @key{RET} 12 ^ r 1 |
7529 1: [0, 0, 20000000000, 5000000000, ... ] 1: 25129926000
7537 Another way to do this final step would be to reduce the formula
7538 @w{@samp{10 $$ + $}} across the vector of digits.
7542 1: [0, 0, 2, 5, ... ] 1: 25129926000
7545 V R ' 10 $$ + $ @key{RET}
7549 @node List Answer 10, List Answer 11, List Answer 9, Answers to Exercises
7550 @subsection List Tutorial Exercise 10
7553 For the list @expr{[a, b, c, d]}, the result is @expr{((a = b) = c) = d},
7554 which will compare @expr{a} and @expr{b} to produce a 1 or 0, which is
7555 then compared with @expr{c} to produce another 1 or 0, which is then
7556 compared with @expr{d}. This is not at all what Joe wanted.
7558 Here's a more correct method:
7562 1: [7, 7, 7, 8, 7] 2: [7, 7, 7, 8, 7]
7566 ' [7,7,7,8,7] @key{RET} @key{RET} v r 1 @key{RET}
7573 1: [1, 1, 1, 0, 1] 1: 0
7580 @node List Answer 11, List Answer 12, List Answer 10, Answers to Exercises
7581 @subsection List Tutorial Exercise 11
7584 The circle of unit radius consists of those points @expr{(x,y)} for which
7585 @expr{x^2 + y^2 < 1}. We start by generating a vector of @expr{x^2}
7586 and a vector of @expr{y^2}.
7588 We can make this go a bit faster by using the @kbd{v .} and @kbd{t .}
7593 2: [2., 2., ..., 2.] 2: [2., 2., ..., 2.]
7594 1: [2., 2., ..., 2.] 1: [1.16, 1.98, ..., 0.81]
7597 v . t . 2. v b 100 @key{RET} @key{RET} V M k r
7604 2: [2., 2., ..., 2.] 1: [0.026, 0.96, ..., 0.036]
7605 1: [0.026, 0.96, ..., 0.036] 2: [0.53, 0.81, ..., 0.094]
7608 1 - 2 V M ^ @key{TAB} V M k r 1 - 2 V M ^
7612 Now we sum the @expr{x^2} and @expr{y^2} values, compare with 1 to
7613 get a vector of 1/0 truth values, then sum the truth values.
7617 1: [0.56, 1.78, ..., 0.13] 1: [1, 0, ..., 1] 1: 84
7625 The ratio @expr{84/100} should approximate the ratio @cpiover{4}.
7629 1: 0.84 1: 3.36 2: 3.36 1: 1.0695
7637 Our estimate, 3.36, is off by about 7%. We could get a better estimate
7638 by taking more points (say, 1000), but it's clear that this method is
7641 (Naturally, since this example uses random numbers your own answer
7642 will be slightly different from the one shown here!)
7644 If you typed @kbd{v .} and @kbd{t .} before, type them again to
7645 return to full-sized display of vectors.
7647 @node List Answer 12, List Answer 13, List Answer 11, Answers to Exercises
7648 @subsection List Tutorial Exercise 12
7651 This problem can be made a lot easier by taking advantage of some
7652 symmetries. First of all, after some thought it's clear that the
7653 @expr{y} axis can be ignored altogether. Just pick a random @expr{x}
7654 component for one end of the match, pick a random direction
7655 @texline @math{\theta},
7656 @infoline @expr{theta},
7657 and see if @expr{x} and
7658 @texline @math{x + \cos \theta}
7659 @infoline @expr{x + cos(theta)}
7660 (which is the @expr{x} coordinate of the other endpoint) cross a line.
7661 The lines are at integer coordinates, so this happens when the two
7662 numbers surround an integer.
7664 Since the two endpoints are equivalent, we may as well choose the leftmost
7665 of the two endpoints as @expr{x}. Then @expr{theta} is an angle pointing
7666 to the right, in the range -90 to 90 degrees. (We could use radians, but
7667 it would feel like cheating to refer to @cpiover{2} radians while trying
7668 to estimate @cpi{}!)
7670 In fact, since the field of lines is infinite we can choose the
7671 coordinates 0 and 1 for the lines on either side of the leftmost
7672 endpoint. The rightmost endpoint will be between 0 and 1 if the
7673 match does not cross a line, or between 1 and 2 if it does. So:
7674 Pick random @expr{x} and
7675 @texline @math{\theta},
7676 @infoline @expr{theta},
7678 @texline @math{x + \cos \theta},
7679 @infoline @expr{x + cos(theta)},
7680 and count how many of the results are greater than one. Simple!
7682 We can make this go a bit faster by using the @kbd{v .} and @kbd{t .}
7687 1: [0.52, 0.71, ..., 0.72] 2: [0.52, 0.71, ..., 0.72]
7688 . 1: [78.4, 64.5, ..., -42.9]
7691 v . t . 1. v b 100 @key{RET} V M k r 180. v b 100 @key{RET} V M k r 90 -
7696 (The next step may be slow, depending on the speed of your computer.)
7700 2: [0.52, 0.71, ..., 0.72] 1: [0.72, 1.14, ..., 1.45]
7701 1: [0.20, 0.43, ..., 0.73] .
7711 1: [0, 1, ..., 1] 1: 0.64 1: 3.125
7714 1 V M a > V R + 100 / 2 @key{TAB} /
7718 Let's try the third method, too. We'll use random integers up to
7719 one million. The @kbd{k r} command with an integer argument picks
7724 2: [1000000, 1000000, ..., 1000000] 2: [78489, 527587, ..., 814975]
7725 1: [1000000, 1000000, ..., 1000000] 1: [324014, 358783, ..., 955450]
7728 1000000 v b 100 @key{RET} @key{RET} V M k r @key{TAB} V M k r
7735 1: [1, 1, ..., 25] 1: [1, 1, ..., 0] 1: 0.56
7738 V M k g 1 V M a = V R + 100 /
7752 For a proof of this property of the GCD function, see section 4.5.2,
7753 exercise 10, of Knuth's @emph{Art of Computer Programming}, volume II.
7755 If you typed @kbd{v .} and @kbd{t .} before, type them again to
7756 return to full-sized display of vectors.
7758 @node List Answer 13, List Answer 14, List Answer 12, Answers to Exercises
7759 @subsection List Tutorial Exercise 13
7762 First, we put the string on the stack as a vector of ASCII codes.
7766 1: [84, 101, 115, ..., 51]
7769 "Testing, 1, 2, 3 @key{RET}
7774 Note that the @kbd{"} key, like @kbd{$}, initiates algebraic entry so
7775 there was no need to type an apostrophe. Also, Calc didn't mind that
7776 we omitted the closing @kbd{"}. (The same goes for all closing delimiters
7777 like @kbd{)} and @kbd{]} at the end of a formula.
7779 We'll show two different approaches here. In the first, we note that
7780 if the input vector is @expr{[a, b, c, d]}, then the hash code is
7781 @expr{3 (3 (3a + b) + c) + d = 27a + 9b + 3c + d}. In other words,
7782 it's a sum of descending powers of three times the ASCII codes.
7786 2: [84, 101, 115, ..., 51] 2: [84, 101, 115, ..., 51]
7787 1: 16 1: [15, 14, 13, ..., 0]
7790 @key{RET} v l v x 16 @key{RET} -
7797 2: [84, 101, 115, ..., 51] 1: 1960915098 1: 121
7798 1: [14348907, ..., 1] . .
7801 3 @key{TAB} V M ^ * 511 %
7806 Once again, @kbd{*} elegantly summarizes most of the computation.
7807 But there's an even more elegant approach: Reduce the formula
7808 @kbd{3 $$ + $} across the vector. Recall that this represents a
7809 function of two arguments that computes its first argument times three
7810 plus its second argument.
7814 1: [84, 101, 115, ..., 51] 1: 1960915098
7817 "Testing, 1, 2, 3 @key{RET} V R ' 3$$+$ @key{RET}
7822 If you did the decimal arithmetic exercise, this will be familiar.
7823 Basically, we're turning a base-3 vector of digits into an integer,
7824 except that our ``digits'' are much larger than real digits.
7826 Instead of typing @kbd{511 %} again to reduce the result, we can be
7827 cleverer still and notice that rather than computing a huge integer
7828 and taking the modulo at the end, we can take the modulo at each step
7829 without affecting the result. While this means there are more
7830 arithmetic operations, the numbers we operate on remain small so
7831 the operations are faster.
7835 1: [84, 101, 115, ..., 51] 1: 121
7838 "Testing, 1, 2, 3 @key{RET} V R ' (3$$+$)%511 @key{RET}
7842 Why does this work? Think about a two-step computation:
7843 @w{@expr{3 (3a + b) + c}}. Taking a result modulo 511 basically means
7844 subtracting off enough 511's to put the result in the desired range.
7845 So the result when we take the modulo after every step is,
7849 3 (3 a + b - 511 m) + c - 511 n
7854 $$ 3 (3 a + b - 511 m) + c - 511 n $$
7859 for some suitable integers @expr{m} and @expr{n}. Expanding out by
7860 the distributive law yields
7864 9 a + 3 b + c - 511*3 m - 511 n
7869 $$ 9 a + 3 b + c - 511\times3 m - 511 n $$
7874 The @expr{m} term in the latter formula is redundant because any
7875 contribution it makes could just as easily be made by the @expr{n}
7876 term. So we can take it out to get an equivalent formula with
7881 9 a + 3 b + c - 511 n'
7886 $$ 9 a + 3 b + c - 511 n^{\prime} $$
7891 which is just the formula for taking the modulo only at the end of
7892 the calculation. Therefore the two methods are essentially the same.
7894 Later in the tutorial we will encounter @dfn{modulo forms}, which
7895 basically automate the idea of reducing every intermediate result
7896 modulo some value @var{m}.
7898 @node List Answer 14, Types Answer 1, List Answer 13, Answers to Exercises
7899 @subsection List Tutorial Exercise 14
7901 We want to use @kbd{H V U} to nest a function which adds a random
7902 step to an @expr{(x,y)} coordinate. The function is a bit long, but
7903 otherwise the problem is quite straightforward.
7907 2: [0, 0] 1: [ [ 0, 0 ]
7908 1: 50 [ 0.4288, -0.1695 ]
7909 . [ -0.4787, -0.9027 ]
7912 [0,0] 50 H V U ' <# + [random(2.0)-1, random(2.0)-1]> @key{RET}
7916 Just as the text recommended, we used @samp{< >} nameless function
7917 notation to keep the two @code{random} calls from being evaluated
7918 before nesting even begins.
7920 We now have a vector of @expr{[x, y]} sub-vectors, which by Calc's
7921 rules acts like a matrix. We can transpose this matrix and unpack
7922 to get a pair of vectors, @expr{x} and @expr{y}, suitable for graphing.
7926 2: [ 0, 0.4288, -0.4787, ... ]
7927 1: [ 0, -0.1696, -0.9027, ... ]
7934 Incidentally, because the @expr{x} and @expr{y} are completely
7935 independent in this case, we could have done two separate commands
7936 to create our @expr{x} and @expr{y} vectors of numbers directly.
7938 To make a random walk of unit steps, we note that @code{sincos} of
7939 a random direction exactly gives us an @expr{[x, y]} step of unit
7940 length; in fact, the new nesting function is even briefer, though
7941 we might want to lower the precision a bit for it.
7945 2: [0, 0] 1: [ [ 0, 0 ]
7946 1: 50 [ 0.1318, 0.9912 ]
7947 . [ -0.5965, 0.3061 ]
7950 [0,0] 50 m d p 6 @key{RET} H V U ' <# + sincos(random(360.0))> @key{RET}
7954 Another @kbd{v t v u g f} sequence will graph this new random walk.
7956 An interesting twist on these random walk functions would be to use
7957 complex numbers instead of 2-vectors to represent points on the plane.
7958 In the first example, we'd use something like @samp{random + random*(0,1)},
7959 and in the second we could use polar complex numbers with random phase
7960 angles. (This exercise was first suggested in this form by Randal
7963 @node Types Answer 1, Types Answer 2, List Answer 14, Answers to Exercises
7964 @subsection Types Tutorial Exercise 1
7967 If the number is the square root of @cpi{} times a rational number,
7968 then its square, divided by @cpi{}, should be a rational number.
7972 1: 1.26508260337 1: 0.509433962268 1: 2486645810:4881193627
7980 Technically speaking this is a rational number, but not one that is
7981 likely to have arisen in the original problem. More likely, it just
7982 happens to be the fraction which most closely represents some
7983 irrational number to within 12 digits.
7985 But perhaps our result was not quite exact. Let's reduce the
7986 precision slightly and try again:
7990 1: 0.509433962268 1: 27:53
7993 U p 10 @key{RET} c F
7998 Aha! It's unlikely that an irrational number would equal a fraction
7999 this simple to within ten digits, so our original number was probably
8000 @texline @math{\sqrt{27 \pi / 53}}.
8001 @infoline @expr{sqrt(27 pi / 53)}.
8003 Notice that we didn't need to re-round the number when we reduced the
8004 precision. Remember, arithmetic operations always round their inputs
8005 to the current precision before they begin.
8007 @node Types Answer 2, Types Answer 3, Types Answer 1, Answers to Exercises
8008 @subsection Types Tutorial Exercise 2
8011 @samp{inf / inf = nan}. Perhaps @samp{1} is the ``obvious'' answer.
8012 But if @w{@samp{17 inf = inf}}, then @samp{17 inf / inf = inf / inf = 17}, too.
8014 @samp{exp(inf) = inf}. It's tempting to say that the exponential
8015 of infinity must be ``bigger'' than ``regular'' infinity, but as
8016 far as Calc is concerned all infinities are the same size.
8017 In other words, as @expr{x} goes to infinity, @expr{e^x} also goes
8018 to infinity, but the fact the @expr{e^x} grows much faster than
8019 @expr{x} is not relevant here.
8021 @samp{exp(-inf) = 0}. Here we have a finite answer even though
8022 the input is infinite.
8024 @samp{sqrt(-inf) = (0, 1) inf}. Remember that @expr{(0, 1)}
8025 represents the imaginary number @expr{i}. Here's a derivation:
8026 @samp{sqrt(-inf) = @w{sqrt((-1) * inf)} = sqrt(-1) * sqrt(inf)}.
8027 The first part is, by definition, @expr{i}; the second is @code{inf}
8028 because, once again, all infinities are the same size.
8030 @samp{sqrt(uinf) = uinf}. In fact, we do know something about the
8031 direction because @code{sqrt} is defined to return a value in the
8032 right half of the complex plane. But Calc has no notation for this,
8033 so it settles for the conservative answer @code{uinf}.
8035 @samp{abs(uinf) = inf}. No matter which direction @expr{x} points,
8036 @samp{abs(x)} always points along the positive real axis.
8038 @samp{ln(0) = -inf}. Here we have an infinite answer to a finite
8039 input. As in the @expr{1 / 0} case, Calc will only use infinities
8040 here if you have turned on Infinite mode. Otherwise, it will
8041 treat @samp{ln(0)} as an error.
8043 @node Types Answer 3, Types Answer 4, Types Answer 2, Answers to Exercises
8044 @subsection Types Tutorial Exercise 3
8047 We can make @samp{inf - inf} be any real number we like, say,
8048 @expr{a}, just by claiming that we added @expr{a} to the first
8049 infinity but not to the second. This is just as true for complex
8050 values of @expr{a}, so @code{nan} can stand for a complex number.
8051 (And, similarly, @code{uinf} can stand for an infinity that points
8052 in any direction in the complex plane, such as @samp{(0, 1) inf}).
8054 In fact, we can multiply the first @code{inf} by two. Surely
8055 @w{@samp{2 inf - inf = inf}}, but also @samp{2 inf - inf = inf - inf = nan}.
8056 So @code{nan} can even stand for infinity. Obviously it's just
8057 as easy to make it stand for minus infinity as for plus infinity.
8059 The moral of this story is that ``infinity'' is a slippery fish
8060 indeed, and Calc tries to handle it by having a very simple model
8061 for infinities (only the direction counts, not the ``size''); but
8062 Calc is careful to write @code{nan} any time this simple model is
8063 unable to tell what the true answer is.
8065 @node Types Answer 4, Types Answer 5, Types Answer 3, Answers to Exercises
8066 @subsection Types Tutorial Exercise 4
8070 2: 0@@ 47' 26" 1: 0@@ 2' 47.411765"
8074 0@@ 47' 26" @key{RET} 17 /
8079 The average song length is two minutes and 47.4 seconds.
8083 2: 0@@ 2' 47.411765" 1: 0@@ 3' 7.411765" 1: 0@@ 53' 6.000005"
8092 The album would be 53 minutes and 6 seconds long.
8094 @node Types Answer 5, Types Answer 6, Types Answer 4, Answers to Exercises
8095 @subsection Types Tutorial Exercise 5
8098 Let's suppose it's January 14, 1991. The easiest thing to do is
8099 to keep trying 13ths of months until Calc reports a Friday.
8100 We can do this by manually entering dates, or by using @kbd{t I}:
8104 1: <Wed Feb 13, 1991> 1: <Wed Mar 13, 1991> 1: <Sat Apr 13, 1991>
8107 ' <2/13> @key{RET} @key{DEL} ' <3/13> @key{RET} t I
8112 (Calc assumes the current year if you don't say otherwise.)
8114 This is getting tedious---we can keep advancing the date by typing
8115 @kbd{t I} over and over again, but let's automate the job by using
8116 vector mapping. The @kbd{t I} command actually takes a second
8117 ``how-many-months'' argument, which defaults to one. This
8118 argument is exactly what we want to map over:
8122 2: <Sat Apr 13, 1991> 1: [<Mon May 13, 1991>, <Thu Jun 13, 1991>,
8123 1: [1, 2, 3, 4, 5, 6] <Sat Jul 13, 1991>, <Tue Aug 13, 1991>,
8124 . <Fri Sep 13, 1991>, <Sun Oct 13, 1991>]
8127 v x 6 @key{RET} V M t I
8132 Et voil@`a, September 13, 1991 is a Friday.
8139 ' <sep 13> - <jan 14> @key{RET}
8144 And the answer to our original question: 242 days to go.
8146 @node Types Answer 6, Types Answer 7, Types Answer 5, Answers to Exercises
8147 @subsection Types Tutorial Exercise 6
8150 The full rule for leap years is that they occur in every year divisible
8151 by four, except that they don't occur in years divisible by 100, except
8152 that they @emph{do} in years divisible by 400. We could work out the
8153 answer by carefully counting the years divisible by four and the
8154 exceptions, but there is a much simpler way that works even if we
8155 don't know the leap year rule.
8157 Let's assume the present year is 1991. Years have 365 days, except
8158 that leap years (whenever they occur) have 366 days. So let's count
8159 the number of days between now and then, and compare that to the
8160 number of years times 365. The number of extra days we find must be
8161 equal to the number of leap years there were.
8165 1: <Mon Jan 1, 10001> 2: <Mon Jan 1, 10001> 1: 2925593
8166 . 1: <Tue Jan 1, 1991> .
8169 ' <jan 1 10001> @key{RET} ' <jan 1 1991> @key{RET} -
8176 3: 2925593 2: 2925593 2: 2925593 1: 1943
8177 2: 10001 1: 8010 1: 2923650 .
8181 10001 @key{RET} 1991 - 365 * -
8185 @c [fix-ref Date Forms]
8187 There will be 1943 leap years before the year 10001. (Assuming,
8188 of course, that the algorithm for computing leap years remains
8189 unchanged for that long. @xref{Date Forms}, for some interesting
8190 background information in that regard.)
8192 @node Types Answer 7, Types Answer 8, Types Answer 6, Answers to Exercises
8193 @subsection Types Tutorial Exercise 7
8196 The relative errors must be converted to absolute errors so that
8197 @samp{+/-} notation may be used.
8205 20 @key{RET} .05 * 4 @key{RET} .05 *
8209 Now we simply chug through the formula.
8213 1: 19.7392088022 1: 394.78 +/- 19.739 1: 6316.5 +/- 706.21
8216 2 P 2 ^ * 20 p 1 * 4 p .2 @key{RET} 2 ^ *
8220 It turns out the @kbd{v u} command will unpack an error form as
8221 well as a vector. This saves us some retyping of numbers.
8225 3: 6316.5 +/- 706.21 2: 6316.5 +/- 706.21
8230 @key{RET} v u @key{TAB} /
8235 Thus the volume is 6316 cubic centimeters, within about 11 percent.
8237 @node Types Answer 8, Types Answer 9, Types Answer 7, Answers to Exercises
8238 @subsection Types Tutorial Exercise 8
8241 The first answer is pretty simple: @samp{1 / (0 .. 10) = (0.1 .. inf)}.
8242 Since a number in the interval @samp{(0 .. 10)} can get arbitrarily
8243 close to zero, its reciprocal can get arbitrarily large, so the answer
8244 is an interval that effectively means, ``any number greater than 0.1''
8245 but with no upper bound.
8247 The second answer, similarly, is @samp{1 / (-10 .. 0) = (-inf .. -0.1)}.
8249 Calc normally treats division by zero as an error, so that the formula
8250 @w{@samp{1 / 0}} is left unsimplified. Our third problem,
8251 @w{@samp{1 / [0 .. 10]}}, also (potentially) divides by zero because zero
8252 is now a member of the interval. So Calc leaves this one unevaluated, too.
8254 If you turn on Infinite mode by pressing @kbd{m i}, you will
8255 instead get the answer @samp{[0.1 .. inf]}, which includes infinity
8256 as a possible value.
8258 The fourth calculation, @samp{1 / (-10 .. 10)}, has the same problem.
8259 Zero is buried inside the interval, but it's still a possible value.
8260 It's not hard to see that the actual result of @samp{1 / (-10 .. 10)}
8261 will be either greater than @mathit{0.1}, or less than @mathit{-0.1}. Thus
8262 the interval goes from minus infinity to plus infinity, with a ``hole''
8263 in it from @mathit{-0.1} to @mathit{0.1}. Calc doesn't have any way to
8264 represent this, so it just reports @samp{[-inf .. inf]} as the answer.
8265 It may be disappointing to hear ``the answer lies somewhere between
8266 minus infinity and plus infinity, inclusive,'' but that's the best
8267 that interval arithmetic can do in this case.
8269 @node Types Answer 9, Types Answer 10, Types Answer 8, Answers to Exercises
8270 @subsection Types Tutorial Exercise 9
8274 1: [-3 .. 3] 2: [-3 .. 3] 2: [0 .. 9]
8275 . 1: [0 .. 9] 1: [-9 .. 9]
8278 [ 3 n .. 3 ] @key{RET} 2 ^ @key{TAB} @key{RET} *
8283 In the first case the result says, ``if a number is between @mathit{-3} and
8284 3, its square is between 0 and 9.'' The second case says, ``the product
8285 of two numbers each between @mathit{-3} and 3 is between @mathit{-9} and 9.''
8287 An interval form is not a number; it is a symbol that can stand for
8288 many different numbers. Two identical-looking interval forms can stand
8289 for different numbers.
8291 The same issue arises when you try to square an error form.
8293 @node Types Answer 10, Types Answer 11, Types Answer 9, Answers to Exercises
8294 @subsection Types Tutorial Exercise 10
8297 Testing the first number, we might arbitrarily choose 17 for @expr{x}.
8301 1: 17 mod 811749613 2: 17 mod 811749613 1: 533694123 mod 811749613
8305 17 M 811749613 @key{RET} 811749612 ^
8310 Since 533694123 is (considerably) different from 1, the number 811749613
8313 It's awkward to type the number in twice as we did above. There are
8314 various ways to avoid this, and algebraic entry is one. In fact, using
8315 a vector mapping operation we can perform several tests at once. Let's
8316 use this method to test the second number.
8320 2: [17, 42, 100000] 1: [1 mod 15485863, 1 mod ... ]
8324 [17 42 100000] 15485863 @key{RET} V M ' ($$ mod $)^($-1) @key{RET}
8329 The result is three ones (modulo @expr{n}), so it's very probable that
8330 15485863 is prime. (In fact, this number is the millionth prime.)
8332 Note that the functions @samp{($$^($-1)) mod $} or @samp{$$^($-1) % $}
8333 would have been hopelessly inefficient, since they would have calculated
8334 the power using full integer arithmetic.
8336 Calc has a @kbd{k p} command that does primality testing. For small
8337 numbers it does an exact test; for large numbers it uses a variant
8338 of the Fermat test we used here. You can use @kbd{k p} repeatedly
8339 to prove that a large integer is prime with any desired probability.
8341 @node Types Answer 11, Types Answer 12, Types Answer 10, Answers to Exercises
8342 @subsection Types Tutorial Exercise 11
8345 There are several ways to insert a calculated number into an HMS form.
8346 One way to convert a number of seconds to an HMS form is simply to
8347 multiply the number by an HMS form representing one second:
8351 1: 31415926.5359 2: 31415926.5359 1: 8726@@ 38' 46.5359"
8362 2: 8726@@ 38' 46.5359" 1: 6@@ 6' 2.5359" mod 24@@ 0' 0"
8363 1: 15@@ 27' 16" mod 24@@ 0' 0" .
8371 It will be just after six in the morning.
8373 The algebraic @code{hms} function can also be used to build an
8378 1: hms(0, 0, 10000000. pi) 1: 8726@@ 38' 46.5359"
8381 ' hms(0, 0, 1e7 pi) @key{RET} =
8386 The @kbd{=} key is necessary to evaluate the symbol @samp{pi} to
8387 the actual number 3.14159...
8389 @node Types Answer 12, Types Answer 13, Types Answer 11, Answers to Exercises
8390 @subsection Types Tutorial Exercise 12
8393 As we recall, there are 17 songs of about 2 minutes and 47 seconds
8398 2: 0@@ 2' 47" 1: [0@@ 3' 7" .. 0@@ 3' 47"]
8399 1: [0@@ 0' 20" .. 0@@ 1' 0"] .
8402 [ 0@@ 20" .. 0@@ 1' ] +
8409 1: [0@@ 52' 59." .. 1@@ 4' 19."]
8417 No matter how long it is, the album will fit nicely on one CD.
8419 @node Types Answer 13, Types Answer 14, Types Answer 12, Answers to Exercises
8420 @subsection Types Tutorial Exercise 13
8423 Type @kbd{' 1 yr @key{RET} u c s @key{RET}}. The answer is 31557600 seconds.
8425 @node Types Answer 14, Types Answer 15, Types Answer 13, Answers to Exercises
8426 @subsection Types Tutorial Exercise 14
8429 How long will it take for a signal to get from one end of the computer
8434 1: m / c 1: 3.3356 ns
8437 ' 1 m / c @key{RET} u c ns @key{RET}
8442 (Recall, @samp{c} is a ``unit'' corresponding to the speed of light.)
8446 1: 3.3356 ns 1: 0.81356 ns / ns 1: 0.81356
8450 ' 4.1 ns @key{RET} / u s
8455 Thus a signal could take up to 81 percent of a clock cycle just to
8456 go from one place to another inside the computer, assuming the signal
8457 could actually attain the full speed of light. Pretty tight!
8459 @node Types Answer 15, Algebra Answer 1, Types Answer 14, Answers to Exercises
8460 @subsection Types Tutorial Exercise 15
8463 The speed limit is 55 miles per hour on most highways. We want to
8464 find the ratio of Sam's speed to the US speed limit.
8468 1: 55 mph 2: 55 mph 3: 11 hr mph / yd
8472 ' 55 mph @key{RET} ' 5 yd/hr @key{RET} /
8476 The @kbd{u s} command cancels out these units to get a plain
8477 number. Now we take the logarithm base two to find the final
8478 answer, assuming that each successive pill doubles his speed.
8482 1: 19360. 2: 19360. 1: 14.24
8491 Thus Sam can take up to 14 pills without a worry.
8493 @node Algebra Answer 1, Algebra Answer 2, Types Answer 15, Answers to Exercises
8494 @subsection Algebra Tutorial Exercise 1
8497 @c [fix-ref Declarations]
8498 The result @samp{sqrt(x)^2} is simplified back to @expr{x} by the
8499 Calculator, but @samp{sqrt(x^2)} is not. (Consider what happens
8500 if @w{@expr{x = -4}}.) If @expr{x} is real, this formula could be
8501 simplified to @samp{abs(x)}, but for general complex arguments even
8502 that is not safe. (@xref{Declarations}, for a way to tell Calc
8503 that @expr{x} is known to be real.)
8505 @node Algebra Answer 2, Algebra Answer 3, Algebra Answer 1, Answers to Exercises
8506 @subsection Algebra Tutorial Exercise 2
8509 Suppose our roots are @expr{[a, b, c]}. We want a polynomial which
8510 is zero when @expr{x} is any of these values. The trivial polynomial
8511 @expr{x-a} is zero when @expr{x=a}, so the product @expr{(x-a)(x-b)(x-c)}
8512 will do the job. We can use @kbd{a c x} to write this in a more
8517 1: 34 x - 24 x^3 1: [1.19023, -1.19023, 0]
8527 1: [x - 1.19023, x + 1.19023, x] 1: (x - 1.19023) (x + 1.19023) x
8530 V M ' x-$ @key{RET} V R *
8537 1: x^3 - 1.41666 x 1: 34 x - 24 x^3
8540 a c x @key{RET} 24 n * a x
8545 Sure enough, our answer (multiplied by a suitable constant) is the
8546 same as the original polynomial.
8548 @node Algebra Answer 3, Algebra Answer 4, Algebra Answer 2, Answers to Exercises
8549 @subsection Algebra Tutorial Exercise 3
8553 1: x sin(pi x) 1: (sin(pi x) - pi x cos(pi x)) / pi^2
8556 ' x sin(pi x) @key{RET} m r a i x @key{RET}
8564 2: (sin(pi x) - pi x cos(pi x)) / pi^2
8567 ' [y,1] @key{RET} @key{TAB}
8574 1: [(sin(pi y) - pi y cos(pi y)) / pi^2, (sin(pi) - pi cos(pi)) / pi^2]
8584 1: (sin(pi y) - pi y cos(pi y)) / pi^2 + (pi cos(pi) - sin(pi)) / pi^2
8594 1: (sin(3.14159 y) - 3.14159 y cos(3.14159 y)) / 9.8696 - 0.3183
8604 1: [0., -0.95493, 0.63662, -1.5915, 1.2732]
8607 v x 5 @key{RET} @key{TAB} V M $ @key{RET}
8611 @node Algebra Answer 4, Rewrites Answer 1, Algebra Answer 3, Answers to Exercises
8612 @subsection Algebra Tutorial Exercise 4
8615 The hard part is that @kbd{V R +} is no longer sufficient to add up all
8616 the contributions from the slices, since the slices have varying
8617 coefficients. So first we must come up with a vector of these
8618 coefficients. Here's one way:
8622 2: -1 2: 3 1: [4, 2, ..., 4]
8623 1: [1, 2, ..., 9] 1: [-1, 1, ..., -1] .
8626 1 n v x 9 @key{RET} V M ^ 3 @key{TAB} -
8633 1: [4, 2, ..., 4, 1] 1: [1, 4, 2, ..., 4, 1]
8641 Now we compute the function values. Note that for this method we need
8642 eleven values, including both endpoints of the desired interval.
8646 2: [1, 4, 2, ..., 4, 1]
8647 1: [1, 1.1, 1.2, ... , 1.8, 1.9, 2.]
8650 11 @key{RET} 1 @key{RET} .1 @key{RET} C-u v x
8657 2: [1, 4, 2, ..., 4, 1]
8658 1: [0., 0.084941, 0.16993, ... ]
8661 ' sin(x) ln(x) @key{RET} m r p 5 @key{RET} V M $ @key{RET}
8666 Once again this calls for @kbd{V M * V R +}; a simple @kbd{*} does the
8671 1: 11.22 1: 1.122 1: 0.374
8679 Wow! That's even better than the result from the Taylor series method.
8681 @node Rewrites Answer 1, Rewrites Answer 2, Algebra Answer 4, Answers to Exercises
8682 @subsection Rewrites Tutorial Exercise 1
8685 We'll use Big mode to make the formulas more readable.
8691 1: (2 + sqrt(2)) / (1 + sqrt(2)) 1: --------
8697 ' (2+sqrt(2)) / (1+sqrt(2)) @key{RET} d B
8702 Multiplying by the conjugate helps because @expr{(a+b) (a-b) = a^2 - b^2}.
8707 1: (2 + V 2 ) (V 2 - 1)
8710 a r a/(b+c) := a*(b-c) / (b^2-c^2) @key{RET}
8718 1: 2 + V 2 - 2 1: V 2
8721 a r a*(b+c) := a*b + a*c a s
8726 (We could have used @kbd{a x} instead of a rewrite rule for the
8729 The multiply-by-conjugate rule turns out to be useful in many
8730 different circumstances, such as when the denominator involves
8731 sines and cosines or the imaginary constant @code{i}.
8733 @node Rewrites Answer 2, Rewrites Answer 3, Rewrites Answer 1, Answers to Exercises
8734 @subsection Rewrites Tutorial Exercise 2
8737 Here is the rule set:
8741 [ fib(n) := fib(n, 1, 1) :: integer(n) :: n >= 1,
8743 fib(n, x, y) := fib(n-1, y, x+y) ]
8748 The first rule turns a one-argument @code{fib} that people like to write
8749 into a three-argument @code{fib} that makes computation easier. The
8750 second rule converts back from three-argument form once the computation
8751 is done. The third rule does the computation itself. It basically
8752 says that if @expr{x} and @expr{y} are two consecutive Fibonacci numbers,
8753 then @expr{y} and @expr{x+y} are the next (overlapping) pair of Fibonacci
8756 Notice that because the number @expr{n} was ``validated'' by the
8757 conditions on the first rule, there is no need to put conditions on
8758 the other rules because the rule set would never get that far unless
8759 the input were valid. That further speeds computation, since no
8760 extra conditions need to be checked at every step.
8762 Actually, a user with a nasty sense of humor could enter a bad
8763 three-argument @code{fib} call directly, say, @samp{fib(0, 1, 1)},
8764 which would get the rules into an infinite loop. One thing that would
8765 help keep this from happening by accident would be to use something like
8766 @samp{ZzFib} instead of @code{fib} as the name of the three-argument
8769 @node Rewrites Answer 3, Rewrites Answer 4, Rewrites Answer 2, Answers to Exercises
8770 @subsection Rewrites Tutorial Exercise 3
8773 He got an infinite loop. First, Calc did as expected and rewrote
8774 @w{@samp{2 + 3 x}} to @samp{f(2, 3, x)}. Then it looked for ways to
8775 apply the rule again, and found that @samp{f(2, 3, x)} looks like
8776 @samp{a + b x} with @w{@samp{a = 0}} and @samp{b = 1}, so it rewrote to
8777 @samp{f(0, 1, f(2, 3, x))}. It then wrapped another @samp{f(0, 1, ...)}
8778 around that, and so on, ad infinitum. Joe should have used @kbd{M-1 a r}
8779 to make sure the rule applied only once.
8781 (Actually, even the first step didn't work as he expected. What Calc
8782 really gives for @kbd{M-1 a r} in this situation is @samp{f(3 x, 1, 2)},
8783 treating 2 as the ``variable,'' and @samp{3 x} as a constant being added
8784 to it. While this may seem odd, it's just as valid a solution as the
8785 ``obvious'' one. One way to fix this would be to add the condition
8786 @samp{:: variable(x)} to the rule, to make sure the thing that matches
8787 @samp{x} is indeed a variable, or to change @samp{x} to @samp{quote(x)}
8788 on the lefthand side, so that the rule matches the actual variable
8789 @samp{x} rather than letting @samp{x} stand for something else.)
8791 @node Rewrites Answer 4, Rewrites Answer 5, Rewrites Answer 3, Answers to Exercises
8792 @subsection Rewrites Tutorial Exercise 4
8799 Here is a suitable set of rules to solve the first part of the problem:
8803 [ seq(n, c) := seq(n/2, c+1) :: n%2 = 0,
8804 seq(n, c) := seq(3n+1, c+1) :: n%2 = 1 :: n > 1 ]
8808 Given the initial formula @samp{seq(6, 0)}, application of these
8809 rules produces the following sequence of formulas:
8823 whereupon neither of the rules match, and rewriting stops.
8825 We can pretty this up a bit with a couple more rules:
8829 [ seq(n) := seq(n, 0),
8836 Now, given @samp{seq(6)} as the starting configuration, we get 8
8839 The change to return a vector is quite simple:
8843 [ seq(n) := seq(n, []) :: integer(n) :: n > 0,
8845 seq(n, v) := seq(n/2, v | n) :: n%2 = 0,
8846 seq(n, v) := seq(3n+1, v | n) :: n%2 = 1 ]
8851 Given @samp{seq(6)}, the result is @samp{[6, 3, 10, 5, 16, 8, 4, 2, 1]}.
8853 Notice that the @expr{n > 1} guard is no longer necessary on the last
8854 rule since the @expr{n = 1} case is now detected by another rule.
8855 But a guard has been added to the initial rule to make sure the
8856 initial value is suitable before the computation begins.
8858 While still a good idea, this guard is not as vitally important as it
8859 was for the @code{fib} function, since calling, say, @samp{seq(x, [])}
8860 will not get into an infinite loop. Calc will not be able to prove
8861 the symbol @samp{x} is either even or odd, so none of the rules will
8862 apply and the rewrites will stop right away.
8864 @node Rewrites Answer 5, Rewrites Answer 6, Rewrites Answer 4, Answers to Exercises
8865 @subsection Rewrites Tutorial Exercise 5
8872 If @expr{x} is the sum @expr{a + b}, then `@tfn{nterms(}@var{x}@tfn{)}' must
8873 be `@tfn{nterms(}@var{a}@tfn{)}' plus `@tfn{nterms(}@var{b}@tfn{)}'. If @expr{x}
8874 is not a sum, then `@tfn{nterms(}@var{x}@tfn{)}' = 1.
8878 [ nterms(a + b) := nterms(a) + nterms(b),
8884 Here we have taken advantage of the fact that earlier rules always
8885 match before later rules; @samp{nterms(x)} will only be tried if we
8886 already know that @samp{x} is not a sum.
8888 @node Rewrites Answer 6, Programming Answer 1, Rewrites Answer 5, Answers to Exercises
8889 @subsection Rewrites Tutorial Exercise 6
8892 Here is a rule set that will do the job:
8896 [ a*(b + c) := a*b + a*c,
8897 opt(a) O(x^n) + opt(b) O(x^m) := O(x^n) :: n <= m
8898 :: constant(a) :: constant(b),
8899 opt(a) O(x^n) + opt(b) x^m := O(x^n) :: n <= m
8900 :: constant(a) :: constant(b),
8901 a O(x^n) := O(x^n) :: constant(a),
8902 x^opt(m) O(x^n) := O(x^(n+m)),
8903 O(x^n) O(x^m) := O(x^(n+m)) ]
8907 If we really want the @kbd{+} and @kbd{*} keys to operate naturally
8908 on power series, we should put these rules in @code{EvalRules}. For
8909 testing purposes, it is better to put them in a different variable,
8910 say, @code{O}, first.
8912 The first rule just expands products of sums so that the rest of the
8913 rules can assume they have an expanded-out polynomial to work with.
8914 Note that this rule does not mention @samp{O} at all, so it will
8915 apply to any product-of-sum it encounters---this rule may surprise
8916 you if you put it into @code{EvalRules}!
8918 In the second rule, the sum of two O's is changed to the smaller O.
8919 The optional constant coefficients are there mostly so that
8920 @samp{O(x^2) - O(x^3)} and @samp{O(x^3) - O(x^2)} are handled
8921 as well as @samp{O(x^2) + O(x^3)}.
8923 The third rule absorbs higher powers of @samp{x} into O's.
8925 The fourth rule says that a constant times a negligible quantity
8926 is still negligible. (This rule will also match @samp{O(x^3) / 4},
8927 with @samp{a = 1/4}.)
8929 The fifth rule rewrites, for example, @samp{x^2 O(x^3)} to @samp{O(x^5)}.
8930 (It is easy to see that if one of these forms is negligible, the other
8931 is, too.) Notice the @samp{x^opt(m)} to pick up terms like
8932 @w{@samp{x O(x^3)}}. Optional powers will match @samp{x} as @samp{x^1}
8933 but not 1 as @samp{x^0}. This turns out to be exactly what we want here.
8935 The sixth rule is the corresponding rule for products of two O's.
8937 Another way to solve this problem would be to create a new ``data type''
8938 that represents truncated power series. We might represent these as
8939 function calls @samp{series(@var{coefs}, @var{x})} where @var{coefs} is
8940 a vector of coefficients for @expr{x^0}, @expr{x^1}, @expr{x^2}, and so
8941 on. Rules would exist for sums and products of such @code{series}
8942 objects, and as an optional convenience could also know how to combine a
8943 @code{series} object with a normal polynomial. (With this, and with a
8944 rule that rewrites @samp{O(x^n)} to the equivalent @code{series} form,
8945 you could still enter power series in exactly the same notation as
8946 before.) Operations on such objects would probably be more efficient,
8947 although the objects would be a bit harder to read.
8949 @c [fix-ref Compositions]
8950 Some other symbolic math programs provide a power series data type
8951 similar to this. Mathematica, for example, has an object that looks
8952 like @samp{PowerSeries[@var{x}, @var{x0}, @var{coefs}, @var{nmin},
8953 @var{nmax}, @var{den}]}, where @var{x0} is the point about which the
8954 power series is taken (we've been assuming this was always zero),
8955 and @var{nmin}, @var{nmax}, and @var{den} allow pseudo-power-series
8956 with fractional or negative powers. Also, the @code{PowerSeries}
8957 objects have a special display format that makes them look like
8958 @samp{2 x^2 + O(x^4)} when they are printed out. (@xref{Compositions},
8959 for a way to do this in Calc, although for something as involved as
8960 this it would probably be better to write the formatting routine
8963 @node Programming Answer 1, Programming Answer 2, Rewrites Answer 6, Answers to Exercises
8964 @subsection Programming Tutorial Exercise 1
8967 Just enter the formula @samp{ninteg(sin(t)/t, t, 0, x)}, type
8968 @kbd{Z F}, and answer the questions. Since this formula contains two
8969 variables, the default argument list will be @samp{(t x)}. We want to
8970 change this to @samp{(x)} since @expr{t} is really a dummy variable
8971 to be used within @code{ninteg}.
8973 The exact keystrokes are @kbd{Z F s Si @key{RET} @key{RET} C-b C-b @key{DEL} @key{DEL} @key{RET} y}.
8974 (The @kbd{C-b C-b @key{DEL} @key{DEL}} are what fix the argument list.)
8976 @node Programming Answer 2, Programming Answer 3, Programming Answer 1, Answers to Exercises
8977 @subsection Programming Tutorial Exercise 2
8980 One way is to move the number to the top of the stack, operate on
8981 it, then move it back: @kbd{C-x ( M-@key{TAB} n M-@key{TAB} M-@key{TAB} C-x )}.
8983 Another way is to negate the top three stack entries, then negate
8984 again the top two stack entries: @kbd{C-x ( M-3 n M-2 n C-x )}.
8986 Finally, it turns out that a negative prefix argument causes a
8987 command like @kbd{n} to operate on the specified stack entry only,
8988 which is just what we want: @kbd{C-x ( M-- 3 n C-x )}.
8990 Just for kicks, let's also do it algebraically:
8991 @w{@kbd{C-x ( ' -$$$, $$, $ @key{RET} C-x )}}.
8993 @node Programming Answer 3, Programming Answer 4, Programming Answer 2, Answers to Exercises
8994 @subsection Programming Tutorial Exercise 3
8997 Each of these functions can be computed using the stack, or using
8998 algebraic entry, whichever way you prefer:
9002 @texline @math{\displaystyle{\sin x \over x}}:
9003 @infoline @expr{sin(x) / x}:
9005 Using the stack: @kbd{C-x ( @key{RET} S @key{TAB} / C-x )}.
9007 Using algebraic entry: @kbd{C-x ( ' sin($)/$ @key{RET} C-x )}.
9010 Computing the logarithm:
9012 Using the stack: @kbd{C-x ( @key{TAB} B C-x )}
9014 Using algebraic entry: @kbd{C-x ( ' log($,$$) @key{RET} C-x )}.
9017 Computing the vector of integers:
9019 Using the stack: @kbd{C-x ( 1 @key{RET} 1 C-u v x C-x )}. (Recall that
9020 @kbd{C-u v x} takes the vector size, starting value, and increment
9023 Alternatively: @kbd{C-x ( ~ v x C-x )}. (The @kbd{~} key pops a
9024 number from the stack and uses it as the prefix argument for the
9027 Using algebraic entry: @kbd{C-x ( ' index($) @key{RET} C-x )}.
9029 @node Programming Answer 4, Programming Answer 5, Programming Answer 3, Answers to Exercises
9030 @subsection Programming Tutorial Exercise 4
9033 Here's one way: @kbd{C-x ( @key{RET} V R + @key{TAB} v l / C-x )}.
9035 @node Programming Answer 5, Programming Answer 6, Programming Answer 4, Answers to Exercises
9036 @subsection Programming Tutorial Exercise 5
9040 2: 1 1: 1.61803398502 2: 1.61803398502
9041 1: 20 . 1: 1.61803398875
9044 1 @key{RET} 20 Z < & 1 + Z > I H P
9049 This answer is quite accurate.
9051 @node Programming Answer 6, Programming Answer 7, Programming Answer 5, Answers to Exercises
9052 @subsection Programming Tutorial Exercise 6
9058 [ [ 0, 1 ] * [a, b] = [b, a + b]
9063 Thus @samp{[0, 1; 1, 1]^n * [1, 1]} computes Fibonacci numbers @expr{n+1}
9064 and @expr{n+2}. Here's one program that does the job:
9067 C-x ( ' [0, 1; 1, 1] ^ ($-1) * [1, 1] @key{RET} v u @key{DEL} C-x )
9071 This program is quite efficient because Calc knows how to raise a
9072 matrix (or other value) to the power @expr{n} in only
9073 @texline @math{\log_2 n}
9074 @infoline @expr{log(n,2)}
9075 steps. For example, this program can compute the 1000th Fibonacci
9076 number (a 209-digit integer!) in about 10 steps; even though the
9077 @kbd{Z < ... Z >} solution had much simpler steps, it would have
9078 required so many steps that it would not have been practical.
9080 @node Programming Answer 7, Programming Answer 8, Programming Answer 6, Answers to Exercises
9081 @subsection Programming Tutorial Exercise 7
9084 The trick here is to compute the harmonic numbers differently, so that
9085 the loop counter itself accumulates the sum of reciprocals. We use
9086 a separate variable to hold the integer counter.
9094 1 t 1 1 @key{RET} 4 Z ( t 2 r 1 1 + s 1 & Z )
9099 The body of the loop goes as follows: First save the harmonic sum
9100 so far in variable 2. Then delete it from the stack; the for loop
9101 itself will take care of remembering it for us. Next, recall the
9102 count from variable 1, add one to it, and feed its reciprocal to
9103 the for loop to use as the step value. The for loop will increase
9104 the ``loop counter'' by that amount and keep going until the
9105 loop counter exceeds 4.
9110 1: 3.99498713092 2: 3.99498713092
9114 r 1 r 2 @key{RET} 31 & +
9118 Thus we find that the 30th harmonic number is 3.99, and the 31st
9119 harmonic number is 4.02.
9121 @node Programming Answer 8, Programming Answer 9, Programming Answer 7, Answers to Exercises
9122 @subsection Programming Tutorial Exercise 8
9125 The first step is to compute the derivative @expr{f'(x)} and thus
9127 @texline @math{\displaystyle{x - {f(x) \over f'(x)}}}.
9128 @infoline @expr{x - f(x)/f'(x)}.
9130 (Because this definition is long, it will be repeated in concise form
9131 below. You can use @w{@kbd{C-x * m}} to load it from there. While you are
9132 entering a @kbd{Z ` Z '} body in a macro, Calc simply collects
9133 keystrokes without executing them. In the following diagrams we'll
9134 pretend Calc actually executed the keystrokes as you typed them,
9135 just for purposes of illustration.)
9139 2: sin(cos(x)) - 0.5 3: 4.5
9140 1: 4.5 2: sin(cos(x)) - 0.5
9141 . 1: -(sin(x) cos(cos(x)))
9144 ' sin(cos(x))-0.5 @key{RET} 4.5 m r C-x ( Z ` @key{TAB} @key{RET} a d x @key{RET}
9152 1: x + (sin(cos(x)) - 0.5) / sin(x) cos(cos(x))
9155 / ' x @key{RET} @key{TAB} - t 1
9159 Now, we enter the loop. We'll use a repeat loop with a 20-repetition
9160 limit just in case the method fails to converge for some reason.
9161 (Normally, the @w{@kbd{Z /}} command will stop the loop before all 20
9162 repetitions are done.)
9166 1: 4.5 3: 4.5 2: 4.5
9167 . 2: x + (sin(cos(x)) ... 1: 5.24196456928
9171 20 Z < @key{RET} r 1 @key{TAB} s l x @key{RET}
9175 This is the new guess for @expr{x}. Now we compare it with the
9176 old one to see if we've converged.
9180 3: 5.24196 2: 5.24196 1: 5.24196 1: 5.26345856348
9185 @key{RET} M-@key{TAB} a = Z / Z > Z ' C-x )
9189 The loop converges in just a few steps to this value. To check
9190 the result, we can simply substitute it back into the equation.
9198 @key{RET} ' sin(cos($)) @key{RET}
9202 Let's test the new definition again:
9210 ' x^2-9 @key{RET} 1 X
9214 Once again, here's the full Newton's Method definition:
9218 C-x ( Z ` @key{TAB} @key{RET} a d x @key{RET} / ' x @key{RET} @key{TAB} - t 1
9219 20 Z < @key{RET} r 1 @key{TAB} s l x @key{RET}
9220 @key{RET} M-@key{TAB} a = Z /
9227 @c [fix-ref Nesting and Fixed Points]
9228 It turns out that Calc has a built-in command for applying a formula
9229 repeatedly until it converges to a number. @xref{Nesting and Fixed Points},
9230 to see how to use it.
9232 @c [fix-ref Root Finding]
9233 Also, of course, @kbd{a R} is a built-in command that uses Newton's
9234 method (among others) to look for numerical solutions to any equation.
9235 @xref{Root Finding}.
9237 @node Programming Answer 9, Programming Answer 10, Programming Answer 8, Answers to Exercises
9238 @subsection Programming Tutorial Exercise 9
9241 The first step is to adjust @expr{z} to be greater than 5. A simple
9242 ``for'' loop will do the job here. If @expr{z} is less than 5, we
9243 reduce the problem using
9244 @texline @math{\psi(z) = \psi(z+1) - 1/z}.
9245 @infoline @expr{psi(z) = psi(z+1) - 1/z}. We go
9247 @texline @math{\psi(z+1)},
9248 @infoline @expr{psi(z+1)},
9249 and remember to add back a factor of @expr{-1/z} when we're done. This
9250 step is repeated until @expr{z > 5}.
9252 (Because this definition is long, it will be repeated in concise form
9253 below. You can use @w{@kbd{C-x * m}} to load it from there. While you are
9254 entering a @kbd{Z ` Z '} body in a macro, Calc simply collects
9255 keystrokes without executing them. In the following diagrams we'll
9256 pretend Calc actually executed the keystrokes as you typed them,
9257 just for purposes of illustration.)
9264 1.0 @key{RET} C-x ( Z ` s 1 0 t 2
9268 Here, variable 1 holds @expr{z} and variable 2 holds the adjustment
9269 factor. If @expr{z < 5}, we use a loop to increase it.
9271 (By the way, we started with @samp{1.0} instead of the integer 1 because
9272 otherwise the calculation below will try to do exact fractional arithmetic,
9273 and will never converge because fractions compare equal only if they
9274 are exactly equal, not just equal to within the current precision.)
9283 @key{RET} 5 a < Z [ 5 Z ( & s + 2 1 s + 1 1 Z ) r 1 Z ]
9287 Now we compute the initial part of the sum:
9288 @texline @math{\ln z - {1 \over 2z}}
9289 @infoline @expr{ln(z) - 1/2z}
9290 minus the adjustment factor.
9294 2: 1.79175946923 2: 1.7084261359 1: -0.57490719743
9295 1: 0.0833333333333 1: 2.28333333333 .
9302 Now we evaluate the series. We'll use another ``for'' loop counting
9303 up the value of @expr{2 n}. (Calc does have a summation command,
9304 @kbd{a +}, but we'll use loops just to get more practice with them.)
9308 3: -0.5749 3: -0.5749 4: -0.5749 2: -0.5749
9309 2: 2 2: 1:6 3: 1:6 1: 2.3148e-3
9314 2 @key{RET} 40 Z ( @key{RET} k b @key{TAB} @key{RET} r 1 @key{TAB} ^ * /
9321 3: -0.5749 3: -0.5772 2: -0.5772 1: -0.577215664892
9322 2: -0.5749 2: -0.5772 1: 0 .
9323 1: 2.3148e-3 1: -0.5749 .
9326 @key{TAB} @key{RET} M-@key{TAB} - @key{RET} M-@key{TAB} a = Z / 2 Z ) Z ' C-x )
9330 This is the value of
9331 @texline @math{-\gamma},
9332 @infoline @expr{- gamma},
9333 with a slight bit of roundoff error. To get a full 12 digits, let's use
9338 2: -0.577215664892 2: -0.577215664892
9339 1: 1. 1: -0.577215664901532
9341 1. @key{RET} p 16 @key{RET} X
9345 Here's the complete sequence of keystrokes:
9350 @key{RET} 5 a < Z [ 5 Z ( & s + 2 1 s + 1 1 Z ) r 1 Z ]
9352 2 @key{RET} 40 Z ( @key{RET} k b @key{TAB} @key{RET} r 1 @key{TAB} ^ * /
9353 @key{TAB} @key{RET} M-@key{TAB} - @key{RET} M-@key{TAB} a = Z /
9360 @node Programming Answer 10, Programming Answer 11, Programming Answer 9, Answers to Exercises
9361 @subsection Programming Tutorial Exercise 10
9364 Taking the derivative of a term of the form @expr{x^n} will produce
9366 @texline @math{n x^{n-1}}.
9367 @infoline @expr{n x^(n-1)}.
9368 Taking the derivative of a constant
9369 produces zero. From this it is easy to see that the @expr{n}th
9370 derivative of a polynomial, evaluated at @expr{x = 0}, will equal the
9371 coefficient on the @expr{x^n} term times @expr{n!}.
9373 (Because this definition is long, it will be repeated in concise form
9374 below. You can use @w{@kbd{C-x * m}} to load it from there. While you are
9375 entering a @kbd{Z ` Z '} body in a macro, Calc simply collects
9376 keystrokes without executing them. In the following diagrams we'll
9377 pretend Calc actually executed the keystrokes as you typed them,
9378 just for purposes of illustration.)
9382 2: 5 x^4 + (x + 1)^2 3: 5 x^4 + (x + 1)^2
9387 ' 5 x^4 + (x+1)^2 @key{RET} 6 C-x ( Z ` [ ] t 1 0 @key{TAB}
9392 Variable 1 will accumulate the vector of coefficients.
9396 2: 0 3: 0 2: 5 x^4 + ...
9397 1: 5 x^4 + ... 2: 5 x^4 + ... 1: 1
9401 Z ( @key{TAB} @key{RET} 0 s l x @key{RET} M-@key{TAB} ! / s | 1
9406 Note that @kbd{s | 1} appends the top-of-stack value to the vector
9407 in a variable; it is completely analogous to @kbd{s + 1}. We could
9408 have written instead, @kbd{r 1 @key{TAB} | t 1}.
9412 1: 20 x^3 + 2 x + 2 1: 0 1: [1, 2, 1, 0, 5, 0, 0]
9415 a d x @key{RET} 1 Z ) @key{DEL} r 1 Z ' C-x )
9419 To convert back, a simple method is just to map the coefficients
9420 against a table of powers of @expr{x}.
9424 2: [1, 2, 1, 0, 5, 0, 0] 2: [1, 2, 1, 0, 5, 0, 0]
9425 1: 6 1: [0, 1, 2, 3, 4, 5, 6]
9428 6 @key{RET} 1 + 0 @key{RET} 1 C-u v x
9435 2: [1, 2, 1, 0, 5, 0, 0] 2: 1 + 2 x + x^2 + 5 x^4
9436 1: [1, x, x^2, x^3, ... ] .
9439 ' x @key{RET} @key{TAB} V M ^ *
9443 Once again, here are the whole polynomial to/from vector programs:
9447 C-x ( Z ` [ ] t 1 0 @key{TAB}
9448 Z ( @key{TAB} @key{RET} 0 s l x @key{RET} M-@key{TAB} ! / s | 1
9454 C-x ( 1 + 0 @key{RET} 1 C-u v x ' x @key{RET} @key{TAB} V M ^ * C-x )
9458 @node Programming Answer 11, Programming Answer 12, Programming Answer 10, Answers to Exercises
9459 @subsection Programming Tutorial Exercise 11
9462 First we define a dummy program to go on the @kbd{z s} key. The true
9463 @w{@kbd{z s}} key is supposed to take two numbers from the stack and
9464 return one number, so @key{DEL} as a dummy definition will make
9465 sure the stack comes out right.
9473 4 @key{RET} 2 C-x ( @key{DEL} C-x ) Z K s @key{RET} 2
9477 The last step replaces the 2 that was eaten during the creation
9478 of the dummy @kbd{z s} command. Now we move on to the real
9479 definition. The recurrence needs to be rewritten slightly,
9480 to the form @expr{s(n,m) = s(n-1,m-1) - (n-1) s(n-1,m)}.
9482 (Because this definition is long, it will be repeated in concise form
9483 below. You can use @kbd{C-x * m} to load it from there.)
9493 C-x ( M-2 @key{RET} a = Z [ @key{DEL} @key{DEL} 1 Z :
9500 4: 4 2: 4 2: 3 4: 3 4: 3 3: 3
9501 3: 2 1: 2 1: 2 3: 2 3: 2 2: 2
9502 2: 2 . . 2: 3 2: 3 1: 3
9506 @key{RET} 0 a = Z [ @key{DEL} @key{DEL} 0 Z : @key{TAB} 1 - @key{TAB} M-2 @key{RET} 1 - z s
9511 (Note that the value 3 that our dummy @kbd{z s} produces is not correct;
9512 it is merely a placeholder that will do just as well for now.)
9516 3: 3 4: 3 3: 3 2: 3 1: -6
9517 2: 3 3: 3 2: 3 1: 9 .
9522 M-@key{TAB} M-@key{TAB} @key{TAB} @key{RET} M-@key{TAB} z s * -
9529 1: -6 2: 4 1: 11 2: 11
9533 Z ] Z ] C-x ) Z K s @key{RET} @key{DEL} 4 @key{RET} 2 z s M-@key{RET} k s
9537 Even though the result that we got during the definition was highly
9538 bogus, once the definition is complete the @kbd{z s} command gets
9541 Here's the full program once again:
9545 C-x ( M-2 @key{RET} a =
9546 Z [ @key{DEL} @key{DEL} 1
9548 Z [ @key{DEL} @key{DEL} 0
9549 Z : @key{TAB} 1 - @key{TAB} M-2 @key{RET} 1 - z s
9550 M-@key{TAB} M-@key{TAB} @key{TAB} @key{RET} M-@key{TAB} z s * -
9557 You can read this definition using @kbd{C-x * m} (@code{read-kbd-macro})
9558 followed by @kbd{Z K s}, without having to make a dummy definition
9559 first, because @code{read-kbd-macro} doesn't need to execute the
9560 definition as it reads it in. For this reason, @code{C-x * m} is often
9561 the easiest way to create recursive programs in Calc.
9563 @node Programming Answer 12, , Programming Answer 11, Answers to Exercises
9564 @subsection Programming Tutorial Exercise 12
9567 This turns out to be a much easier way to solve the problem. Let's
9568 denote Stirling numbers as calls of the function @samp{s}.
9570 First, we store the rewrite rules corresponding to the definition of
9571 Stirling numbers in a convenient variable:
9574 s e StirlingRules @key{RET}
9575 [ s(n,n) := 1 :: n >= 0,
9576 s(n,0) := 0 :: n > 0,
9577 s(n,m) := s(n-1,m-1) - (n-1) s(n-1,m) :: n >= m :: m >= 1 ]
9581 Now, it's just a matter of applying the rules:
9585 2: 4 1: s(4, 2) 1: 11
9589 4 @key{RET} 2 C-x ( ' s($$,$) @key{RET} a r StirlingRules @key{RET} C-x )
9593 As in the case of the @code{fib} rules, it would be useful to put these
9594 rules in @code{EvalRules} and to add a @samp{:: remember} condition to
9597 @c This ends the table-of-contents kludge from above:
9599 \global\let\chapternofonts=\oldchapternofonts
9604 @node Introduction, Data Types, Tutorial, Top
9605 @chapter Introduction
9608 This chapter is the beginning of the Calc reference manual.
9609 It covers basic concepts such as the stack, algebraic and
9610 numeric entry, undo, numeric prefix arguments, etc.
9613 @c (Chapter 2, the Tutorial, has been printed in a separate volume.)
9621 * Quick Calculator::
9622 * Prefix Arguments::
9625 * Multiple Calculators::
9626 * Troubleshooting Commands::
9629 @node Basic Commands, Help Commands, Introduction, Introduction
9630 @section Basic Commands
9635 @cindex Starting the Calculator
9636 @cindex Running the Calculator
9637 To start the Calculator in its standard interface, type @kbd{M-x calc}.
9638 By default this creates a pair of small windows, @samp{*Calculator*}
9639 and @samp{*Calc Trail*}. The former displays the contents of the
9640 Calculator stack and is manipulated exclusively through Calc commands.
9641 It is possible (though not usually necessary) to create several Calc
9642 mode buffers each of which has an independent stack, undo list, and
9643 mode settings. There is exactly one Calc Trail buffer; it records a
9644 list of the results of all calculations that have been done. The
9645 Calc Trail buffer uses a variant of Calc mode, so Calculator commands
9646 still work when the trail buffer's window is selected. It is possible
9647 to turn the trail window off, but the @samp{*Calc Trail*} buffer itself
9648 still exists and is updated silently. @xref{Trail Commands}.
9655 In most installations, the @kbd{C-x * c} key sequence is a more
9656 convenient way to start the Calculator. Also, @kbd{C-x * *}
9657 is a synonym for @kbd{C-x * c} unless you last used Calc
9662 @pindex calc-execute-extended-command
9663 Most Calc commands use one or two keystrokes. Lower- and upper-case
9664 letters are distinct. Commands may also be entered in full @kbd{M-x} form;
9665 for some commands this is the only form. As a convenience, the @kbd{x}
9666 key (@code{calc-execute-extended-command})
9667 is like @kbd{M-x} except that it enters the initial string @samp{calc-}
9668 for you. For example, the following key sequences are equivalent:
9669 @kbd{S}, @kbd{M-x calc-sin @key{RET}}, @kbd{x sin @key{RET}}.
9671 Although Calc is designed to be used from the keyboard, some of
9672 Calc's more common commands are available from a menu. In the menu, the
9673 arguments to the functions are given by referring to their stack level
9676 @cindex Extensions module
9677 @cindex @file{calc-ext} module
9678 The Calculator exists in many parts. When you type @kbd{C-x * c}, the
9679 Emacs ``auto-load'' mechanism will bring in only the first part, which
9680 contains the basic arithmetic functions. The other parts will be
9681 auto-loaded the first time you use the more advanced commands like trig
9682 functions or matrix operations. This is done to improve the response time
9683 of the Calculator in the common case when all you need to do is a
9684 little arithmetic. If for some reason the Calculator fails to load an
9685 extension module automatically, you can force it to load all the
9686 extensions by using the @kbd{C-x * L} (@code{calc-load-everything})
9687 command. @xref{Mode Settings}.
9689 If you type @kbd{M-x calc} or @kbd{C-x * c} with any numeric prefix argument,
9690 the Calculator is loaded if necessary, but it is not actually started.
9691 If the argument is positive, the @file{calc-ext} extensions are also
9692 loaded if necessary. User-written Lisp code that wishes to make use
9693 of Calc's arithmetic routines can use @samp{(calc 0)} or @samp{(calc 1)}
9694 to auto-load the Calculator.
9698 If you type @kbd{C-x * b}, then next time you use @kbd{C-x * c} you
9699 will get a Calculator that uses the full height of the Emacs screen.
9700 When full-screen mode is on, @kbd{C-x * c} runs the @code{full-calc}
9701 command instead of @code{calc}. From the Unix shell you can type
9702 @samp{emacs -f full-calc} to start a new Emacs specifically for use
9703 as a calculator. When Calc is started from the Emacs command line
9704 like this, Calc's normal ``quit'' commands actually quit Emacs itself.
9707 @pindex calc-other-window
9708 The @kbd{C-x * o} command is like @kbd{C-x * c} except that the Calc
9709 window is not actually selected. If you are already in the Calc
9710 window, @kbd{C-x * o} switches you out of it. (The regular Emacs
9711 @kbd{C-x o} command would also work for this, but it has a
9712 tendency to drop you into the Calc Trail window instead, which
9713 @kbd{C-x * o} takes care not to do.)
9718 For one quick calculation, you can type @kbd{C-x * q} (@code{quick-calc})
9719 which prompts you for a formula (like @samp{2+3/4}). The result is
9720 displayed at the bottom of the Emacs screen without ever creating
9721 any special Calculator windows. @xref{Quick Calculator}.
9726 Finally, if you are using the X window system you may want to try
9727 @kbd{C-x * k} (@code{calc-keypad}) which runs Calc with a
9728 ``calculator keypad'' picture as well as a stack display. Click on
9729 the keys with the mouse to operate the calculator. @xref{Keypad Mode}.
9733 @cindex Quitting the Calculator
9734 @cindex Exiting the Calculator
9735 The @kbd{q} key (@code{calc-quit}) exits Calc mode and closes the
9736 Calculator's window(s). It does not delete the Calculator buffers.
9737 If you type @kbd{M-x calc} again, the Calculator will reappear with the
9738 contents of the stack intact. Typing @kbd{C-x * c} or @kbd{C-x * *}
9739 again from inside the Calculator buffer is equivalent to executing
9740 @code{calc-quit}; you can think of @kbd{C-x * *} as toggling the
9741 Calculator on and off.
9744 The @kbd{C-x * x} command also turns the Calculator off, no matter which
9745 user interface (standard, Keypad, or Embedded) is currently active.
9746 It also cancels @code{calc-edit} mode if used from there.
9749 @pindex calc-refresh
9750 @cindex Refreshing a garbled display
9751 @cindex Garbled displays, refreshing
9752 The @kbd{d @key{SPC}} key sequence (@code{calc-refresh}) redraws the contents
9753 of the Calculator buffer from memory. Use this if the contents of the
9754 buffer have been damaged somehow.
9759 The @kbd{o} key (@code{calc-realign}) moves the cursor back to its
9760 ``home'' position at the bottom of the Calculator buffer.
9764 @pindex calc-scroll-left
9765 @pindex calc-scroll-right
9766 @cindex Horizontal scrolling
9768 @cindex Wide text, scrolling
9769 The @kbd{<} and @kbd{>} keys are bound to @code{calc-scroll-left} and
9770 @code{calc-scroll-right}. These are just like the normal horizontal
9771 scrolling commands except that they scroll one half-screen at a time by
9772 default. (Calc formats its output to fit within the bounds of the
9773 window whenever it can.)
9777 @pindex calc-scroll-down
9778 @pindex calc-scroll-up
9779 @cindex Vertical scrolling
9780 The @kbd{@{} and @kbd{@}} keys are bound to @code{calc-scroll-down}
9781 and @code{calc-scroll-up}. They scroll up or down by one-half the
9782 height of the Calc window.
9786 The @kbd{C-x * 0} command (@code{calc-reset}; that's @kbd{C-x *} followed
9787 by a zero) resets the Calculator to its initial state. This clears
9788 the stack, resets all the modes to their initial values (the values
9789 that were saved with @kbd{m m} (@code{calc-save-modes})), clears the
9790 caches (@pxref{Caches}), and so on. (It does @emph{not} erase the
9791 values of any variables.) With an argument of 0, Calc will be reset to
9792 its default state; namely, the modes will be given their default values.
9793 With a positive prefix argument, @kbd{C-x * 0} preserves the contents of
9794 the stack but resets everything else to its initial state; with a
9795 negative prefix argument, @kbd{C-x * 0} preserves the contents of the
9796 stack but resets everything else to its default state.
9798 @node Help Commands, Stack Basics, Basic Commands, Introduction
9799 @section Help Commands
9802 @cindex Help commands
9822 The @kbd{?} key (@code{calc-help}) displays a series of brief help messages.
9823 Some keys (such as @kbd{b} and @kbd{d}) are prefix keys, like Emacs'
9824 @key{ESC} and @kbd{C-x} prefixes. You can type
9825 @kbd{?} after a prefix to see a list of commands beginning with that
9826 prefix. (If the message includes @samp{[MORE]}, press @kbd{?} again
9827 to see additional commands for that prefix.)
9830 @pindex calc-full-help
9831 The @kbd{h h} (@code{calc-full-help}) command displays all the @kbd{?}
9832 responses at once. When printed, this makes a nice, compact (three pages)
9833 summary of Calc keystrokes.
9835 In general, the @kbd{h} key prefix introduces various commands that
9836 provide help within Calc. Many of the @kbd{h} key functions are
9837 Calc-specific analogues to the @kbd{C-h} functions for Emacs help.
9843 The @kbd{h i} (@code{calc-info}) command runs the Emacs Info system
9844 to read this manual on-line. This is basically the same as typing
9845 @kbd{C-h i} (the regular way to run the Info system), then, if Info
9846 is not already in the Calc manual, selecting the beginning of the
9847 manual. The @kbd{C-x * i} command is another way to read the Calc
9848 manual; it is different from @kbd{h i} in that it works any time,
9849 not just inside Calc. The plain @kbd{i} key is also equivalent to
9850 @kbd{h i}, though this key is obsolete and may be replaced with a
9851 different command in a future version of Calc.
9855 @pindex calc-tutorial
9856 The @kbd{h t} (@code{calc-tutorial}) command runs the Info system on
9857 the Tutorial section of the Calc manual. It is like @kbd{h i},
9858 except that it selects the starting node of the tutorial rather
9859 than the beginning of the whole manual. (It actually selects the
9860 node ``Interactive Tutorial'' which tells a few things about
9861 using the Info system before going on to the actual tutorial.)
9862 The @kbd{C-x * t} key is equivalent to @kbd{h t} (but it works at
9867 @pindex calc-info-summary
9868 The @kbd{h s} (@code{calc-info-summary}) command runs the Info system
9869 on the Summary node of the Calc manual. @xref{Summary}. The @kbd{C-x * s}
9870 key is equivalent to @kbd{h s}.
9873 @pindex calc-describe-key
9874 The @kbd{h k} (@code{calc-describe-key}) command looks up a key
9875 sequence in the Calc manual. For example, @kbd{h k H a S} looks
9876 up the documentation on the @kbd{H a S} (@code{calc-solve-for})
9877 command. This works by looking up the textual description of
9878 the key(s) in the Key Index of the manual, then jumping to the
9879 node indicated by the index.
9881 Most Calc commands do not have traditional Emacs documentation
9882 strings, since the @kbd{h k} command is both more convenient and
9883 more instructive. This means the regular Emacs @kbd{C-h k}
9884 (@code{describe-key}) command will not be useful for Calc keystrokes.
9887 @pindex calc-describe-key-briefly
9888 The @kbd{h c} (@code{calc-describe-key-briefly}) command reads a
9889 key sequence and displays a brief one-line description of it at
9890 the bottom of the screen. It looks for the key sequence in the
9891 Summary node of the Calc manual; if it doesn't find the sequence
9892 there, it acts just like its regular Emacs counterpart @kbd{C-h c}
9893 (@code{describe-key-briefly}). For example, @kbd{h c H a S}
9894 gives the description:
9897 H a S runs calc-solve-for: a `H a S' v => fsolve(a,v) (?=notes)
9901 which means the command @kbd{H a S} or @kbd{H M-x calc-solve-for}
9902 takes a value @expr{a} from the stack, prompts for a value @expr{v},
9903 then applies the algebraic function @code{fsolve} to these values.
9904 The @samp{?=notes} message means you can now type @kbd{?} to see
9905 additional notes from the summary that apply to this command.
9908 @pindex calc-describe-function
9909 The @kbd{h f} (@code{calc-describe-function}) command looks up an
9910 algebraic function or a command name in the Calc manual. Enter an
9911 algebraic function name to look up that function in the Function
9912 Index or enter a command name beginning with @samp{calc-} to look it
9913 up in the Command Index. This command will also look up operator
9914 symbols that can appear in algebraic formulas, like @samp{%} and
9918 @pindex calc-describe-variable
9919 The @kbd{h v} (@code{calc-describe-variable}) command looks up a
9920 variable in the Calc manual. Enter a variable name like @code{pi} or
9924 @pindex describe-bindings
9925 The @kbd{h b} (@code{calc-describe-bindings}) command is just like
9926 @kbd{C-h b}, except that only local (Calc-related) key bindings are
9930 The @kbd{h n} or @kbd{h C-n} (@code{calc-view-news}) command displays
9931 the ``news'' or change history of Calc. This is kept in the file
9932 @file{README}, which Calc looks for in the same directory as the Calc
9938 The @kbd{h C-c}, @kbd{h C-d}, and @kbd{h C-w} keys display copying,
9939 distribution, and warranty information about Calc. These work by
9940 pulling up the appropriate parts of the ``Copying'' or ``Reporting
9941 Bugs'' sections of the manual.
9943 @node Stack Basics, Numeric Entry, Help Commands, Introduction
9944 @section Stack Basics
9947 @cindex Stack basics
9948 @c [fix-tut RPN Calculations and the Stack]
9949 Calc uses RPN notation. If you are not familiar with RPN, @pxref{RPN
9952 To add the numbers 1 and 2 in Calc you would type the keys:
9953 @kbd{1 @key{RET} 2 +}.
9954 (@key{RET} corresponds to the @key{ENTER} key on most calculators.)
9955 The first three keystrokes ``push'' the numbers 1 and 2 onto the stack. The
9956 @kbd{+} key always ``pops'' the top two numbers from the stack, adds them,
9957 and pushes the result (3) back onto the stack. This number is ready for
9958 further calculations: @kbd{5 -} pushes 5 onto the stack, then pops the
9959 3 and 5, subtracts them, and pushes the result (@mathit{-2}).
9961 Note that the ``top'' of the stack actually appears at the @emph{bottom}
9962 of the buffer. A line containing a single @samp{.} character signifies
9963 the end of the buffer; Calculator commands operate on the number(s)
9964 directly above this line. The @kbd{d t} (@code{calc-truncate-stack})
9965 command allows you to move the @samp{.} marker up and down in the stack;
9966 @pxref{Truncating the Stack}.
9969 @pindex calc-line-numbering
9970 Stack elements are numbered consecutively, with number 1 being the top of
9971 the stack. These line numbers are ordinarily displayed on the lefthand side
9972 of the window. The @kbd{d l} (@code{calc-line-numbering}) command controls
9973 whether these numbers appear. (Line numbers may be turned off since they
9974 slow the Calculator down a bit and also clutter the display.)
9977 @pindex calc-realign
9978 The unshifted letter @kbd{o} (@code{calc-realign}) command repositions
9979 the cursor to its top-of-stack ``home'' position. It also undoes any
9980 horizontal scrolling in the window. If you give it a numeric prefix
9981 argument, it instead moves the cursor to the specified stack element.
9983 The @key{RET} (or equivalent @key{SPC}) key is only required to separate
9984 two consecutive numbers.
9985 (After all, if you typed @kbd{1 2} by themselves the Calculator
9986 would enter the number 12.) If you press @key{RET} or @key{SPC} @emph{not}
9987 right after typing a number, the key duplicates the number on the top of
9988 the stack. @kbd{@key{RET} *} is thus a handy way to square a number.
9990 The @key{DEL} key pops and throws away the top number on the stack.
9991 The @key{TAB} key swaps the top two objects on the stack.
9992 @xref{Stack and Trail}, for descriptions of these and other stack-related
9995 @node Numeric Entry, Algebraic Entry, Stack Basics, Introduction
9996 @section Numeric Entry
10002 @cindex Numeric entry
10003 @cindex Entering numbers
10004 Pressing a digit or other numeric key begins numeric entry using the
10005 minibuffer. The number is pushed on the stack when you press the @key{RET}
10006 or @key{SPC} keys. If you press any other non-numeric key, the number is
10007 pushed onto the stack and the appropriate operation is performed. If
10008 you press a numeric key which is not valid, the key is ignored.
10010 @cindex Minus signs
10011 @cindex Negative numbers, entering
10013 There are three different concepts corresponding to the word ``minus,''
10014 typified by @expr{a-b} (subtraction), @expr{-x}
10015 (change-sign), and @expr{-5} (negative number). Calc uses three
10016 different keys for these operations, respectively:
10017 @kbd{-}, @kbd{n}, and @kbd{_} (the underscore). The @kbd{-} key subtracts
10018 the two numbers on the top of the stack. The @kbd{n} key changes the sign
10019 of the number on the top of the stack or the number currently being entered.
10020 The @kbd{_} key begins entry of a negative number or changes the sign of
10021 the number currently being entered. The following sequences all enter the
10022 number @mathit{-5} onto the stack: @kbd{0 @key{RET} 5 -}, @kbd{5 n @key{RET}},
10023 @kbd{5 @key{RET} n}, @kbd{_ 5 @key{RET}}, @kbd{5 _ @key{RET}}.
10025 Some other keys are active during numeric entry, such as @kbd{#} for
10026 non-decimal numbers, @kbd{:} for fractions, and @kbd{@@} for HMS forms.
10027 These notations are described later in this manual with the corresponding
10028 data types. @xref{Data Types}.
10030 During numeric entry, the only editing key available is @key{DEL}.
10032 @node Algebraic Entry, Quick Calculator, Numeric Entry, Introduction
10033 @section Algebraic Entry
10037 @pindex calc-algebraic-entry
10038 @cindex Algebraic notation
10039 @cindex Formulas, entering
10040 The @kbd{'} (@code{calc-algebraic-entry}) command can be used to enter
10041 calculations in algebraic form. This is accomplished by typing the
10042 apostrophe key, ', followed by the expression in standard format:
10050 @texline @math{2+(3\times4) = 14}
10051 @infoline @expr{2+(3*4) = 14}
10052 and push it on the stack. If you wish you can
10053 ignore the RPN aspect of Calc altogether and simply enter algebraic
10054 expressions in this way. You may want to use @key{DEL} every so often to
10055 clear previous results off the stack.
10057 You can press the apostrophe key during normal numeric entry to switch
10058 the half-entered number into Algebraic entry mode. One reason to do
10059 this would be to fix a typo, as the full Emacs cursor motion and editing
10060 keys are available during algebraic entry but not during numeric entry.
10062 In the same vein, during either numeric or algebraic entry you can
10063 press @kbd{`} (backquote) to switch to @code{calc-edit} mode, where
10064 you complete your half-finished entry in a separate buffer.
10065 @xref{Editing Stack Entries}.
10068 @pindex calc-algebraic-mode
10069 @cindex Algebraic Mode
10070 If you prefer algebraic entry, you can use the command @kbd{m a}
10071 (@code{calc-algebraic-mode}) to set Algebraic mode. In this mode,
10072 digits and other keys that would normally start numeric entry instead
10073 start full algebraic entry; as long as your formula begins with a digit
10074 you can omit the apostrophe. Open parentheses and square brackets also
10075 begin algebraic entry. You can still do RPN calculations in this mode,
10076 but you will have to press @key{RET} to terminate every number:
10077 @kbd{2 @key{RET} 3 @key{RET} * 4 @key{RET} +} would accomplish the same
10078 thing as @kbd{2*3+4 @key{RET}}.
10080 @cindex Incomplete Algebraic Mode
10081 If you give a numeric prefix argument like @kbd{C-u} to the @kbd{m a}
10082 command, it enables Incomplete Algebraic mode; this is like regular
10083 Algebraic mode except that it applies to the @kbd{(} and @kbd{[} keys
10084 only. Numeric keys still begin a numeric entry in this mode.
10087 @pindex calc-total-algebraic-mode
10088 @cindex Total Algebraic Mode
10089 The @kbd{m t} (@code{calc-total-algebraic-mode}) gives you an even
10090 stronger algebraic-entry mode, in which @emph{all} regular letter and
10091 punctuation keys begin algebraic entry. Use this if you prefer typing
10092 @w{@kbd{sqrt( )}} instead of @kbd{Q}, @w{@kbd{factor( )}} instead of
10093 @kbd{a f}, and so on. To type regular Calc commands when you are in
10094 Total Algebraic mode, hold down the @key{META} key. Thus @kbd{M-q}
10095 is the command to quit Calc, @kbd{M-p} sets the precision, and
10096 @kbd{M-m t} (or @kbd{M-m M-t}, if you prefer) turns Total Algebraic
10097 mode back off again. Meta keys also terminate algebraic entry, so
10098 that @kbd{2+3 M-S} is equivalent to @kbd{2+3 @key{RET} M-S}. The symbol
10099 @samp{Alg*} will appear in the mode line whenever you are in this mode.
10101 Pressing @kbd{'} (the apostrophe) a second time re-enters the previous
10102 algebraic formula. You can then use the normal Emacs editing keys to
10103 modify this formula to your liking before pressing @key{RET}.
10106 @cindex Formulas, referring to stack
10107 Within a formula entered from the keyboard, the symbol @kbd{$}
10108 represents the number on the top of the stack. If an entered formula
10109 contains any @kbd{$} characters, the Calculator replaces the top of
10110 stack with that formula rather than simply pushing the formula onto the
10111 stack. Thus, @kbd{' 1+2 @key{RET}} pushes 3 on the stack, and @kbd{$*2
10112 @key{RET}} replaces it with 6. Note that the @kbd{$} key always
10113 initiates algebraic entry; the @kbd{'} is unnecessary if @kbd{$} is the
10114 first character in the new formula.
10116 Higher stack elements can be accessed from an entered formula with the
10117 symbols @kbd{$$}, @kbd{$$$}, and so on. The number of stack elements
10118 removed (to be replaced by the entered values) equals the number of dollar
10119 signs in the longest such symbol in the formula. For example, @samp{$$+$$$}
10120 adds the second and third stack elements, replacing the top three elements
10121 with the answer. (All information about the top stack element is thus lost
10122 since no single @samp{$} appears in this formula.)
10124 A slightly different way to refer to stack elements is with a dollar
10125 sign followed by a number: @samp{$1}, @samp{$2}, and so on are much
10126 like @samp{$}, @samp{$$}, etc., except that stack entries referred
10127 to numerically are not replaced by the algebraic entry. That is, while
10128 @samp{$+1} replaces 5 on the stack with 6, @samp{$1+1} leaves the 5
10129 on the stack and pushes an additional 6.
10131 If a sequence of formulas are entered separated by commas, each formula
10132 is pushed onto the stack in turn. For example, @samp{1,2,3} pushes
10133 those three numbers onto the stack (leaving the 3 at the top), and
10134 @samp{$+1,$-1} replaces a 5 on the stack with 4 followed by 6. Also,
10135 @samp{$,$$} exchanges the top two elements of the stack, just like the
10138 You can finish an algebraic entry with @kbd{M-=} or @kbd{M-@key{RET}} instead
10139 of @key{RET}. This uses @kbd{=} to evaluate the variables in each
10140 formula that goes onto the stack. (Thus @kbd{' pi @key{RET}} pushes
10141 the variable @samp{pi}, but @kbd{' pi M-@key{RET}} pushes 3.1415.)
10143 If you finish your algebraic entry by pressing @key{LFD} (or @kbd{C-j})
10144 instead of @key{RET}, Calc disables the default simplifications
10145 (as if by @kbd{m O}; @pxref{Simplification Modes}) while the entry
10146 is being pushed on the stack. Thus @kbd{' 1+2 @key{RET}} pushes 3
10147 on the stack, but @kbd{' 1+2 @key{LFD}} pushes the formula @expr{1+2};
10148 you might then press @kbd{=} when it is time to evaluate this formula.
10150 @node Quick Calculator, Prefix Arguments, Algebraic Entry, Introduction
10151 @section ``Quick Calculator'' Mode
10156 @cindex Quick Calculator
10157 There is another way to invoke the Calculator if all you need to do
10158 is make one or two quick calculations. Type @kbd{C-x * q} (or
10159 @kbd{M-x quick-calc}), then type any formula as an algebraic entry.
10160 The Calculator will compute the result and display it in the echo
10161 area, without ever actually putting up a Calc window.
10163 You can use the @kbd{$} character in a Quick Calculator formula to
10164 refer to the previous Quick Calculator result. Older results are
10165 not retained; the Quick Calculator has no effect on the full
10166 Calculator's stack or trail. If you compute a result and then
10167 forget what it was, just run @code{C-x * q} again and enter
10168 @samp{$} as the formula.
10170 If this is the first time you have used the Calculator in this Emacs
10171 session, the @kbd{C-x * q} command will create the @code{*Calculator*}
10172 buffer and perform all the usual initializations; it simply will
10173 refrain from putting that buffer up in a new window. The Quick
10174 Calculator refers to the @code{*Calculator*} buffer for all mode
10175 settings. Thus, for example, to set the precision that the Quick
10176 Calculator uses, simply run the full Calculator momentarily and use
10177 the regular @kbd{p} command.
10179 If you use @code{C-x * q} from inside the Calculator buffer, the
10180 effect is the same as pressing the apostrophe key (algebraic entry).
10182 The result of a Quick calculation is placed in the Emacs ``kill ring''
10183 as well as being displayed. A subsequent @kbd{C-y} command will
10184 yank the result into the editing buffer. You can also use this
10185 to yank the result into the next @kbd{C-x * q} input line as a more
10186 explicit alternative to @kbd{$} notation, or to yank the result
10187 into the Calculator stack after typing @kbd{C-x * c}.
10189 If you finish your formula by typing @key{LFD} (or @kbd{C-j}) instead
10190 of @key{RET}, the result is inserted immediately into the current
10191 buffer rather than going into the kill ring.
10193 Quick Calculator results are actually evaluated as if by the @kbd{=}
10194 key (which replaces variable names by their stored values, if any).
10195 If the formula you enter is an assignment to a variable using the
10196 @samp{:=} operator, say, @samp{foo := 2 + 3} or @samp{foo := foo + 1},
10197 then the result of the evaluation is stored in that Calc variable.
10198 @xref{Store and Recall}.
10200 If the result is an integer and the current display radix is decimal,
10201 the number will also be displayed in hex, octal and binary formats. If
10202 the integer is in the range from 1 to 126, it will also be displayed as
10203 an ASCII character.
10205 For example, the quoted character @samp{"x"} produces the vector
10206 result @samp{[120]} (because 120 is the ASCII code of the lower-case
10207 `x'; @pxref{Strings}). Since this is a vector, not an integer, it
10208 is displayed only according to the current mode settings. But
10209 running Quick Calc again and entering @samp{120} will produce the
10210 result @samp{120 (16#78, 8#170, x)} which shows the number in its
10211 decimal, hexadecimal, octal, and ASCII forms.
10213 Please note that the Quick Calculator is not any faster at loading
10214 or computing the answer than the full Calculator; the name ``quick''
10215 merely refers to the fact that it's much less hassle to use for
10216 small calculations.
10218 @node Prefix Arguments, Undo, Quick Calculator, Introduction
10219 @section Numeric Prefix Arguments
10222 Many Calculator commands use numeric prefix arguments. Some, such as
10223 @kbd{d s} (@code{calc-sci-notation}), set a parameter to the value of
10224 the prefix argument or use a default if you don't use a prefix.
10225 Others (like @kbd{d f} (@code{calc-fix-notation})) require an argument
10226 and prompt for a number if you don't give one as a prefix.
10228 As a rule, stack-manipulation commands accept a numeric prefix argument
10229 which is interpreted as an index into the stack. A positive argument
10230 operates on the top @var{n} stack entries; a negative argument operates
10231 on the @var{n}th stack entry in isolation; and a zero argument operates
10232 on the entire stack.
10234 Most commands that perform computations (such as the arithmetic and
10235 scientific functions) accept a numeric prefix argument that allows the
10236 operation to be applied across many stack elements. For unary operations
10237 (that is, functions of one argument like absolute value or complex
10238 conjugate), a positive prefix argument applies that function to the top
10239 @var{n} stack entries simultaneously, and a negative argument applies it
10240 to the @var{n}th stack entry only. For binary operations (functions of
10241 two arguments like addition, GCD, and vector concatenation), a positive
10242 prefix argument ``reduces'' the function across the top @var{n}
10243 stack elements (for example, @kbd{C-u 5 +} sums the top 5 stack entries;
10244 @pxref{Reducing and Mapping}), and a negative argument maps the next-to-top
10245 @var{n} stack elements with the top stack element as a second argument
10246 (for example, @kbd{7 c-u -5 +} adds 7 to the top 5 stack elements).
10247 This feature is not available for operations which use the numeric prefix
10248 argument for some other purpose.
10250 Numeric prefixes are specified the same way as always in Emacs: Press
10251 a sequence of @key{META}-digits, or press @key{ESC} followed by digits,
10252 or press @kbd{C-u} followed by digits. Some commands treat plain
10253 @kbd{C-u} (without any actual digits) specially.
10256 @pindex calc-num-prefix
10257 You can type @kbd{~} (@code{calc-num-prefix}) to pop an integer from the
10258 top of the stack and enter it as the numeric prefix for the next command.
10259 For example, @kbd{C-u 16 p} sets the precision to 16 digits; an alternate
10260 (silly) way to do this would be @kbd{2 @key{RET} 4 ^ ~ p}, i.e., compute 2
10261 to the fourth power and set the precision to that value.
10263 Conversely, if you have typed a numeric prefix argument the @kbd{~} key
10264 pushes it onto the stack in the form of an integer.
10266 @node Undo, Error Messages, Prefix Arguments, Introduction
10267 @section Undoing Mistakes
10273 @cindex Mistakes, undoing
10274 @cindex Undoing mistakes
10275 @cindex Errors, undoing
10276 The shift-@kbd{U} key (@code{calc-undo}) undoes the most recent operation.
10277 If that operation added or dropped objects from the stack, those objects
10278 are removed or restored. If it was a ``store'' operation, you are
10279 queried whether or not to restore the variable to its original value.
10280 The @kbd{U} key may be pressed any number of times to undo successively
10281 farther back in time; with a numeric prefix argument it undoes a
10282 specified number of operations. When the Calculator is quit, as with
10283 the @kbd{q} (@code{calc-quit}) command, the undo history will be
10284 truncated to the length of the customizable variable
10285 @code{calc-undo-length} (@pxref{Customizing Calc}), which by default
10286 is @expr{100}. (Recall that @kbd{C-x * c} is synonymous with
10287 @code{calc-quit} while inside the Calculator; this also truncates the
10290 Currently the mode-setting commands (like @code{calc-precision}) are not
10291 undoable. You can undo past a point where you changed a mode, but you
10292 will need to reset the mode yourself.
10296 @cindex Redoing after an Undo
10297 The shift-@kbd{D} key (@code{calc-redo}) redoes an operation that was
10298 mistakenly undone. Pressing @kbd{U} with a negative prefix argument is
10299 equivalent to executing @code{calc-redo}. You can redo any number of
10300 times, up to the number of recent consecutive undo commands. Redo
10301 information is cleared whenever you give any command that adds new undo
10302 information, i.e., if you undo, then enter a number on the stack or make
10303 any other change, then it will be too late to redo.
10305 @kindex M-@key{RET}
10306 @pindex calc-last-args
10307 @cindex Last-arguments feature
10308 @cindex Arguments, restoring
10309 The @kbd{M-@key{RET}} key (@code{calc-last-args}) is like undo in that
10310 it restores the arguments of the most recent command onto the stack;
10311 however, it does not remove the result of that command. Given a numeric
10312 prefix argument, this command applies to the @expr{n}th most recent
10313 command which removed items from the stack; it pushes those items back
10316 The @kbd{K} (@code{calc-keep-args}) command provides a related function
10317 to @kbd{M-@key{RET}}. @xref{Stack and Trail}.
10319 It is also possible to recall previous results or inputs using the trail.
10320 @xref{Trail Commands}.
10322 The standard Emacs @kbd{C-_} undo key is recognized as a synonym for @kbd{U}.
10324 @node Error Messages, Multiple Calculators, Undo, Introduction
10325 @section Error Messages
10330 @cindex Errors, messages
10331 @cindex Why did an error occur?
10332 Many situations that would produce an error message in other calculators
10333 simply create unsimplified formulas in the Emacs Calculator. For example,
10334 @kbd{1 @key{RET} 0 /} pushes the formula @expr{1 / 0}; @w{@kbd{0 L}} pushes
10335 the formula @samp{ln(0)}. Floating-point overflow and underflow are also
10336 reasons for this to happen.
10338 When a function call must be left in symbolic form, Calc usually
10339 produces a message explaining why. Messages that are probably
10340 surprising or indicative of user errors are displayed automatically.
10341 Other messages are simply kept in Calc's memory and are displayed only
10342 if you type @kbd{w} (@code{calc-why}). You can also press @kbd{w} if
10343 the same computation results in several messages. (The first message
10344 will end with @samp{[w=more]} in this case.)
10347 @pindex calc-auto-why
10348 The @kbd{d w} (@code{calc-auto-why}) command controls when error messages
10349 are displayed automatically. (Calc effectively presses @kbd{w} for you
10350 after your computation finishes.) By default, this occurs only for
10351 ``important'' messages. The other possible modes are to report
10352 @emph{all} messages automatically, or to report none automatically (so
10353 that you must always press @kbd{w} yourself to see the messages).
10355 @node Multiple Calculators, Troubleshooting Commands, Error Messages, Introduction
10356 @section Multiple Calculators
10359 @pindex another-calc
10360 It is possible to have any number of Calc mode buffers at once.
10361 Usually this is done by executing @kbd{M-x another-calc}, which
10362 is similar to @kbd{C-x * c} except that if a @samp{*Calculator*}
10363 buffer already exists, a new, independent one with a name of the
10364 form @samp{*Calculator*<@var{n}>} is created. You can also use the
10365 command @code{calc-mode} to put any buffer into Calculator mode, but
10366 this would ordinarily never be done.
10368 The @kbd{q} (@code{calc-quit}) command does not destroy a Calculator buffer;
10369 it only closes its window. Use @kbd{M-x kill-buffer} to destroy a
10372 Each Calculator buffer keeps its own stack, undo list, and mode settings
10373 such as precision, angular mode, and display formats. In Emacs terms,
10374 variables such as @code{calc-stack} are buffer-local variables. The
10375 global default values of these variables are used only when a new
10376 Calculator buffer is created. The @code{calc-quit} command saves
10377 the stack and mode settings of the buffer being quit as the new defaults.
10379 There is only one trail buffer, @samp{*Calc Trail*}, used by all
10380 Calculator buffers.
10382 @node Troubleshooting Commands, , Multiple Calculators, Introduction
10383 @section Troubleshooting Commands
10386 This section describes commands you can use in case a computation
10387 incorrectly fails or gives the wrong answer.
10389 @xref{Reporting Bugs}, if you find a problem that appears to be due
10390 to a bug or deficiency in Calc.
10393 * Autoloading Problems::
10394 * Recursion Depth::
10399 @node Autoloading Problems, Recursion Depth, Troubleshooting Commands, Troubleshooting Commands
10400 @subsection Autoloading Problems
10403 The Calc program is split into many component files; components are
10404 loaded automatically as you use various commands that require them.
10405 Occasionally Calc may lose track of when a certain component is
10406 necessary; typically this means you will type a command and it won't
10407 work because some function you've never heard of was undefined.
10410 @pindex calc-load-everything
10411 If this happens, the easiest workaround is to type @kbd{C-x * L}
10412 (@code{calc-load-everything}) to force all the parts of Calc to be
10413 loaded right away. This will cause Emacs to take up a lot more
10414 memory than it would otherwise, but it's guaranteed to fix the problem.
10416 @node Recursion Depth, Caches, Autoloading Problems, Troubleshooting Commands
10417 @subsection Recursion Depth
10422 @pindex calc-more-recursion-depth
10423 @pindex calc-less-recursion-depth
10424 @cindex Recursion depth
10425 @cindex ``Computation got stuck'' message
10426 @cindex @code{max-lisp-eval-depth}
10427 @cindex @code{max-specpdl-size}
10428 Calc uses recursion in many of its calculations. Emacs Lisp keeps a
10429 variable @code{max-lisp-eval-depth} which limits the amount of recursion
10430 possible in an attempt to recover from program bugs. If a calculation
10431 ever halts incorrectly with the message ``Computation got stuck or
10432 ran too long,'' use the @kbd{M} command (@code{calc-more-recursion-depth})
10433 to increase this limit. (Of course, this will not help if the
10434 calculation really did get stuck due to some problem inside Calc.)
10436 The limit is always increased (multiplied) by a factor of two. There
10437 is also an @kbd{I M} (@code{calc-less-recursion-depth}) command which
10438 decreases this limit by a factor of two, down to a minimum value of 200.
10439 The default value is 1000.
10441 These commands also double or halve @code{max-specpdl-size}, another
10442 internal Lisp recursion limit. The minimum value for this limit is 600.
10444 @node Caches, Debugging Calc, Recursion Depth, Troubleshooting Commands
10449 @cindex Flushing caches
10450 Calc saves certain values after they have been computed once. For
10451 example, the @kbd{P} (@code{calc-pi}) command initially ``knows'' the
10452 constant @cpi{} to about 20 decimal places; if the current precision
10453 is greater than this, it will recompute @cpi{} using a series
10454 approximation. This value will not need to be recomputed ever again
10455 unless you raise the precision still further. Many operations such as
10456 logarithms and sines make use of similarly cached values such as
10458 @texline @math{\ln 2}.
10459 @infoline @expr{ln(2)}.
10460 The visible effect of caching is that
10461 high-precision computations may seem to do extra work the first time.
10462 Other things cached include powers of two (for the binary arithmetic
10463 functions), matrix inverses and determinants, symbolic integrals, and
10464 data points computed by the graphing commands.
10466 @pindex calc-flush-caches
10467 If you suspect a Calculator cache has become corrupt, you can use the
10468 @code{calc-flush-caches} command to reset all caches to the empty state.
10469 (This should only be necessary in the event of bugs in the Calculator.)
10470 The @kbd{C-x * 0} (with the zero key) command also resets caches along
10471 with all other aspects of the Calculator's state.
10473 @node Debugging Calc, , Caches, Troubleshooting Commands
10474 @subsection Debugging Calc
10477 A few commands exist to help in the debugging of Calc commands.
10478 @xref{Programming}, to see the various ways that you can write
10479 your own Calc commands.
10482 @pindex calc-timing
10483 The @kbd{Z T} (@code{calc-timing}) command turns on and off a mode
10484 in which the timing of slow commands is reported in the Trail.
10485 Any Calc command that takes two seconds or longer writes a line
10486 to the Trail showing how many seconds it took. This value is
10487 accurate only to within one second.
10489 All steps of executing a command are included; in particular, time
10490 taken to format the result for display in the stack and trail is
10491 counted. Some prompts also count time taken waiting for them to
10492 be answered, while others do not; this depends on the exact
10493 implementation of the command. For best results, if you are timing
10494 a sequence that includes prompts or multiple commands, define a
10495 keyboard macro to run the whole sequence at once. Calc's @kbd{X}
10496 command (@pxref{Keyboard Macros}) will then report the time taken
10497 to execute the whole macro.
10499 Another advantage of the @kbd{X} command is that while it is
10500 executing, the stack and trail are not updated from step to step.
10501 So if you expect the output of your test sequence to leave a result
10502 that may take a long time to format and you don't wish to count
10503 this formatting time, end your sequence with a @key{DEL} keystroke
10504 to clear the result from the stack. When you run the sequence with
10505 @kbd{X}, Calc will never bother to format the large result.
10507 Another thing @kbd{Z T} does is to increase the Emacs variable
10508 @code{gc-cons-threshold} to a much higher value (two million; the
10509 usual default in Calc is 250,000) for the duration of each command.
10510 This generally prevents garbage collection during the timing of
10511 the command, though it may cause your Emacs process to grow
10512 abnormally large. (Garbage collection time is a major unpredictable
10513 factor in the timing of Emacs operations.)
10515 Another command that is useful when debugging your own Lisp
10516 extensions to Calc is @kbd{M-x calc-pass-errors}, which disables
10517 the error handler that changes the ``@code{max-lisp-eval-depth}
10518 exceeded'' message to the much more friendly ``Computation got
10519 stuck or ran too long.'' This handler interferes with the Emacs
10520 Lisp debugger's @code{debug-on-error} mode. Errors are reported
10521 in the handler itself rather than at the true location of the
10522 error. After you have executed @code{calc-pass-errors}, Lisp
10523 errors will be reported correctly but the user-friendly message
10526 @node Data Types, Stack and Trail, Introduction, Top
10527 @chapter Data Types
10530 This chapter discusses the various types of objects that can be placed
10531 on the Calculator stack, how they are displayed, and how they are
10532 entered. (@xref{Data Type Formats}, for information on how these data
10533 types are represented as underlying Lisp objects.)
10535 Integers, fractions, and floats are various ways of describing real
10536 numbers. HMS forms also for many purposes act as real numbers. These
10537 types can be combined to form complex numbers, modulo forms, error forms,
10538 or interval forms. (But these last four types cannot be combined
10539 arbitrarily:@: error forms may not contain modulo forms, for example.)
10540 Finally, all these types of numbers may be combined into vectors,
10541 matrices, or algebraic formulas.
10544 * Integers:: The most basic data type.
10545 * Fractions:: This and above are called @dfn{rationals}.
10546 * Floats:: This and above are called @dfn{reals}.
10547 * Complex Numbers:: This and above are called @dfn{numbers}.
10549 * Vectors and Matrices::
10556 * Incomplete Objects::
10561 @node Integers, Fractions, Data Types, Data Types
10566 The Calculator stores integers to arbitrary precision. Addition,
10567 subtraction, and multiplication of integers always yields an exact
10568 integer result. (If the result of a division or exponentiation of
10569 integers is not an integer, it is expressed in fractional or
10570 floating-point form according to the current Fraction mode.
10571 @xref{Fraction Mode}.)
10573 A decimal integer is represented as an optional sign followed by a
10574 sequence of digits. Grouping (@pxref{Grouping Digits}) can be used to
10575 insert a comma at every third digit for display purposes, but you
10576 must not type commas during the entry of numbers.
10579 A non-decimal integer is represented as an optional sign, a radix
10580 between 2 and 36, a @samp{#} symbol, and one or more digits. For radix 11
10581 and above, the letters A through Z (upper- or lower-case) count as
10582 digits and do not terminate numeric entry mode. @xref{Radix Modes}, for how
10583 to set the default radix for display of integers. Numbers of any radix
10584 may be entered at any time. If you press @kbd{#} at the beginning of a
10585 number, the current display radix is used.
10587 @node Fractions, Floats, Integers, Data Types
10592 A @dfn{fraction} is a ratio of two integers. Fractions are traditionally
10593 written ``2/3'' but Calc uses the notation @samp{2:3}. (The @kbd{/} key
10594 performs RPN division; the following two sequences push the number
10595 @samp{2:3} on the stack: @kbd{2 :@: 3 @key{RET}}, or @kbd{2 @key{RET} 3 /}
10596 assuming Fraction mode has been enabled.)
10597 When the Calculator produces a fractional result it always reduces it to
10598 simplest form, which may in fact be an integer.
10600 Fractions may also be entered in a three-part form, where @samp{2:3:4}
10601 represents two-and-three-quarters. @xref{Fraction Formats}, for fraction
10604 Non-decimal fractions are entered and displayed as
10605 @samp{@var{radix}#@var{num}:@var{denom}} (or in the analogous three-part
10606 form). The numerator and denominator always use the same radix.
10608 @node Floats, Complex Numbers, Fractions, Data Types
10612 @cindex Floating-point numbers
10613 A floating-point number or @dfn{float} is a number stored in scientific
10614 notation. The number of significant digits in the fractional part is
10615 governed by the current floating precision (@pxref{Precision}). The
10616 range of acceptable values is from
10617 @texline @math{10^{-3999999}}
10618 @infoline @expr{10^-3999999}
10620 @texline @math{10^{4000000}}
10621 @infoline @expr{10^4000000}
10622 (exclusive), plus the corresponding negative values and zero.
10624 Calculations that would exceed the allowable range of values (such
10625 as @samp{exp(exp(20))}) are left in symbolic form by Calc. The
10626 messages ``floating-point overflow'' or ``floating-point underflow''
10627 indicate that during the calculation a number would have been produced
10628 that was too large or too close to zero, respectively, to be represented
10629 by Calc. This does not necessarily mean the final result would have
10630 overflowed, just that an overflow occurred while computing the result.
10631 (In fact, it could report an underflow even though the final result
10632 would have overflowed!)
10634 If a rational number and a float are mixed in a calculation, the result
10635 will in general be expressed as a float. Commands that require an integer
10636 value (such as @kbd{k g} [@code{gcd}]) will also accept integer-valued
10637 floats, i.e., floating-point numbers with nothing after the decimal point.
10639 Floats are identified by the presence of a decimal point and/or an
10640 exponent. In general a float consists of an optional sign, digits
10641 including an optional decimal point, and an optional exponent consisting
10642 of an @samp{e}, an optional sign, and up to seven exponent digits.
10643 For example, @samp{23.5e-2} is 23.5 times ten to the minus-second power,
10646 Floating-point numbers are normally displayed in decimal notation with
10647 all significant figures shown. Exceedingly large or small numbers are
10648 displayed in scientific notation. Various other display options are
10649 available. @xref{Float Formats}.
10651 @cindex Accuracy of calculations
10652 Floating-point numbers are stored in decimal, not binary. The result
10653 of each operation is rounded to the nearest value representable in the
10654 number of significant digits specified by the current precision,
10655 rounding away from zero in the case of a tie. Thus (in the default
10656 display mode) what you see is exactly what you get. Some operations such
10657 as square roots and transcendental functions are performed with several
10658 digits of extra precision and then rounded down, in an effort to make the
10659 final result accurate to the full requested precision. However,
10660 accuracy is not rigorously guaranteed. If you suspect the validity of a
10661 result, try doing the same calculation in a higher precision. The
10662 Calculator's arithmetic is not intended to be IEEE-conformant in any
10665 While floats are always @emph{stored} in decimal, they can be entered
10666 and displayed in any radix just like integers and fractions. Since a
10667 float that is entered in a radix other that 10 will be converted to
10668 decimal, the number that Calc stores may not be exactly the number that
10669 was entered, it will be the closest decimal approximation given the
10670 current precison. The notation @samp{@var{radix}#@var{ddd}.@var{ddd}}
10671 is a floating-point number whose digits are in the specified radix.
10672 Note that the @samp{.} is more aptly referred to as a ``radix point''
10673 than as a decimal point in this case. The number @samp{8#123.4567} is
10674 defined as @samp{8#1234567 * 8^-4}. If the radix is 14 or less, you can
10675 use @samp{e} notation to write a non-decimal number in scientific
10676 notation. The exponent is written in decimal, and is considered to be a
10677 power of the radix: @samp{8#1234567e-4}. If the radix is 15 or above,
10678 the letter @samp{e} is a digit, so scientific notation must be written
10679 out, e.g., @samp{16#123.4567*16^2}. The first two exercises of the
10680 Modes Tutorial explore some of the properties of non-decimal floats.
10682 @node Complex Numbers, Infinities, Floats, Data Types
10683 @section Complex Numbers
10686 @cindex Complex numbers
10687 There are two supported formats for complex numbers: rectangular and
10688 polar. The default format is rectangular, displayed in the form
10689 @samp{(@var{real},@var{imag})} where @var{real} is the real part and
10690 @var{imag} is the imaginary part, each of which may be any real number.
10691 Rectangular complex numbers can also be displayed in @samp{@var{a}+@var{b}i}
10692 notation; @pxref{Complex Formats}.
10694 Polar complex numbers are displayed in the form
10695 @texline `@tfn{(}@var{r}@tfn{;}@math{\theta}@tfn{)}'
10696 @infoline `@tfn{(}@var{r}@tfn{;}@var{theta}@tfn{)}'
10697 where @var{r} is the nonnegative magnitude and
10698 @texline @math{\theta}
10699 @infoline @var{theta}
10700 is the argument or phase angle. The range of
10701 @texline @math{\theta}
10702 @infoline @var{theta}
10703 depends on the current angular mode (@pxref{Angular Modes}); it is
10704 generally between @mathit{-180} and @mathit{+180} degrees or the equivalent range
10707 Complex numbers are entered in stages using incomplete objects.
10708 @xref{Incomplete Objects}.
10710 Operations on rectangular complex numbers yield rectangular complex
10711 results, and similarly for polar complex numbers. Where the two types
10712 are mixed, or where new complex numbers arise (as for the square root of
10713 a negative real), the current @dfn{Polar mode} is used to determine the
10714 type. @xref{Polar Mode}.
10716 A complex result in which the imaginary part is zero (or the phase angle
10717 is 0 or 180 degrees or @cpi{} radians) is automatically converted to a real
10720 @node Infinities, Vectors and Matrices, Complex Numbers, Data Types
10721 @section Infinities
10725 @cindex @code{inf} variable
10726 @cindex @code{uinf} variable
10727 @cindex @code{nan} variable
10731 The word @code{inf} represents the mathematical concept of @dfn{infinity}.
10732 Calc actually has three slightly different infinity-like values:
10733 @code{inf}, @code{uinf}, and @code{nan}. These are just regular
10734 variable names (@pxref{Variables}); you should avoid using these
10735 names for your own variables because Calc gives them special
10736 treatment. Infinities, like all variable names, are normally
10737 entered using algebraic entry.
10739 Mathematically speaking, it is not rigorously correct to treat
10740 ``infinity'' as if it were a number, but mathematicians often do
10741 so informally. When they say that @samp{1 / inf = 0}, what they
10742 really mean is that @expr{1 / x}, as @expr{x} becomes larger and
10743 larger, becomes arbitrarily close to zero. So you can imagine
10744 that if @expr{x} got ``all the way to infinity,'' then @expr{1 / x}
10745 would go all the way to zero. Similarly, when they say that
10746 @samp{exp(inf) = inf}, they mean that
10747 @texline @math{e^x}
10748 @infoline @expr{exp(x)}
10749 grows without bound as @expr{x} grows. The symbol @samp{-inf} likewise
10750 stands for an infinitely negative real value; for example, we say that
10751 @samp{exp(-inf) = 0}. You can have an infinity pointing in any
10752 direction on the complex plane: @samp{sqrt(-inf) = i inf}.
10754 The same concept of limits can be used to define @expr{1 / 0}. We
10755 really want the value that @expr{1 / x} approaches as @expr{x}
10756 approaches zero. But if all we have is @expr{1 / 0}, we can't
10757 tell which direction @expr{x} was coming from. If @expr{x} was
10758 positive and decreasing toward zero, then we should say that
10759 @samp{1 / 0 = inf}. But if @expr{x} was negative and increasing
10760 toward zero, the answer is @samp{1 / 0 = -inf}. In fact, @expr{x}
10761 could be an imaginary number, giving the answer @samp{i inf} or
10762 @samp{-i inf}. Calc uses the special symbol @samp{uinf} to mean
10763 @dfn{undirected infinity}, i.e., a value which is infinitely
10764 large but with an unknown sign (or direction on the complex plane).
10766 Calc actually has three modes that say how infinities are handled.
10767 Normally, infinities never arise from calculations that didn't
10768 already have them. Thus, @expr{1 / 0} is treated simply as an
10769 error and left unevaluated. The @kbd{m i} (@code{calc-infinite-mode})
10770 command (@pxref{Infinite Mode}) enables a mode in which
10771 @expr{1 / 0} evaluates to @code{uinf} instead. There is also
10772 an alternative type of infinite mode which says to treat zeros
10773 as if they were positive, so that @samp{1 / 0 = inf}. While this
10774 is less mathematically correct, it may be the answer you want in
10777 Since all infinities are ``as large'' as all others, Calc simplifies,
10778 e.g., @samp{5 inf} to @samp{inf}. Another example is
10779 @samp{5 - inf = -inf}, where the @samp{-inf} is so large that
10780 adding a finite number like five to it does not affect it.
10781 Note that @samp{a - inf} also results in @samp{-inf}; Calc assumes
10782 that variables like @code{a} always stand for finite quantities.
10783 Just to show that infinities really are all the same size,
10784 note that @samp{sqrt(inf) = inf^2 = exp(inf) = inf} in Calc's
10787 It's not so easy to define certain formulas like @samp{0 * inf} and
10788 @samp{inf / inf}. Depending on where these zeros and infinities
10789 came from, the answer could be literally anything. The latter
10790 formula could be the limit of @expr{x / x} (giving a result of one),
10791 or @expr{2 x / x} (giving two), or @expr{x^2 / x} (giving @code{inf}),
10792 or @expr{x / x^2} (giving zero). Calc uses the symbol @code{nan}
10793 to represent such an @dfn{indeterminate} value. (The name ``nan''
10794 comes from analogy with the ``NAN'' concept of IEEE standard
10795 arithmetic; it stands for ``Not A Number.'' This is somewhat of a
10796 misnomer, since @code{nan} @emph{does} stand for some number or
10797 infinity, it's just that @emph{which} number it stands for
10798 cannot be determined.) In Calc's notation, @samp{0 * inf = nan}
10799 and @samp{inf / inf = nan}. A few other common indeterminate
10800 expressions are @samp{inf - inf} and @samp{inf ^ 0}. Also,
10801 @samp{0 / 0 = nan} if you have turned on Infinite mode
10802 (as described above).
10804 Infinities are especially useful as parts of @dfn{intervals}.
10805 @xref{Interval Forms}.
10807 @node Vectors and Matrices, Strings, Infinities, Data Types
10808 @section Vectors and Matrices
10812 @cindex Plain vectors
10814 The @dfn{vector} data type is flexible and general. A vector is simply a
10815 list of zero or more data objects. When these objects are numbers, the
10816 whole is a vector in the mathematical sense. When these objects are
10817 themselves vectors of equal (nonzero) length, the whole is a @dfn{matrix}.
10818 A vector which is not a matrix is referred to here as a @dfn{plain vector}.
10820 A vector is displayed as a list of values separated by commas and enclosed
10821 in square brackets: @samp{[1, 2, 3]}. Thus the following is a 2 row by
10822 3 column matrix: @samp{[[1, 2, 3], [4, 5, 6]]}. Vectors, like complex
10823 numbers, are entered as incomplete objects. @xref{Incomplete Objects}.
10824 During algebraic entry, vectors are entered all at once in the usual
10825 brackets-and-commas form. Matrices may be entered algebraically as nested
10826 vectors, or using the shortcut notation @w{@samp{[1, 2, 3; 4, 5, 6]}},
10827 with rows separated by semicolons. The commas may usually be omitted
10828 when entering vectors: @samp{[1 2 3]}. Curly braces may be used in
10829 place of brackets: @samp{@{1, 2, 3@}}, but the commas are required in
10832 Traditional vector and matrix arithmetic is also supported;
10833 @pxref{Basic Arithmetic} and @pxref{Matrix Functions}.
10834 Many other operations are applied to vectors element-wise. For example,
10835 the complex conjugate of a vector is a vector of the complex conjugates
10842 Algebraic functions for building vectors include @samp{vec(a, b, c)}
10843 to build @samp{[a, b, c]}, @samp{cvec(a, n, m)} to build an
10844 @texline @math{n\times m}
10845 @infoline @var{n}x@var{m}
10846 matrix of @samp{a}s, and @samp{index(n)} to build a vector of integers
10847 from 1 to @samp{n}.
10849 @node Strings, HMS Forms, Vectors and Matrices, Data Types
10855 @cindex Character strings
10856 Character strings are not a special data type in the Calculator.
10857 Rather, a string is represented simply as a vector all of whose
10858 elements are integers in the range 0 to 255 (ASCII codes). You can
10859 enter a string at any time by pressing the @kbd{"} key. Quotation
10860 marks and backslashes are written @samp{\"} and @samp{\\}, respectively,
10861 inside strings. Other notations introduced by backslashes are:
10877 Finally, a backslash followed by three octal digits produces any
10878 character from its ASCII code.
10881 @pindex calc-display-strings
10882 Strings are normally displayed in vector-of-integers form. The
10883 @w{@kbd{d "}} (@code{calc-display-strings}) command toggles a mode in
10884 which any vectors of small integers are displayed as quoted strings
10887 The backslash notations shown above are also used for displaying
10888 strings. Characters 128 and above are not translated by Calc; unless
10889 you have an Emacs modified for 8-bit fonts, these will show up in
10890 backslash-octal-digits notation. For characters below 32, and
10891 for character 127, Calc uses the backslash-letter combination if
10892 there is one, or otherwise uses a @samp{\^} sequence.
10894 The only Calc feature that uses strings is @dfn{compositions};
10895 @pxref{Compositions}. Strings also provide a convenient
10896 way to do conversions between ASCII characters and integers.
10902 There is a @code{string} function which provides a different display
10903 format for strings. Basically, @samp{string(@var{s})}, where @var{s}
10904 is a vector of integers in the proper range, is displayed as the
10905 corresponding string of characters with no surrounding quotation
10906 marks or other modifications. Thus @samp{string("ABC")} (or
10907 @samp{string([65 66 67])}) will look like @samp{ABC} on the stack.
10908 This happens regardless of whether @w{@kbd{d "}} has been used. The
10909 only way to turn it off is to use @kbd{d U} (unformatted language
10910 mode) which will display @samp{string("ABC")} instead.
10912 Control characters are displayed somewhat differently by @code{string}.
10913 Characters below 32, and character 127, are shown using @samp{^} notation
10914 (same as shown above, but without the backslash). The quote and
10915 backslash characters are left alone, as are characters 128 and above.
10921 The @code{bstring} function is just like @code{string} except that
10922 the resulting string is breakable across multiple lines if it doesn't
10923 fit all on one line. Potential break points occur at every space
10924 character in the string.
10926 @node HMS Forms, Date Forms, Strings, Data Types
10930 @cindex Hours-minutes-seconds forms
10931 @cindex Degrees-minutes-seconds forms
10932 @dfn{HMS} stands for Hours-Minutes-Seconds; when used as an angular
10933 argument, the interpretation is Degrees-Minutes-Seconds. All functions
10934 that operate on angles accept HMS forms. These are interpreted as
10935 degrees regardless of the current angular mode. It is also possible to
10936 use HMS as the angular mode so that calculated angles are expressed in
10937 degrees, minutes, and seconds.
10943 @kindex ' (HMS forms)
10947 @kindex " (HMS forms)
10951 @kindex h (HMS forms)
10955 @kindex o (HMS forms)
10959 @kindex m (HMS forms)
10963 @kindex s (HMS forms)
10964 The default format for HMS values is
10965 @samp{@var{hours}@@ @var{mins}' @var{secs}"}. During entry, the letters
10966 @samp{h} (for ``hours'') or
10967 @samp{o} (approximating the ``degrees'' symbol) are accepted as well as
10968 @samp{@@}, @samp{m} is accepted in place of @samp{'}, and @samp{s} is
10969 accepted in place of @samp{"}.
10970 The @var{hours} value is an integer (or integer-valued float).
10971 The @var{mins} value is an integer or integer-valued float between 0 and 59.
10972 The @var{secs} value is a real number between 0 (inclusive) and 60
10973 (exclusive). A positive HMS form is interpreted as @var{hours} +
10974 @var{mins}/60 + @var{secs}/3600. A negative HMS form is interpreted
10975 as @mathit{- @var{hours}} @mathit{-} @var{mins}/60 @mathit{-} @var{secs}/3600.
10976 Display format for HMS forms is quite flexible. @xref{HMS Formats}.
10978 HMS forms can be added and subtracted. When they are added to numbers,
10979 the numbers are interpreted according to the current angular mode. HMS
10980 forms can also be multiplied and divided by real numbers. Dividing
10981 two HMS forms produces a real-valued ratio of the two angles.
10984 @cindex Time of day
10985 Just for kicks, @kbd{M-x calc-time} pushes the current time of day on
10986 the stack as an HMS form.
10988 @node Date Forms, Modulo Forms, HMS Forms, Data Types
10989 @section Date Forms
10993 A @dfn{date form} represents a date and possibly an associated time.
10994 Simple date arithmetic is supported: Adding a number to a date
10995 produces a new date shifted by that many days; adding an HMS form to
10996 a date shifts it by that many hours. Subtracting two date forms
10997 computes the number of days between them (represented as a simple
10998 number). Many other operations, such as multiplying two date forms,
10999 are nonsensical and are not allowed by Calc.
11001 Date forms are entered and displayed enclosed in @samp{< >} brackets.
11002 The default format is, e.g., @samp{<Wed Jan 9, 1991>} for dates,
11003 or @samp{<3:32:20pm Wed Jan 9, 1991>} for dates with times.
11004 Input is flexible; date forms can be entered in any of the usual
11005 notations for dates and times. @xref{Date Formats}.
11007 Date forms are stored internally as numbers, specifically the number
11008 of days since midnight on the morning of January 1 of the year 1 AD.
11009 If the internal number is an integer, the form represents a date only;
11010 if the internal number is a fraction or float, the form represents
11011 a date and time. For example, @samp{<6:00am Wed Jan 9, 1991>}
11012 is represented by the number 726842.25. The standard precision of
11013 12 decimal digits is enough to ensure that a (reasonable) date and
11014 time can be stored without roundoff error.
11016 If the current precision is greater than 12, date forms will keep
11017 additional digits in the seconds position. For example, if the
11018 precision is 15, the seconds will keep three digits after the
11019 decimal point. Decreasing the precision below 12 may cause the
11020 time part of a date form to become inaccurate. This can also happen
11021 if astronomically high years are used, though this will not be an
11022 issue in everyday (or even everymillennium) use. Note that date
11023 forms without times are stored as exact integers, so roundoff is
11024 never an issue for them.
11026 You can use the @kbd{v p} (@code{calc-pack}) and @kbd{v u}
11027 (@code{calc-unpack}) commands to get at the numerical representation
11028 of a date form. @xref{Packing and Unpacking}.
11030 Date forms can go arbitrarily far into the future or past. Negative
11031 year numbers represent years BC. Calc uses a combination of the
11032 Gregorian and Julian calendars, following the history of Great
11033 Britain and the British colonies. This is the same calendar that
11034 is used by the @code{cal} program in most Unix implementations.
11036 @cindex Julian calendar
11037 @cindex Gregorian calendar
11038 Some historical background: The Julian calendar was created by
11039 Julius Caesar in the year 46 BC as an attempt to fix the gradual
11040 drift caused by the lack of leap years in the calendar used
11041 until that time. The Julian calendar introduced an extra day in
11042 all years divisible by four. After some initial confusion, the
11043 calendar was adopted around the year we call 8 AD. Some centuries
11044 later it became apparent that the Julian year of 365.25 days was
11045 itself not quite right. In 1582 Pope Gregory XIII introduced the
11046 Gregorian calendar, which added the new rule that years divisible
11047 by 100, but not by 400, were not to be considered leap years
11048 despite being divisible by four. Many countries delayed adoption
11049 of the Gregorian calendar because of religious differences;
11050 in Britain it was put off until the year 1752, by which time
11051 the Julian calendar had fallen eleven days behind the true
11052 seasons. So the switch to the Gregorian calendar in early
11053 September 1752 introduced a discontinuity: The day after
11054 Sep 2, 1752 is Sep 14, 1752. Calc follows this convention.
11055 To take another example, Russia waited until 1918 before
11056 adopting the new calendar, and thus needed to remove thirteen
11057 days (between Feb 1, 1918 and Feb 14, 1918). This means that
11058 Calc's reckoning will be inconsistent with Russian history between
11059 1752 and 1918, and similarly for various other countries.
11061 Today's timekeepers introduce an occasional ``leap second'' as
11062 well, but Calc does not take these minor effects into account.
11063 (If it did, it would have to report a non-integer number of days
11064 between, say, @samp{<12:00am Mon Jan 1, 1900>} and
11065 @samp{<12:00am Sat Jan 1, 2000>}.)
11067 Calc uses the Julian calendar for all dates before the year 1752,
11068 including dates BC when the Julian calendar technically had not
11069 yet been invented. Thus the claim that day number @mathit{-10000} is
11070 called ``August 16, 28 BC'' should be taken with a grain of salt.
11072 Please note that there is no ``year 0''; the day before
11073 @samp{<Sat Jan 1, +1>} is @samp{<Fri Dec 31, -1>}. These are
11074 days 0 and @mathit{-1} respectively in Calc's internal numbering scheme.
11076 @cindex Julian day counting
11077 Another day counting system in common use is, confusingly, also called
11078 ``Julian.'' The Julian day number is the numbers of days since
11079 12:00 noon (GMT) on Jan 1, 4713 BC, which in Calc's scheme (in GMT)
11080 is @mathit{-1721423.5} (recall that Calc starts at midnight instead
11081 of noon). Thus to convert a Calc date code obtained by unpacking a
11082 date form into a Julian day number, simply add 1721423.5 after
11083 compensating for the time zone difference. The built-in @kbd{t J}
11084 command performs this conversion for you.
11086 The Julian day number is based on the Julian cycle, which was invented
11087 in 1583 by Joseph Justus Scaliger. Scaliger named it the Julian cycle
11088 since it involves the Julian calendar, but some have suggested that
11089 Scaliger named it in honor of his father, Julius Caesar Scaliger. The
11090 Julian cycle is based on three other cycles: the indiction cycle, the
11091 Metonic cycle, and the solar cycle. The indiction cycle is a 15 year
11092 cycle originally used by the Romans for tax purposes but later used to
11093 date medieval documents. The Metonic cycle is a 19 year cycle; 19
11094 years is close to being a common multiple of a solar year and a lunar
11095 month, and so every 19 years the phases of the moon will occur on the
11096 same days of the year. The solar cycle is a 28 year cycle; the Julian
11097 calendar repeats itself every 28 years. The smallest time period
11098 which contains multiples of all three cycles is the least common
11099 multiple of 15 years, 19 years and 28 years, which (since they're
11100 pairwise relatively prime) is
11101 @texline @math{15\times 19\times 28 = 7980} years.
11102 @infoline 15*19*28 = 7980 years.
11103 This is the length of a Julian cycle. Working backwards, the previous
11104 year in which all three cycles began was 4713 BC, and so Scalinger
11105 chose that year as the beginning of a Julian cycle. Since at the time
11106 there were no historical records from before 4713 BC, using this year
11107 as a starting point had the advantage of avoiding negative year
11108 numbers. In 1849, the astronomer John Herschel (son of William
11109 Herschel) suggested using the number of days since the beginning of
11110 the Julian cycle as an astronomical dating system; this idea was taken
11111 up by other astronomers. (At the time, noon was the start of the
11112 astronomical day. Herschel originally suggested counting the days
11113 since Jan 1, 4713 BC at noon Alexandria time; this was later amended to
11114 noon GMT.) Julian day numbering is largely used in astronomy.
11116 @cindex Unix time format
11117 The Unix operating system measures time as an integer number of
11118 seconds since midnight, Jan 1, 1970. To convert a Calc date
11119 value into a Unix time stamp, first subtract 719164 (the code
11120 for @samp{<Jan 1, 1970>}), then multiply by 86400 (the number of
11121 seconds in a day) and press @kbd{R} to round to the nearest
11122 integer. If you have a date form, you can simply subtract the
11123 day @samp{<Jan 1, 1970>} instead of unpacking and subtracting
11124 719164. Likewise, divide by 86400 and add @samp{<Jan 1, 1970>}
11125 to convert from Unix time to a Calc date form. (Note that
11126 Unix normally maintains the time in the GMT time zone; you may
11127 need to subtract five hours to get New York time, or eight hours
11128 for California time. The same is usually true of Julian day
11129 counts.) The built-in @kbd{t U} command performs these
11132 @node Modulo Forms, Error Forms, Date Forms, Data Types
11133 @section Modulo Forms
11136 @cindex Modulo forms
11137 A @dfn{modulo form} is a real number which is taken modulo (i.e., within
11138 an integer multiple of) some value @var{M}. Arithmetic modulo @var{M}
11139 often arises in number theory. Modulo forms are written
11140 `@var{a} @tfn{mod} @var{M}',
11141 where @var{a} and @var{M} are real numbers or HMS forms, and
11142 @texline @math{0 \le a < M}.
11143 @infoline @expr{0 <= a < @var{M}}.
11144 In many applications @expr{a} and @expr{M} will be
11145 integers but this is not required.
11150 @kindex M (modulo forms)
11154 @tindex mod (operator)
11155 To create a modulo form during numeric entry, press the shift-@kbd{M}
11156 key to enter the word @samp{mod}. As a special convenience, pressing
11157 shift-@kbd{M} a second time automatically enters the value of @expr{M}
11158 that was most recently used before. During algebraic entry, either
11159 type @samp{mod} by hand or press @kbd{M-m} (that's @kbd{@key{META}-m}).
11160 Once again, pressing this a second time enters the current modulo.
11162 Modulo forms are not to be confused with the modulo operator @samp{%}.
11163 The expression @samp{27 % 10} means to compute 27 modulo 10 to produce
11164 the result 7. Further computations treat this 7 as just a regular integer.
11165 The expression @samp{27 mod 10} produces the result @samp{7 mod 10};
11166 further computations with this value are again reduced modulo 10 so that
11167 the result always lies in the desired range.
11169 When two modulo forms with identical @expr{M}'s are added or multiplied,
11170 the Calculator simply adds or multiplies the values, then reduces modulo
11171 @expr{M}. If one argument is a modulo form and the other a plain number,
11172 the plain number is treated like a compatible modulo form. It is also
11173 possible to raise modulo forms to powers; the result is the value raised
11174 to the power, then reduced modulo @expr{M}. (When all values involved
11175 are integers, this calculation is done much more efficiently than
11176 actually computing the power and then reducing.)
11178 @cindex Modulo division
11179 Two modulo forms `@var{a} @tfn{mod} @var{M}' and `@var{b} @tfn{mod} @var{M}'
11180 can be divided if @expr{a}, @expr{b}, and @expr{M} are all
11181 integers. The result is the modulo form which, when multiplied by
11182 `@var{b} @tfn{mod} @var{M}', produces `@var{a} @tfn{mod} @var{M}'. If
11183 there is no solution to this equation (which can happen only when
11184 @expr{M} is non-prime), or if any of the arguments are non-integers, the
11185 division is left in symbolic form. Other operations, such as square
11186 roots, are not yet supported for modulo forms. (Note that, although
11187 @w{`@tfn{(}@var{a} @tfn{mod} @var{M}@tfn{)^.5}'} will compute a ``modulo square root''
11188 in the sense of reducing
11189 @texline @math{\sqrt a}
11190 @infoline @expr{sqrt(a)}
11191 modulo @expr{M}, this is not a useful definition from the
11192 number-theoretical point of view.)
11194 It is possible to mix HMS forms and modulo forms. For example, an
11195 HMS form modulo 24 could be used to manipulate clock times; an HMS
11196 form modulo 360 would be suitable for angles. Making the modulo @expr{M}
11197 also be an HMS form eliminates troubles that would arise if the angular
11198 mode were inadvertently set to Radians, in which case
11199 @w{@samp{2@@ 0' 0" mod 24}} would be interpreted as two degrees modulo
11202 Modulo forms cannot have variables or formulas for components. If you
11203 enter the formula @samp{(x + 2) mod 5}, Calc propagates the modulus
11204 to each of the coefficients: @samp{(1 mod 5) x + (2 mod 5)}.
11206 You can use @kbd{v p} and @kbd{%} to modify modulo forms.
11207 @xref{Packing and Unpacking}. @xref{Basic Arithmetic}.
11213 The algebraic function @samp{makemod(a, m)} builds the modulo form
11214 @w{@samp{a mod m}}.
11216 @node Error Forms, Interval Forms, Modulo Forms, Data Types
11217 @section Error Forms
11220 @cindex Error forms
11221 @cindex Standard deviations
11222 An @dfn{error form} is a number with an associated standard
11223 deviation, as in @samp{2.3 +/- 0.12}. The notation
11224 @texline `@var{x} @tfn{+/-} @math{\sigma}'
11225 @infoline `@var{x} @tfn{+/-} sigma'
11226 stands for an uncertain value which follows
11227 a normal or Gaussian distribution of mean @expr{x} and standard
11228 deviation or ``error''
11229 @texline @math{\sigma}.
11230 @infoline @expr{sigma}.
11231 Both the mean and the error can be either numbers or
11232 formulas. Generally these are real numbers but the mean may also be
11233 complex. If the error is negative or complex, it is changed to its
11234 absolute value. An error form with zero error is converted to a
11235 regular number by the Calculator.
11237 All arithmetic and transcendental functions accept error forms as input.
11238 Operations on the mean-value part work just like operations on regular
11239 numbers. The error part for any function @expr{f(x)} (such as
11240 @texline @math{\sin x}
11241 @infoline @expr{sin(x)})
11242 is defined by the error of @expr{x} times the derivative of @expr{f}
11243 evaluated at the mean value of @expr{x}. For a two-argument function
11244 @expr{f(x,y)} (such as addition) the error is the square root of the sum
11245 of the squares of the errors due to @expr{x} and @expr{y}.
11248 f(x \hbox{\code{ +/- }} \sigma)
11249 &= f(x) \hbox{\code{ +/- }} \sigma \left| {df(x) \over dx} \right| \cr
11250 f(x \hbox{\code{ +/- }} \sigma_x, y \hbox{\code{ +/- }} \sigma_y)
11251 &= f(x,y) \hbox{\code{ +/- }}
11252 \sqrt{\left(\sigma_x \left| {\partial f(x,y) \over \partial x}
11254 +\left(\sigma_y \left| {\partial f(x,y) \over \partial y}
11255 \right| \right)^2 } \cr
11259 definition assumes the errors in @expr{x} and @expr{y} are uncorrelated.
11260 A side effect of this definition is that @samp{(2 +/- 1) * (2 +/- 1)}
11261 is not the same as @samp{(2 +/- 1)^2}; the former represents the product
11262 of two independent values which happen to have the same probability
11263 distributions, and the latter is the product of one random value with itself.
11264 The former will produce an answer with less error, since on the average
11265 the two independent errors can be expected to cancel out.
11267 Consult a good text on error analysis for a discussion of the proper use
11268 of standard deviations. Actual errors often are neither Gaussian-distributed
11269 nor uncorrelated, and the above formulas are valid only when errors
11270 are small. As an example, the error arising from
11271 @texline `@tfn{sin(}@var{x} @tfn{+/-} @math{\sigma}@tfn{)}'
11272 @infoline `@tfn{sin(}@var{x} @tfn{+/-} @var{sigma}@tfn{)}'
11274 @texline `@math{\sigma} @tfn{abs(cos(}@var{x}@tfn{))}'.
11275 @infoline `@var{sigma} @tfn{abs(cos(}@var{x}@tfn{))}'.
11276 When @expr{x} is close to zero,
11277 @texline @math{\cos x}
11278 @infoline @expr{cos(x)}
11279 is close to one so the error in the sine is close to
11280 @texline @math{\sigma};
11281 @infoline @expr{sigma};
11282 this makes sense, since
11283 @texline @math{\sin x}
11284 @infoline @expr{sin(x)}
11285 is approximately @expr{x} near zero, so a given error in @expr{x} will
11286 produce about the same error in the sine. Likewise, near 90 degrees
11287 @texline @math{\cos x}
11288 @infoline @expr{cos(x)}
11289 is nearly zero and so the computed error is
11290 small: The sine curve is nearly flat in that region, so an error in @expr{x}
11291 has relatively little effect on the value of
11292 @texline @math{\sin x}.
11293 @infoline @expr{sin(x)}.
11294 However, consider @samp{sin(90 +/- 1000)}. The cosine of 90 is zero, so
11295 Calc will report zero error! We get an obviously wrong result because
11296 we have violated the small-error approximation underlying the error
11297 analysis. If the error in @expr{x} had been small, the error in
11298 @texline @math{\sin x}
11299 @infoline @expr{sin(x)}
11300 would indeed have been negligible.
11305 @kindex p (error forms)
11307 To enter an error form during regular numeric entry, use the @kbd{p}
11308 (``plus-or-minus'') key to type the @samp{+/-} symbol. (If you try actually
11309 typing @samp{+/-} the @kbd{+} key will be interpreted as the Calculator's
11310 @kbd{+} command!) Within an algebraic formula, you can press @kbd{M-+} to
11311 type the @samp{+/-} symbol, or type it out by hand.
11313 Error forms and complex numbers can be mixed; the formulas shown above
11314 are used for complex numbers, too; note that if the error part evaluates
11315 to a complex number its absolute value (or the square root of the sum of
11316 the squares of the absolute values of the two error contributions) is
11317 used. Mathematically, this corresponds to a radially symmetric Gaussian
11318 distribution of numbers on the complex plane. However, note that Calc
11319 considers an error form with real components to represent a real number,
11320 not a complex distribution around a real mean.
11322 Error forms may also be composed of HMS forms. For best results, both
11323 the mean and the error should be HMS forms if either one is.
11329 The algebraic function @samp{sdev(a, b)} builds the error form @samp{a +/- b}.
11331 @node Interval Forms, Incomplete Objects, Error Forms, Data Types
11332 @section Interval Forms
11335 @cindex Interval forms
11336 An @dfn{interval} is a subset of consecutive real numbers. For example,
11337 the interval @samp{[2 ..@: 4]} represents all the numbers from 2 to 4,
11338 inclusive. If you multiply it by the interval @samp{[0.5 ..@: 2]} you
11339 obtain @samp{[1 ..@: 8]}. This calculation represents the fact that if
11340 you multiply some number in the range @samp{[2 ..@: 4]} by some other
11341 number in the range @samp{[0.5 ..@: 2]}, your result will lie in the range
11342 from 1 to 8. Interval arithmetic is used to get a worst-case estimate
11343 of the possible range of values a computation will produce, given the
11344 set of possible values of the input.
11347 Calc supports several varieties of intervals, including @dfn{closed}
11348 intervals of the type shown above, @dfn{open} intervals such as
11349 @samp{(2 ..@: 4)}, which represents the range of numbers from 2 to 4
11350 @emph{exclusive}, and @dfn{semi-open} intervals in which one end
11351 uses a round parenthesis and the other a square bracket. In mathematical
11353 @samp{[2 ..@: 4]} means @expr{2 <= x <= 4}, whereas
11354 @samp{[2 ..@: 4)} represents @expr{2 <= x < 4},
11355 @samp{(2 ..@: 4]} represents @expr{2 < x <= 4}, and
11356 @samp{(2 ..@: 4)} represents @expr{2 < x < 4}.
11359 Calc supports several varieties of intervals, including \dfn{closed}
11360 intervals of the type shown above, \dfn{open} intervals such as
11361 \samp{(2 ..\: 4)}, which represents the range of numbers from 2 to 4
11362 \emph{exclusive}, and \dfn{semi-open} intervals in which one end
11363 uses a round parenthesis and the other a square bracket. In mathematical
11366 [2 \hbox{\cite{..}} 4] &\quad\hbox{means}\quad 2 \le x \le 4 \cr
11367 [2 \hbox{\cite{..}} 4) &\quad\hbox{means}\quad 2 \le x < 4 \cr
11368 (2 \hbox{\cite{..}} 4] &\quad\hbox{means}\quad 2 < x \le 4 \cr
11369 (2 \hbox{\cite{..}} 4) &\quad\hbox{means}\quad 2 < x < 4 \cr
11373 The lower and upper limits of an interval must be either real numbers
11374 (or HMS or date forms), or symbolic expressions which are assumed to be
11375 real-valued, or @samp{-inf} and @samp{inf}. In general the lower limit
11376 must be less than the upper limit. A closed interval containing only
11377 one value, @samp{[3 ..@: 3]}, is converted to a plain number (3)
11378 automatically. An interval containing no values at all (such as
11379 @samp{[3 ..@: 2]} or @samp{[2 ..@: 2)}) can be represented but is not
11380 guaranteed to behave well when used in arithmetic. Note that the
11381 interval @samp{[3 .. inf)} represents all real numbers greater than
11382 or equal to 3, and @samp{(-inf .. inf)} represents all real numbers.
11383 In fact, @samp{[-inf .. inf]} represents all real numbers including
11384 the real infinities.
11386 Intervals are entered in the notation shown here, either as algebraic
11387 formulas, or using incomplete forms. (@xref{Incomplete Objects}.)
11388 In algebraic formulas, multiple periods in a row are collected from
11389 left to right, so that @samp{1...1e2} is interpreted as @samp{1.0 ..@: 1e2}
11390 rather than @samp{1 ..@: 0.1e2}. Add spaces or zeros if you want to
11391 get the other interpretation. If you omit the lower or upper limit,
11392 a default of @samp{-inf} or @samp{inf} (respectively) is furnished.
11394 Infinite mode also affects operations on intervals
11395 (@pxref{Infinities}). Calc will always introduce an open infinity,
11396 as in @samp{1 / (0 .. 2] = [0.5 .. inf)}. But closed infinities,
11397 @w{@samp{1 / [0 .. 2] = [0.5 .. inf]}}, arise only in Infinite mode;
11398 otherwise they are left unevaluated. Note that the ``direction'' of
11399 a zero is not an issue in this case since the zero is always assumed
11400 to be continuous with the rest of the interval. For intervals that
11401 contain zero inside them Calc is forced to give the result,
11402 @samp{1 / (-2 .. 2) = [-inf .. inf]}.
11404 While it may seem that intervals and error forms are similar, they are
11405 based on entirely different concepts of inexact quantities. An error
11407 @texline `@var{x} @tfn{+/-} @math{\sigma}'
11408 @infoline `@var{x} @tfn{+/-} @var{sigma}'
11409 means a variable is random, and its value could
11410 be anything but is ``probably'' within one
11411 @texline @math{\sigma}
11412 @infoline @var{sigma}
11413 of the mean value @expr{x}. An interval
11414 `@tfn{[}@var{a} @tfn{..@:} @var{b}@tfn{]}' means a
11415 variable's value is unknown, but guaranteed to lie in the specified
11416 range. Error forms are statistical or ``average case'' approximations;
11417 interval arithmetic tends to produce ``worst case'' bounds on an
11420 Intervals may not contain complex numbers, but they may contain
11421 HMS forms or date forms.
11423 @xref{Set Operations}, for commands that interpret interval forms
11424 as subsets of the set of real numbers.
11430 The algebraic function @samp{intv(n, a, b)} builds an interval form
11431 from @samp{a} to @samp{b}; @samp{n} is an integer code which must
11432 be 0 for @samp{(..)}, 1 for @samp{(..]}, 2 for @samp{[..)}, or
11435 Please note that in fully rigorous interval arithmetic, care would be
11436 taken to make sure that the computation of the lower bound rounds toward
11437 minus infinity, while upper bound computations round toward plus
11438 infinity. Calc's arithmetic always uses a round-to-nearest mode,
11439 which means that roundoff errors could creep into an interval
11440 calculation to produce intervals slightly smaller than they ought to
11441 be. For example, entering @samp{[1..2]} and pressing @kbd{Q 2 ^}
11442 should yield the interval @samp{[1..2]} again, but in fact it yields the
11443 (slightly too small) interval @samp{[1..1.9999999]} due to roundoff
11446 @node Incomplete Objects, Variables, Interval Forms, Data Types
11447 @section Incomplete Objects
11467 @cindex Incomplete vectors
11468 @cindex Incomplete complex numbers
11469 @cindex Incomplete interval forms
11470 When @kbd{(} or @kbd{[} is typed to begin entering a complex number or
11471 vector, respectively, the effect is to push an @dfn{incomplete} complex
11472 number or vector onto the stack. The @kbd{,} key adds the value(s) at
11473 the top of the stack onto the current incomplete object. The @kbd{)}
11474 and @kbd{]} keys ``close'' the incomplete object after adding any values
11475 on the top of the stack in front of the incomplete object.
11477 As a result, the sequence of keystrokes @kbd{[ 2 , 3 @key{RET} 2 * , 9 ]}
11478 pushes the vector @samp{[2, 6, 9]} onto the stack. Likewise, @kbd{( 1 , 2 Q )}
11479 pushes the complex number @samp{(1, 1.414)} (approximately).
11481 If several values lie on the stack in front of the incomplete object,
11482 all are collected and appended to the object. Thus the @kbd{,} key
11483 is redundant: @kbd{[ 2 @key{RET} 3 @key{RET} 2 * 9 ]}. Some people
11484 prefer the equivalent @key{SPC} key to @key{RET}.
11486 As a special case, typing @kbd{,} immediately after @kbd{(}, @kbd{[}, or
11487 @kbd{,} adds a zero or duplicates the preceding value in the list being
11488 formed. Typing @key{DEL} during incomplete entry removes the last item
11492 The @kbd{;} key is used in the same way as @kbd{,} to create polar complex
11493 numbers: @kbd{( 1 ; 2 )}. When entering a vector, @kbd{;} is useful for
11494 creating a matrix. In particular, @kbd{[ [ 1 , 2 ; 3 , 4 ; 5 , 6 ] ]} is
11495 equivalent to @kbd{[ [ 1 , 2 ] , [ 3 , 4 ] , [ 5 , 6 ] ]}.
11499 Incomplete entry is also used to enter intervals. For example,
11500 @kbd{[ 2 ..@: 4 )} enters a semi-open interval. Note that when you type
11501 the first period, it will be interpreted as a decimal point, but when
11502 you type a second period immediately afterward, it is re-interpreted as
11503 part of the interval symbol. Typing @kbd{..} corresponds to executing
11504 the @code{calc-dots} command.
11506 If you find incomplete entry distracting, you may wish to enter vectors
11507 and complex numbers as algebraic formulas by pressing the apostrophe key.
11509 @node Variables, Formulas, Incomplete Objects, Data Types
11513 @cindex Variables, in formulas
11514 A @dfn{variable} is somewhere between a storage register on a conventional
11515 calculator, and a variable in a programming language. (In fact, a Calc
11516 variable is really just an Emacs Lisp variable that contains a Calc number
11517 or formula.) A variable's name is normally composed of letters and digits.
11518 Calc also allows apostrophes and @code{#} signs in variable names.
11519 (The Calc variable @code{foo} corresponds to the Emacs Lisp variable
11520 @code{var-foo}, but unless you access the variable from within Emacs
11521 Lisp, you don't need to worry about it. Variable names in algebraic
11522 formulas implicitly have @samp{var-} prefixed to their names. The
11523 @samp{#} character in variable names used in algebraic formulas
11524 corresponds to a dash @samp{-} in the Lisp variable name. If the name
11525 contains any dashes, the prefix @samp{var-} is @emph{not} automatically
11526 added. Thus the two formulas @samp{foo + 1} and @samp{var#foo + 1} both
11527 refer to the same variable.)
11529 In a command that takes a variable name, you can either type the full
11530 name of a variable, or type a single digit to use one of the special
11531 convenience variables @code{q0} through @code{q9}. For example,
11532 @kbd{3 s s 2} stores the number 3 in variable @code{q2}, and
11533 @w{@kbd{3 s s foo @key{RET}}} stores that number in variable
11536 To push a variable itself (as opposed to the variable's value) on the
11537 stack, enter its name as an algebraic expression using the apostrophe
11541 @pindex calc-evaluate
11542 @cindex Evaluation of variables in a formula
11543 @cindex Variables, evaluation
11544 @cindex Formulas, evaluation
11545 The @kbd{=} (@code{calc-evaluate}) key ``evaluates'' a formula by
11546 replacing all variables in the formula which have been given values by a
11547 @code{calc-store} or @code{calc-let} command by their stored values.
11548 Other variables are left alone. Thus a variable that has not been
11549 stored acts like an abstract variable in algebra; a variable that has
11550 been stored acts more like a register in a traditional calculator.
11551 With a positive numeric prefix argument, @kbd{=} evaluates the top
11552 @var{n} stack entries; with a negative argument, @kbd{=} evaluates
11553 the @var{n}th stack entry.
11555 @cindex @code{e} variable
11556 @cindex @code{pi} variable
11557 @cindex @code{i} variable
11558 @cindex @code{phi} variable
11559 @cindex @code{gamma} variable
11565 A few variables are called @dfn{special constants}. Their names are
11566 @samp{e}, @samp{pi}, @samp{i}, @samp{phi}, and @samp{gamma}.
11567 (@xref{Scientific Functions}.) When they are evaluated with @kbd{=},
11568 their values are calculated if necessary according to the current precision
11569 or complex polar mode. If you wish to use these symbols for other purposes,
11570 simply undefine or redefine them using @code{calc-store}.
11572 The variables @samp{inf}, @samp{uinf}, and @samp{nan} stand for
11573 infinite or indeterminate values. It's best not to use them as
11574 regular variables, since Calc uses special algebraic rules when
11575 it manipulates them. Calc displays a warning message if you store
11576 a value into any of these special variables.
11578 @xref{Store and Recall}, for a discussion of commands dealing with variables.
11580 @node Formulas, , Variables, Data Types
11585 @cindex Expressions
11586 @cindex Operators in formulas
11587 @cindex Precedence of operators
11588 When you press the apostrophe key you may enter any expression or formula
11589 in algebraic form. (Calc uses the terms ``expression'' and ``formula''
11590 interchangeably.) An expression is built up of numbers, variable names,
11591 and function calls, combined with various arithmetic operators.
11593 be used to indicate grouping. Spaces are ignored within formulas, except
11594 that spaces are not permitted within variable names or numbers.
11595 Arithmetic operators, in order from highest to lowest precedence, and
11596 with their equivalent function names, are:
11598 @samp{_} [@code{subscr}] (subscripts);
11600 postfix @samp{%} [@code{percent}] (as in @samp{25% = 0.25});
11602 prefix @samp{!} [@code{lnot}] (logical ``not,'' as in @samp{!x});
11604 @samp{+/-} [@code{sdev}] (the standard deviation symbol) and
11605 @samp{mod} [@code{makemod}] (the symbol for modulo forms);
11607 postfix @samp{!} [@code{fact}] (factorial, as in @samp{n!})
11608 and postfix @samp{!!} [@code{dfact}] (double factorial);
11610 @samp{^} [@code{pow}] (raised-to-the-power-of);
11612 prefix @samp{+} and @samp{-} [@code{neg}] (as in @samp{-x});
11614 @samp{*} [@code{mul}];
11616 @samp{/} [@code{div}], @samp{%} [@code{mod}] (modulo), and
11617 @samp{\} [@code{idiv}] (integer division);
11619 infix @samp{+} [@code{add}] and @samp{-} [@code{sub}] (as in @samp{x-y});
11621 @samp{|} [@code{vconcat}] (vector concatenation);
11623 relations @samp{=} [@code{eq}], @samp{!=} [@code{neq}], @samp{<} [@code{lt}],
11624 @samp{>} [@code{gt}], @samp{<=} [@code{leq}], and @samp{>=} [@code{geq}];
11626 @samp{&&} [@code{land}] (logical ``and'');
11628 @samp{||} [@code{lor}] (logical ``or'');
11630 the C-style ``if'' operator @samp{a?b:c} [@code{if}];
11632 @samp{!!!} [@code{pnot}] (rewrite pattern ``not'');
11634 @samp{&&&} [@code{pand}] (rewrite pattern ``and'');
11636 @samp{|||} [@code{por}] (rewrite pattern ``or'');
11638 @samp{:=} [@code{assign}] (for assignments and rewrite rules);
11640 @samp{::} [@code{condition}] (rewrite pattern condition);
11642 @samp{=>} [@code{evalto}].
11644 Note that, unlike in usual computer notation, multiplication binds more
11645 strongly than division: @samp{a*b/c*d} is equivalent to
11646 @texline @math{a b \over c d}.
11647 @infoline @expr{(a*b)/(c*d)}.
11649 @cindex Multiplication, implicit
11650 @cindex Implicit multiplication
11651 The multiplication sign @samp{*} may be omitted in many cases. In particular,
11652 if the righthand side is a number, variable name, or parenthesized
11653 expression, the @samp{*} may be omitted. Implicit multiplication has the
11654 same precedence as the explicit @samp{*} operator. The one exception to
11655 the rule is that a variable name followed by a parenthesized expression,
11657 is interpreted as a function call, not an implicit @samp{*}. In many
11658 cases you must use a space if you omit the @samp{*}: @samp{2a} is the
11659 same as @samp{2*a}, and @samp{a b} is the same as @samp{a*b}, but @samp{ab}
11660 is a variable called @code{ab}, @emph{not} the product of @samp{a} and
11661 @samp{b}! Also note that @samp{f (x)} is still a function call.
11663 @cindex Implicit comma in vectors
11664 The rules are slightly different for vectors written with square brackets.
11665 In vectors, the space character is interpreted (like the comma) as a
11666 separator of elements of the vector. Thus @w{@samp{[ 2a b+c d ]}} is
11667 equivalent to @samp{[2*a, b+c, d]}, whereas @samp{2a b+c d} is equivalent
11668 to @samp{2*a*b + c*d}.
11669 Note that spaces around the brackets, and around explicit commas, are
11670 ignored. To force spaces to be interpreted as multiplication you can
11671 enclose a formula in parentheses as in @samp{[(a b) 2(c d)]}, which is
11672 interpreted as @samp{[a*b, 2*c*d]}. An implicit comma is also inserted
11673 between @samp{][}, as in the matrix @samp{[[1 2][3 4]]}.
11675 Vectors that contain commas (not embedded within nested parentheses or
11676 brackets) do not treat spaces specially: @samp{[a b, 2 c d]} is a vector
11677 of two elements. Also, if it would be an error to treat spaces as
11678 separators, but not otherwise, then Calc will ignore spaces:
11679 @w{@samp{[a - b]}} is a vector of one element, but @w{@samp{[a -b]}} is
11680 a vector of two elements. Finally, vectors entered with curly braces
11681 instead of square brackets do not give spaces any special treatment.
11682 When Calc displays a vector that does not contain any commas, it will
11683 insert parentheses if necessary to make the meaning clear:
11684 @w{@samp{[(a b)]}}.
11686 The expression @samp{5%-2} is ambiguous; is this five-percent minus two,
11687 or five modulo minus-two? Calc always interprets the leftmost symbol as
11688 an infix operator preferentially (modulo, in this case), so you would
11689 need to write @samp{(5%)-2} to get the former interpretation.
11691 @cindex Function call notation
11692 A function call is, e.g., @samp{sin(1+x)}. (The Calc algebraic function
11693 @code{foo} corresponds to the Emacs Lisp function @code{calcFunc-foo},
11694 but unless you access the function from within Emacs Lisp, you don't
11695 need to worry about it.) Most mathematical Calculator commands like
11696 @code{calc-sin} have function equivalents like @code{sin}.
11697 If no Lisp function is defined for a function called by a formula, the
11698 call is left as it is during algebraic manipulation: @samp{f(x+y)} is
11699 left alone. Beware that many innocent-looking short names like @code{in}
11700 and @code{re} have predefined meanings which could surprise you; however,
11701 single letters or single letters followed by digits are always safe to
11702 use for your own function names. @xref{Function Index}.
11704 In the documentation for particular commands, the notation @kbd{H S}
11705 (@code{calc-sinh}) [@code{sinh}] means that the key sequence @kbd{H S}, the
11706 command @kbd{M-x calc-sinh}, and the algebraic function @code{sinh(x)} all
11707 represent the same operation.
11709 Commands that interpret (``parse'') text as algebraic formulas include
11710 algebraic entry (@kbd{'}), editing commands like @kbd{`} which parse
11711 the contents of the editing buffer when you finish, the @kbd{C-x * g}
11712 and @w{@kbd{C-x * r}} commands, the @kbd{C-y} command, the X window system
11713 ``paste'' mouse operation, and Embedded mode. All of these operations
11714 use the same rules for parsing formulas; in particular, language modes
11715 (@pxref{Language Modes}) affect them all in the same way.
11717 When you read a large amount of text into the Calculator (say a vector
11718 which represents a big set of rewrite rules; @pxref{Rewrite Rules}),
11719 you may wish to include comments in the text. Calc's formula parser
11720 ignores the symbol @samp{%%} and anything following it on a line:
11723 [ a + b, %% the sum of "a" and "b"
11725 %% last line is coming up:
11730 This is parsed exactly the same as @samp{[ a + b, c + d, e + f ]}.
11732 @xref{Syntax Tables}, for a way to create your own operators and other
11733 input notations. @xref{Compositions}, for a way to create new display
11736 @xref{Algebra}, for commands for manipulating formulas symbolically.
11738 @node Stack and Trail, Mode Settings, Data Types, Top
11739 @chapter Stack and Trail Commands
11742 This chapter describes the Calc commands for manipulating objects on the
11743 stack and in the trail buffer. (These commands operate on objects of any
11744 type, such as numbers, vectors, formulas, and incomplete objects.)
11747 * Stack Manipulation::
11748 * Editing Stack Entries::
11753 @node Stack Manipulation, Editing Stack Entries, Stack and Trail, Stack and Trail
11754 @section Stack Manipulation Commands
11760 @cindex Duplicating stack entries
11761 To duplicate the top object on the stack, press @key{RET} or @key{SPC}
11762 (two equivalent keys for the @code{calc-enter} command).
11763 Given a positive numeric prefix argument, these commands duplicate
11764 several elements at the top of the stack.
11765 Given a negative argument,
11766 these commands duplicate the specified element of the stack.
11767 Given an argument of zero, they duplicate the entire stack.
11768 For example, with @samp{10 20 30} on the stack,
11769 @key{RET} creates @samp{10 20 30 30},
11770 @kbd{C-u 2 @key{RET}} creates @samp{10 20 30 20 30},
11771 @kbd{C-u - 2 @key{RET}} creates @samp{10 20 30 20}, and
11772 @kbd{C-u 0 @key{RET}} creates @samp{10 20 30 10 20 30}.
11776 The @key{LFD} (@code{calc-over}) command (on a key marked Line-Feed if you
11777 have it, else on @kbd{C-j}) is like @code{calc-enter}
11778 except that the sign of the numeric prefix argument is interpreted
11779 oppositely. Also, with no prefix argument the default argument is 2.
11780 Thus with @samp{10 20 30} on the stack, @key{LFD} and @kbd{C-u 2 @key{LFD}}
11781 are both equivalent to @kbd{C-u - 2 @key{RET}}, producing
11782 @samp{10 20 30 20}.
11787 @cindex Removing stack entries
11788 @cindex Deleting stack entries
11789 To remove the top element from the stack, press @key{DEL} (@code{calc-pop}).
11790 The @kbd{C-d} key is a synonym for @key{DEL}.
11791 (If the top element is an incomplete object with at least one element, the
11792 last element is removed from it.) Given a positive numeric prefix argument,
11793 several elements are removed. Given a negative argument, the specified
11794 element of the stack is deleted. Given an argument of zero, the entire
11796 For example, with @samp{10 20 30} on the stack,
11797 @key{DEL} leaves @samp{10 20},
11798 @kbd{C-u 2 @key{DEL}} leaves @samp{10},
11799 @kbd{C-u - 2 @key{DEL}} leaves @samp{10 30}, and
11800 @kbd{C-u 0 @key{DEL}} leaves an empty stack.
11802 @kindex M-@key{DEL}
11803 @pindex calc-pop-above
11804 The @kbd{M-@key{DEL}} (@code{calc-pop-above}) command is to @key{DEL} what
11805 @key{LFD} is to @key{RET}: It interprets the sign of the numeric
11806 prefix argument in the opposite way, and the default argument is 2.
11807 Thus @kbd{M-@key{DEL}} by itself removes the second-from-top stack element,
11808 leaving the first, third, fourth, and so on; @kbd{M-3 M-@key{DEL}} deletes
11809 the third stack element.
11812 @pindex calc-roll-down
11813 To exchange the top two elements of the stack, press @key{TAB}
11814 (@code{calc-roll-down}). Given a positive numeric prefix argument, the
11815 specified number of elements at the top of the stack are rotated downward.
11816 Given a negative argument, the entire stack is rotated downward the specified
11817 number of times. Given an argument of zero, the entire stack is reversed
11819 For example, with @samp{10 20 30 40 50} on the stack,
11820 @key{TAB} creates @samp{10 20 30 50 40},
11821 @kbd{C-u 3 @key{TAB}} creates @samp{10 20 50 30 40},
11822 @kbd{C-u - 2 @key{TAB}} creates @samp{40 50 10 20 30}, and
11823 @kbd{C-u 0 @key{TAB}} creates @samp{50 40 30 20 10}.
11825 @kindex M-@key{TAB}
11826 @pindex calc-roll-up
11827 The command @kbd{M-@key{TAB}} (@code{calc-roll-up}) is analogous to @key{TAB}
11828 except that it rotates upward instead of downward. Also, the default
11829 with no prefix argument is to rotate the top 3 elements.
11830 For example, with @samp{10 20 30 40 50} on the stack,
11831 @kbd{M-@key{TAB}} creates @samp{10 20 40 50 30},
11832 @kbd{C-u 4 M-@key{TAB}} creates @samp{10 30 40 50 20},
11833 @kbd{C-u - 2 M-@key{TAB}} creates @samp{30 40 50 10 20}, and
11834 @kbd{C-u 0 M-@key{TAB}} creates @samp{50 40 30 20 10}.
11836 A good way to view the operation of @key{TAB} and @kbd{M-@key{TAB}} is in
11837 terms of moving a particular element to a new position in the stack.
11838 With a positive argument @var{n}, @key{TAB} moves the top stack
11839 element down to level @var{n}, making room for it by pulling all the
11840 intervening stack elements toward the top. @kbd{M-@key{TAB}} moves the
11841 element at level @var{n} up to the top. (Compare with @key{LFD},
11842 which copies instead of moving the element in level @var{n}.)
11844 With a negative argument @mathit{-@var{n}}, @key{TAB} rotates the stack
11845 to move the object in level @var{n} to the deepest place in the
11846 stack, and the object in level @mathit{@var{n}+1} to the top. @kbd{M-@key{TAB}}
11847 rotates the deepest stack element to be in level @var{n}, also
11848 putting the top stack element in level @mathit{@var{n}+1}.
11850 @xref{Selecting Subformulas}, for a way to apply these commands to
11851 any portion of a vector or formula on the stack.
11854 @pindex calc-transpose-lines
11855 @cindex Moving stack entries
11856 The command @kbd{C-x C-t} (@code{calc-transpose-lines}) will transpose
11857 the stack object determined by the point with the stack object at the
11858 next higher level. For example, with @samp{10 20 30 40 50} on the
11859 stack and the point on the line containing @samp{30}, @kbd{C-x C-t}
11860 creates @samp{10 20 40 30 50}. More generally, @kbd{C-x C-t} acts on
11861 the stack objects determined by the current point (and mark) similar
11862 to how the text-mode command @code{transpose-lines} acts on
11863 lines. With argument @var{n}, @kbd{C-x C-t} will move the stack object
11864 at the level above the current point and move it past N other objects;
11865 for example, with @samp{10 20 30 40 50} on the stack and the point on
11866 the line containing @samp{30}, @kbd{C-u 2 C-x C-t} creates
11867 @samp{10 40 20 30 50}. With an argument of 0, @kbd{C-x C-t} will switch
11868 the stack objects at the levels determined by the point and the mark.
11870 @node Editing Stack Entries, Trail Commands, Stack Manipulation, Stack and Trail
11871 @section Editing Stack Entries
11876 @pindex calc-edit-finish
11877 @cindex Editing the stack with Emacs
11878 The @kbd{`} (@code{calc-edit}) command creates a temporary buffer
11879 (@samp{*Calc Edit*}) for editing the top-of-stack value using regular
11880 Emacs commands. Note that @kbd{`} is a backquote, not a quote. With a
11881 numeric prefix argument, it edits the specified number of stack entries
11882 at once. (An argument of zero edits the entire stack; a negative
11883 argument edits one specific stack entry.)
11885 When you are done editing, press @kbd{C-c C-c} to finish and return
11886 to Calc. The @key{RET} and @key{LFD} keys also work to finish most
11887 sorts of editing, though in some cases Calc leaves @key{RET} with its
11888 usual meaning (``insert a newline'') if it's a situation where you
11889 might want to insert new lines into the editing buffer.
11891 When you finish editing, the Calculator parses the lines of text in
11892 the @samp{*Calc Edit*} buffer as numbers or formulas, replaces the
11893 original stack elements in the original buffer with these new values,
11894 then kills the @samp{*Calc Edit*} buffer. The original Calculator buffer
11895 continues to exist during editing, but for best results you should be
11896 careful not to change it until you have finished the edit. You can
11897 also cancel the edit by killing the buffer with @kbd{C-x k}.
11899 The formula is normally reevaluated as it is put onto the stack.
11900 For example, editing @samp{a + 2} to @samp{3 + 2} and pressing
11901 @kbd{C-c C-c} will push 5 on the stack. If you use @key{LFD} to
11902 finish, Calc will put the result on the stack without evaluating it.
11904 If you give a prefix argument to @kbd{C-c C-c},
11905 Calc will not kill the @samp{*Calc Edit*} buffer. You can switch
11906 back to that buffer and continue editing if you wish. However, you
11907 should understand that if you initiated the edit with @kbd{`}, the
11908 @kbd{C-c C-c} operation will be programmed to replace the top of the
11909 stack with the new edited value, and it will do this even if you have
11910 rearranged the stack in the meanwhile. This is not so much of a problem
11911 with other editing commands, though, such as @kbd{s e}
11912 (@code{calc-edit-variable}; @pxref{Operations on Variables}).
11914 If the @code{calc-edit} command involves more than one stack entry,
11915 each line of the @samp{*Calc Edit*} buffer is interpreted as a
11916 separate formula. Otherwise, the entire buffer is interpreted as
11917 one formula, with line breaks ignored. (You can use @kbd{C-o} or
11918 @kbd{C-q C-j} to insert a newline in the buffer without pressing @key{RET}.)
11920 The @kbd{`} key also works during numeric or algebraic entry. The
11921 text entered so far is moved to the @code{*Calc Edit*} buffer for
11922 more extensive editing than is convenient in the minibuffer.
11924 @node Trail Commands, Keep Arguments, Editing Stack Entries, Stack and Trail
11925 @section Trail Commands
11928 @cindex Trail buffer
11929 The commands for manipulating the Calc Trail buffer are two-key sequences
11930 beginning with the @kbd{t} prefix.
11933 @pindex calc-trail-display
11934 The @kbd{t d} (@code{calc-trail-display}) command turns display of the
11935 trail on and off. Normally the trail display is toggled on if it was off,
11936 off if it was on. With a numeric prefix of zero, this command always
11937 turns the trail off; with a prefix of one, it always turns the trail on.
11938 The other trail-manipulation commands described here automatically turn
11939 the trail on. Note that when the trail is off values are still recorded
11940 there; they are simply not displayed. To set Emacs to turn the trail
11941 off by default, type @kbd{t d} and then save the mode settings with
11942 @kbd{m m} (@code{calc-save-modes}).
11945 @pindex calc-trail-in
11947 @pindex calc-trail-out
11948 The @kbd{t i} (@code{calc-trail-in}) and @kbd{t o}
11949 (@code{calc-trail-out}) commands switch the cursor into and out of the
11950 Calc Trail window. In practice they are rarely used, since the commands
11951 shown below are a more convenient way to move around in the
11952 trail, and they work ``by remote control'' when the cursor is still
11953 in the Calculator window.
11955 @cindex Trail pointer
11956 There is a @dfn{trail pointer} which selects some entry of the trail at
11957 any given time. The trail pointer looks like a @samp{>} symbol right
11958 before the selected number. The following commands operate on the
11959 trail pointer in various ways.
11962 @pindex calc-trail-yank
11963 @cindex Retrieving previous results
11964 The @kbd{t y} (@code{calc-trail-yank}) command reads the selected value in
11965 the trail and pushes it onto the Calculator stack. It allows you to
11966 re-use any previously computed value without retyping. With a numeric
11967 prefix argument @var{n}, it yanks the value @var{n} lines above the current
11971 @pindex calc-trail-scroll-left
11973 @pindex calc-trail-scroll-right
11974 The @kbd{t <} (@code{calc-trail-scroll-left}) and @kbd{t >}
11975 (@code{calc-trail-scroll-right}) commands horizontally scroll the trail
11976 window left or right by one half of its width.
11979 @pindex calc-trail-next
11981 @pindex calc-trail-previous
11983 @pindex calc-trail-forward
11985 @pindex calc-trail-backward
11986 The @kbd{t n} (@code{calc-trail-next}) and @kbd{t p}
11987 (@code{calc-trail-previous)} commands move the trail pointer down or up
11988 one line. The @kbd{t f} (@code{calc-trail-forward}) and @kbd{t b}
11989 (@code{calc-trail-backward}) commands move the trail pointer down or up
11990 one screenful at a time. All of these commands accept numeric prefix
11991 arguments to move several lines or screenfuls at a time.
11994 @pindex calc-trail-first
11996 @pindex calc-trail-last
11998 @pindex calc-trail-here
11999 The @kbd{t [} (@code{calc-trail-first}) and @kbd{t ]}
12000 (@code{calc-trail-last}) commands move the trail pointer to the first or
12001 last line of the trail. The @kbd{t h} (@code{calc-trail-here}) command
12002 moves the trail pointer to the cursor position; unlike the other trail
12003 commands, @kbd{t h} works only when Calc Trail is the selected window.
12006 @pindex calc-trail-isearch-forward
12008 @pindex calc-trail-isearch-backward
12010 The @kbd{t s} (@code{calc-trail-isearch-forward}) and @kbd{t r}
12011 (@code{calc-trail-isearch-backward}) commands perform an incremental
12012 search forward or backward through the trail. You can press @key{RET}
12013 to terminate the search; the trail pointer moves to the current line.
12014 If you cancel the search with @kbd{C-g}, the trail pointer stays where
12015 it was when the search began.
12018 The @kbd{t s} (@code{calc-trail-isearch-forward}) and @kbd{t r}
12019 (@code{calc-trail-isearch-backward}) com\-mands perform an incremental
12020 search forward or backward through the trail. You can press @key{RET}
12021 to terminate the search; the trail pointer moves to the current line.
12022 If you cancel the search with @kbd{C-g}, the trail pointer stays where
12023 it was when the search began.
12027 @pindex calc-trail-marker
12028 The @kbd{t m} (@code{calc-trail-marker}) command allows you to enter a
12029 line of text of your own choosing into the trail. The text is inserted
12030 after the line containing the trail pointer; this usually means it is
12031 added to the end of the trail. Trail markers are useful mainly as the
12032 targets for later incremental searches in the trail.
12035 @pindex calc-trail-kill
12036 The @kbd{t k} (@code{calc-trail-kill}) command removes the selected line
12037 from the trail. The line is saved in the Emacs kill ring suitable for
12038 yanking into another buffer, but it is not easy to yank the text back
12039 into the trail buffer. With a numeric prefix argument, this command
12040 kills the @var{n} lines below or above the selected one.
12042 The @kbd{t .} (@code{calc-full-trail-vectors}) command is described
12043 elsewhere; @pxref{Vector and Matrix Formats}.
12045 @node Keep Arguments, , Trail Commands, Stack and Trail
12046 @section Keep Arguments
12050 @pindex calc-keep-args
12051 The @kbd{K} (@code{calc-keep-args}) command acts like a prefix for
12052 the following command. It prevents that command from removing its
12053 arguments from the stack. For example, after @kbd{2 @key{RET} 3 +},
12054 the stack contains the sole number 5, but after @kbd{2 @key{RET} 3 K +},
12055 the stack contains the arguments and the result: @samp{2 3 5}.
12057 With the exception of keyboard macros, this works for all commands that
12058 take arguments off the stack. (To avoid potentially unpleasant behavior,
12059 a @kbd{K} prefix before a keyboard macro will be ignored. A @kbd{K}
12060 prefix called @emph{within} the keyboard macro will still take effect.)
12061 As another example, @kbd{K a s} simplifies a formula, pushing the
12062 simplified version of the formula onto the stack after the original
12063 formula (rather than replacing the original formula). Note that you
12064 could get the same effect by typing @kbd{@key{RET} a s}, copying the
12065 formula and then simplifying the copy. One difference is that for a very
12066 large formula the time taken to format the intermediate copy in
12067 @kbd{@key{RET} a s} could be noticeable; @kbd{K a s} would avoid this
12070 Even stack manipulation commands are affected. @key{TAB} works by
12071 popping two values and pushing them back in the opposite order,
12072 so @kbd{2 @key{RET} 3 K @key{TAB}} produces @samp{2 3 3 2}.
12074 A few Calc commands provide other ways of doing the same thing.
12075 For example, @kbd{' sin($)} replaces the number on the stack with
12076 its sine using algebraic entry; to push the sine and keep the
12077 original argument you could use either @kbd{' sin($1)} or
12078 @kbd{K ' sin($)}. @xref{Algebraic Entry}. Also, the @kbd{s s}
12079 command is effectively the same as @kbd{K s t}. @xref{Storing Variables}.
12081 If you execute a command and then decide you really wanted to keep
12082 the argument, you can press @kbd{M-@key{RET}} (@code{calc-last-args}).
12083 This command pushes the last arguments that were popped by any command
12084 onto the stack. Note that the order of things on the stack will be
12085 different than with @kbd{K}: @kbd{2 @key{RET} 3 + M-@key{RET}} leaves
12086 @samp{5 2 3} on the stack instead of @samp{2 3 5}. @xref{Undo}.
12088 @node Mode Settings, Arithmetic, Stack and Trail, Top
12089 @chapter Mode Settings
12092 This chapter describes commands that set modes in the Calculator.
12093 They do not affect the contents of the stack, although they may change
12094 the @emph{appearance} or @emph{interpretation} of the stack's contents.
12097 * General Mode Commands::
12099 * Inverse and Hyperbolic::
12100 * Calculation Modes::
12101 * Simplification Modes::
12109 @node General Mode Commands, Precision, Mode Settings, Mode Settings
12110 @section General Mode Commands
12114 @pindex calc-save-modes
12115 @cindex Continuous memory
12116 @cindex Saving mode settings
12117 @cindex Permanent mode settings
12118 @cindex Calc init file, mode settings
12119 You can save all of the current mode settings in your Calc init file
12120 (the file given by the variable @code{calc-settings-file}, typically
12121 @file{~/.emacs.d/calc.el}) with the @kbd{m m} (@code{calc-save-modes})
12122 command. This will cause Emacs to reestablish these modes each time
12123 it starts up. The modes saved in the file include everything
12124 controlled by the @kbd{m} and @kbd{d} prefix keys, the current
12125 precision and binary word size, whether or not the trail is displayed,
12126 the current height of the Calc window, and more. The current
12127 interface (used when you type @kbd{C-x * *}) is also saved. If there
12128 were already saved mode settings in the file, they are replaced.
12129 Otherwise, the new mode information is appended to the end of the
12133 @pindex calc-mode-record-mode
12134 The @kbd{m R} (@code{calc-mode-record-mode}) command tells Calc to
12135 record all the mode settings (as if by pressing @kbd{m m}) every
12136 time a mode setting changes. If the modes are saved this way, then this
12137 ``automatic mode recording'' mode is also saved.
12138 Type @kbd{m R} again to disable this method of recording the mode
12139 settings. To turn it off permanently, the @kbd{m m} command will also be
12140 necessary. (If Embedded mode is enabled, other options for recording
12141 the modes are available; @pxref{Mode Settings in Embedded Mode}.)
12144 @pindex calc-settings-file-name
12145 The @kbd{m F} (@code{calc-settings-file-name}) command allows you to
12146 choose a different file than the current value of @code{calc-settings-file}
12147 for @kbd{m m}, @kbd{Z P}, and similar commands to save permanent information.
12148 You are prompted for a file name. All Calc modes are then reset to
12149 their default values, then settings from the file you named are loaded
12150 if this file exists, and this file becomes the one that Calc will
12151 use in the future for commands like @kbd{m m}. The default settings
12152 file name is @file{~/.emacs.d/calc.el}. You can see the current file name by
12153 giving a blank response to the @kbd{m F} prompt. See also the
12154 discussion of the @code{calc-settings-file} variable; @pxref{Customizing Calc}.
12156 If the file name you give is your user init file (typically
12157 @file{~/.emacs}), @kbd{m F} will not automatically load the new file. This
12158 is because your user init file may contain other things you don't want
12159 to reread. You can give
12160 a numeric prefix argument of 1 to @kbd{m F} to force it to read the
12161 file no matter what. Conversely, an argument of @mathit{-1} tells
12162 @kbd{m F} @emph{not} to read the new file. An argument of 2 or @mathit{-2}
12163 tells @kbd{m F} not to reset the modes to their defaults beforehand,
12164 which is useful if you intend your new file to have a variant of the
12165 modes present in the file you were using before.
12168 @pindex calc-always-load-extensions
12169 The @kbd{m x} (@code{calc-always-load-extensions}) command enables a mode
12170 in which the first use of Calc loads the entire program, including all
12171 extensions modules. Otherwise, the extensions modules will not be loaded
12172 until the various advanced Calc features are used. Since this mode only
12173 has effect when Calc is first loaded, @kbd{m x} is usually followed by
12174 @kbd{m m} to make the mode-setting permanent. To load all of Calc just
12175 once, rather than always in the future, you can press @kbd{C-x * L}.
12178 @pindex calc-shift-prefix
12179 The @kbd{m S} (@code{calc-shift-prefix}) command enables a mode in which
12180 all of Calc's letter prefix keys may be typed shifted as well as unshifted.
12181 If you are typing, say, @kbd{a S} (@code{calc-solve-for}) quite often
12182 you might find it easier to turn this mode on so that you can type
12183 @kbd{A S} instead. When this mode is enabled, the commands that used to
12184 be on those single shifted letters (e.g., @kbd{A} (@code{calc-abs})) can
12185 now be invoked by pressing the shifted letter twice: @kbd{A A}. Note
12186 that the @kbd{v} prefix key always works both shifted and unshifted, and
12187 the @kbd{z} and @kbd{Z} prefix keys are always distinct. Also, the @kbd{h}
12188 prefix is not affected by this mode. Press @kbd{m S} again to disable
12189 shifted-prefix mode.
12191 @node Precision, Inverse and Hyperbolic, General Mode Commands, Mode Settings
12196 @pindex calc-precision
12197 @cindex Precision of calculations
12198 The @kbd{p} (@code{calc-precision}) command controls the precision to
12199 which floating-point calculations are carried. The precision must be
12200 at least 3 digits and may be arbitrarily high, within the limits of
12201 memory and time. This affects only floats: Integer and rational
12202 calculations are always carried out with as many digits as necessary.
12204 The @kbd{p} key prompts for the current precision. If you wish you
12205 can instead give the precision as a numeric prefix argument.
12207 Many internal calculations are carried to one or two digits higher
12208 precision than normal. Results are rounded down afterward to the
12209 current precision. Unless a special display mode has been selected,
12210 floats are always displayed with their full stored precision, i.e.,
12211 what you see is what you get. Reducing the current precision does not
12212 round values already on the stack, but those values will be rounded
12213 down before being used in any calculation. The @kbd{c 0} through
12214 @kbd{c 9} commands (@pxref{Conversions}) can be used to round an
12215 existing value to a new precision.
12217 @cindex Accuracy of calculations
12218 It is important to distinguish the concepts of @dfn{precision} and
12219 @dfn{accuracy}. In the normal usage of these words, the number
12220 123.4567 has a precision of 7 digits but an accuracy of 4 digits.
12221 The precision is the total number of digits not counting leading
12222 or trailing zeros (regardless of the position of the decimal point).
12223 The accuracy is simply the number of digits after the decimal point
12224 (again not counting trailing zeros). In Calc you control the precision,
12225 not the accuracy of computations. If you were to set the accuracy
12226 instead, then calculations like @samp{exp(100)} would generate many
12227 more digits than you would typically need, while @samp{exp(-100)} would
12228 probably round to zero! In Calc, both these computations give you
12229 exactly 12 (or the requested number of) significant digits.
12231 The only Calc features that deal with accuracy instead of precision
12232 are fixed-point display mode for floats (@kbd{d f}; @pxref{Float Formats}),
12233 and the rounding functions like @code{floor} and @code{round}
12234 (@pxref{Integer Truncation}). Also, @kbd{c 0} through @kbd{c 9}
12235 deal with both precision and accuracy depending on the magnitudes
12236 of the numbers involved.
12238 If you need to work with a particular fixed accuracy (say, dollars and
12239 cents with two digits after the decimal point), one solution is to work
12240 with integers and an ``implied'' decimal point. For example, $8.99
12241 divided by 6 would be entered @kbd{899 @key{RET} 6 /}, yielding 149.833
12242 (actually $1.49833 with our implied decimal point); pressing @kbd{R}
12243 would round this to 150 cents, i.e., $1.50.
12245 @xref{Floats}, for still more on floating-point precision and related
12248 @node Inverse and Hyperbolic, Calculation Modes, Precision, Mode Settings
12249 @section Inverse and Hyperbolic Flags
12253 @pindex calc-inverse
12254 There is no single-key equivalent to the @code{calc-arcsin} function.
12255 Instead, you must first press @kbd{I} (@code{calc-inverse}) to set
12256 the @dfn{Inverse Flag}, then press @kbd{S} (@code{calc-sin}).
12257 The @kbd{I} key actually toggles the Inverse Flag. When this flag
12258 is set, the word @samp{Inv} appears in the mode line.
12261 @pindex calc-hyperbolic
12262 Likewise, the @kbd{H} key (@code{calc-hyperbolic}) sets or clears the
12263 Hyperbolic Flag, which transforms @code{calc-sin} into @code{calc-sinh}.
12264 If both of these flags are set at once, the effect will be
12265 @code{calc-arcsinh}. (The Hyperbolic flag is also used by some
12266 non-trigonometric commands; for example @kbd{H L} computes a base-10,
12267 instead of base-@mathit{e}, logarithm.)
12269 Command names like @code{calc-arcsin} are provided for completeness, and
12270 may be executed with @kbd{x} or @kbd{M-x}. Their effect is simply to
12271 toggle the Inverse and/or Hyperbolic flags and then execute the
12272 corresponding base command (@code{calc-sin} in this case).
12275 @pindex calc-option
12276 The @kbd{O} key (@code{calc-option}) sets another flag, the
12277 @dfn{Option Flag}, which also can alter the subsequent Calc command in
12280 The Inverse, Hyperbolic and Option flags apply only to the next
12281 Calculator command, after which they are automatically cleared. (They
12282 are also cleared if the next keystroke is not a Calc command.) Digits
12283 you type after @kbd{I}, @kbd{H} or @kbd{O} (or @kbd{K}) are treated as
12284 prefix arguments for the next command, not as numeric entries. The
12285 same is true of @kbd{C-u}, but not of the minus sign (@kbd{K -} means
12286 to subtract and keep arguments).
12288 Another Calc prefix flag, @kbd{K} (keep-arguments), is discussed
12289 elsewhere. @xref{Keep Arguments}.
12291 @node Calculation Modes, Simplification Modes, Inverse and Hyperbolic, Mode Settings
12292 @section Calculation Modes
12295 The commands in this section are two-key sequences beginning with
12296 the @kbd{m} prefix. (That's the letter @kbd{m}, not the @key{META} key.)
12297 The @samp{m a} (@code{calc-algebraic-mode}) command is described elsewhere
12298 (@pxref{Algebraic Entry}).
12307 * Automatic Recomputation::
12308 * Working Message::
12311 @node Angular Modes, Polar Mode, Calculation Modes, Calculation Modes
12312 @subsection Angular Modes
12315 @cindex Angular mode
12316 The Calculator supports three notations for angles: radians, degrees,
12317 and degrees-minutes-seconds. When a number is presented to a function
12318 like @code{sin} that requires an angle, the current angular mode is
12319 used to interpret the number as either radians or degrees. If an HMS
12320 form is presented to @code{sin}, it is always interpreted as
12321 degrees-minutes-seconds.
12323 Functions that compute angles produce a number in radians, a number in
12324 degrees, or an HMS form depending on the current angular mode. If the
12325 result is a complex number and the current mode is HMS, the number is
12326 instead expressed in degrees. (Complex-number calculations would
12327 normally be done in Radians mode, though. Complex numbers are converted
12328 to degrees by calculating the complex result in radians and then
12329 multiplying by 180 over @cpi{}.)
12332 @pindex calc-radians-mode
12334 @pindex calc-degrees-mode
12336 @pindex calc-hms-mode
12337 The @kbd{m r} (@code{calc-radians-mode}), @kbd{m d} (@code{calc-degrees-mode}),
12338 and @kbd{m h} (@code{calc-hms-mode}) commands control the angular mode.
12339 The current angular mode is displayed on the Emacs mode line.
12340 The default angular mode is Degrees.
12342 @node Polar Mode, Fraction Mode, Angular Modes, Calculation Modes
12343 @subsection Polar Mode
12347 The Calculator normally ``prefers'' rectangular complex numbers in the
12348 sense that rectangular form is used when the proper form can not be
12349 decided from the input. This might happen by multiplying a rectangular
12350 number by a polar one, by taking the square root of a negative real
12351 number, or by entering @kbd{( 2 @key{SPC} 3 )}.
12354 @pindex calc-polar-mode
12355 The @kbd{m p} (@code{calc-polar-mode}) command toggles complex-number
12356 preference between rectangular and polar forms. In Polar mode, all
12357 of the above example situations would produce polar complex numbers.
12359 @node Fraction Mode, Infinite Mode, Polar Mode, Calculation Modes
12360 @subsection Fraction Mode
12363 @cindex Fraction mode
12364 @cindex Division of integers
12365 Division of two integers normally yields a floating-point number if the
12366 result cannot be expressed as an integer. In some cases you would
12367 rather get an exact fractional answer. One way to accomplish this is
12368 to use the @kbd{:} (@code{calc-fdiv}) [@code{fdiv}] command, which
12369 divides the two integers on the top of the stack to produce a fraction:
12370 @kbd{6 @key{RET} 4 :} produces @expr{3:2} even though
12371 @kbd{6 @key{RET} 4 /} produces @expr{1.5}.
12374 @pindex calc-frac-mode
12375 To set the Calculator to produce fractional results for normal integer
12376 divisions, use the @kbd{m f} (@code{calc-frac-mode}) command.
12377 For example, @expr{8/4} produces @expr{2} in either mode,
12378 but @expr{6/4} produces @expr{3:2} in Fraction mode, @expr{1.5} in
12381 At any time you can use @kbd{c f} (@code{calc-float}) to convert a
12382 fraction to a float, or @kbd{c F} (@code{calc-fraction}) to convert a
12383 float to a fraction. @xref{Conversions}.
12385 @node Infinite Mode, Symbolic Mode, Fraction Mode, Calculation Modes
12386 @subsection Infinite Mode
12389 @cindex Infinite mode
12390 The Calculator normally treats results like @expr{1 / 0} as errors;
12391 formulas like this are left in unsimplified form. But Calc can be
12392 put into a mode where such calculations instead produce ``infinite''
12396 @pindex calc-infinite-mode
12397 The @kbd{m i} (@code{calc-infinite-mode}) command turns this mode
12398 on and off. When the mode is off, infinities do not arise except
12399 in calculations that already had infinities as inputs. (One exception
12400 is that infinite open intervals like @samp{[0 .. inf)} can be
12401 generated; however, intervals closed at infinity (@samp{[0 .. inf]})
12402 will not be generated when Infinite mode is off.)
12404 With Infinite mode turned on, @samp{1 / 0} will generate @code{uinf},
12405 an undirected infinity. @xref{Infinities}, for a discussion of the
12406 difference between @code{inf} and @code{uinf}. Also, @expr{0 / 0}
12407 evaluates to @code{nan}, the ``indeterminate'' symbol. Various other
12408 functions can also return infinities in this mode; for example,
12409 @samp{ln(0) = -inf}, and @samp{gamma(-7) = uinf}. Once again,
12410 note that @samp{exp(inf) = inf} regardless of Infinite mode because
12411 this calculation has infinity as an input.
12413 @cindex Positive Infinite mode
12414 The @kbd{m i} command with a numeric prefix argument of zero,
12415 i.e., @kbd{C-u 0 m i}, turns on a Positive Infinite mode in
12416 which zero is treated as positive instead of being directionless.
12417 Thus, @samp{1 / 0 = inf} and @samp{-1 / 0 = -inf} in this mode.
12418 Note that zero never actually has a sign in Calc; there are no
12419 separate representations for @mathit{+0} and @mathit{-0}. Positive
12420 Infinite mode merely changes the interpretation given to the
12421 single symbol, @samp{0}. One consequence of this is that, while
12422 you might expect @samp{1 / -0 = -inf}, actually @samp{1 / -0}
12423 is equivalent to @samp{1 / 0}, which is equal to positive @code{inf}.
12425 @node Symbolic Mode, Matrix Mode, Infinite Mode, Calculation Modes
12426 @subsection Symbolic Mode
12429 @cindex Symbolic mode
12430 @cindex Inexact results
12431 Calculations are normally performed numerically wherever possible.
12432 For example, the @code{calc-sqrt} command, or @code{sqrt} function in an
12433 algebraic expression, produces a numeric answer if the argument is a
12434 number or a symbolic expression if the argument is an expression:
12435 @kbd{2 Q} pushes 1.4142 but @kbd{@key{'} x+1 @key{RET} Q} pushes @samp{sqrt(x+1)}.
12438 @pindex calc-symbolic-mode
12439 In @dfn{Symbolic mode}, controlled by the @kbd{m s} (@code{calc-symbolic-mode})
12440 command, functions which would produce inexact, irrational results are
12441 left in symbolic form. Thus @kbd{16 Q} pushes 4, but @kbd{2 Q} pushes
12445 @pindex calc-eval-num
12446 The shift-@kbd{N} (@code{calc-eval-num}) command evaluates numerically
12447 the expression at the top of the stack, by temporarily disabling
12448 @code{calc-symbolic-mode} and executing @kbd{=} (@code{calc-evaluate}).
12449 Given a numeric prefix argument, it also
12450 sets the floating-point precision to the specified value for the duration
12453 To evaluate a formula numerically without expanding the variables it
12454 contains, you can use the key sequence @kbd{m s a v m s} (this uses
12455 @code{calc-alg-evaluate}, which resimplifies but doesn't evaluate
12458 @node Matrix Mode, Automatic Recomputation, Symbolic Mode, Calculation Modes
12459 @subsection Matrix and Scalar Modes
12462 @cindex Matrix mode
12463 @cindex Scalar mode
12464 Calc sometimes makes assumptions during algebraic manipulation that
12465 are awkward or incorrect when vectors and matrices are involved.
12466 Calc has two modes, @dfn{Matrix mode} and @dfn{Scalar mode}, which
12467 modify its behavior around vectors in useful ways.
12470 @pindex calc-matrix-mode
12471 Press @kbd{m v} (@code{calc-matrix-mode}) once to enter Matrix mode.
12472 In this mode, all objects are assumed to be matrices unless provably
12473 otherwise. One major effect is that Calc will no longer consider
12474 multiplication to be commutative. (Recall that in matrix arithmetic,
12475 @samp{A*B} is not the same as @samp{B*A}.) This assumption affects
12476 rewrite rules and algebraic simplification. Another effect of this
12477 mode is that calculations that would normally produce constants like
12478 0 and 1 (e.g., @expr{a - a} and @expr{a / a}, respectively) will now
12479 produce function calls that represent ``generic'' zero or identity
12480 matrices: @samp{idn(0)}, @samp{idn(1)}. The @code{idn} function
12481 @samp{idn(@var{a},@var{n})} returns @var{a} times an @var{n}x@var{n}
12482 identity matrix; if @var{n} is omitted, it doesn't know what
12483 dimension to use and so the @code{idn} call remains in symbolic
12484 form. However, if this generic identity matrix is later combined
12485 with a matrix whose size is known, it will be converted into
12486 a true identity matrix of the appropriate size. On the other hand,
12487 if it is combined with a scalar (as in @samp{idn(1) + 2}), Calc
12488 will assume it really was a scalar after all and produce, e.g., 3.
12490 Press @kbd{m v} a second time to get Scalar mode. Here, objects are
12491 assumed @emph{not} to be vectors or matrices unless provably so.
12492 For example, normally adding a variable to a vector, as in
12493 @samp{[x, y, z] + a}, will leave the sum in symbolic form because
12494 as far as Calc knows, @samp{a} could represent either a number or
12495 another 3-vector. In Scalar mode, @samp{a} is assumed to be a
12496 non-vector, and the addition is evaluated to @samp{[x+a, y+a, z+a]}.
12498 Press @kbd{m v} a third time to return to the normal mode of operation.
12500 If you press @kbd{m v} with a numeric prefix argument @var{n}, you
12501 get a special ``dimensioned'' Matrix mode in which matrices of
12502 unknown size are assumed to be @var{n}x@var{n} square matrices.
12503 Then, the function call @samp{idn(1)} will expand into an actual
12504 matrix rather than representing a ``generic'' matrix. Simply typing
12505 @kbd{C-u m v} will get you a square Matrix mode, in which matrices of
12506 unknown size are assumed to be square matrices of unspecified size.
12508 @cindex Declaring scalar variables
12509 Of course these modes are approximations to the true state of
12510 affairs, which is probably that some quantities will be matrices
12511 and others will be scalars. One solution is to ``declare''
12512 certain variables or functions to be scalar-valued.
12513 @xref{Declarations}, to see how to make declarations in Calc.
12515 There is nothing stopping you from declaring a variable to be
12516 scalar and then storing a matrix in it; however, if you do, the
12517 results you get from Calc may not be valid. Suppose you let Calc
12518 get the result @samp{[x+a, y+a, z+a]} shown above, and then stored
12519 @samp{[1, 2, 3]} in @samp{a}. The result would not be the same as
12520 for @samp{[x, y, z] + [1, 2, 3]}, but that's because you have broken
12521 your earlier promise to Calc that @samp{a} would be scalar.
12523 Another way to mix scalars and matrices is to use selections
12524 (@pxref{Selecting Subformulas}). Use Matrix mode when operating on
12525 your formula normally; then, to apply Scalar mode to a certain part
12526 of the formula without affecting the rest just select that part,
12527 change into Scalar mode and press @kbd{=} to resimplify the part
12528 under this mode, then change back to Matrix mode before deselecting.
12530 @node Automatic Recomputation, Working Message, Matrix Mode, Calculation Modes
12531 @subsection Automatic Recomputation
12534 The @dfn{evaluates-to} operator, @samp{=>}, has the special
12535 property that any @samp{=>} formulas on the stack are recomputed
12536 whenever variable values or mode settings that might affect them
12537 are changed. @xref{Evaluates-To Operator}.
12540 @pindex calc-auto-recompute
12541 The @kbd{m C} (@code{calc-auto-recompute}) command turns this
12542 automatic recomputation on and off. If you turn it off, Calc will
12543 not update @samp{=>} operators on the stack (nor those in the
12544 attached Embedded mode buffer, if there is one). They will not
12545 be updated unless you explicitly do so by pressing @kbd{=} or until
12546 you press @kbd{m C} to turn recomputation back on. (While automatic
12547 recomputation is off, you can think of @kbd{m C m C} as a command
12548 to update all @samp{=>} operators while leaving recomputation off.)
12550 To update @samp{=>} operators in an Embedded buffer while
12551 automatic recomputation is off, use @w{@kbd{C-x * u}}.
12552 @xref{Embedded Mode}.
12554 @node Working Message, , Automatic Recomputation, Calculation Modes
12555 @subsection Working Messages
12558 @cindex Performance
12559 @cindex Working messages
12560 Since the Calculator is written entirely in Emacs Lisp, which is not
12561 designed for heavy numerical work, many operations are quite slow.
12562 The Calculator normally displays the message @samp{Working...} in the
12563 echo area during any command that may be slow. In addition, iterative
12564 operations such as square roots and trigonometric functions display the
12565 intermediate result at each step. Both of these types of messages can
12566 be disabled if you find them distracting.
12569 @pindex calc-working
12570 Type @kbd{m w} (@code{calc-working}) with a numeric prefix of 0 to
12571 disable all ``working'' messages. Use a numeric prefix of 1 to enable
12572 only the plain @samp{Working...} message. Use a numeric prefix of 2 to
12573 see intermediate results as well. With no numeric prefix this displays
12576 While it may seem that the ``working'' messages will slow Calc down
12577 considerably, experiments have shown that their impact is actually
12578 quite small. But if your terminal is slow you may find that it helps
12579 to turn the messages off.
12581 @node Simplification Modes, Declarations, Calculation Modes, Mode Settings
12582 @section Simplification Modes
12585 The current @dfn{simplification mode} controls how numbers and formulas
12586 are ``normalized'' when being taken from or pushed onto the stack.
12587 Some normalizations are unavoidable, such as rounding floating-point
12588 results to the current precision, and reducing fractions to simplest
12589 form. Others, such as simplifying a formula like @expr{a+a} (or @expr{2+3}),
12590 are done by default but can be turned off when necessary.
12592 When you press a key like @kbd{+} when @expr{2} and @expr{3} are on the
12593 stack, Calc pops these numbers, normalizes them, creates the formula
12594 @expr{2+3}, normalizes it, and pushes the result. Of course the standard
12595 rules for normalizing @expr{2+3} will produce the result @expr{5}.
12597 Simplification mode commands consist of the lower-case @kbd{m} prefix key
12598 followed by a shifted letter.
12601 @pindex calc-no-simplify-mode
12602 The @kbd{m O} (@code{calc-no-simplify-mode}) command turns off all optional
12603 simplifications. These would leave a formula like @expr{2+3} alone. In
12604 fact, nothing except simple numbers are ever affected by normalization
12608 @pindex calc-num-simplify-mode
12609 The @kbd{m N} (@code{calc-num-simplify-mode}) command turns off simplification
12610 of any formulas except those for which all arguments are constants. For
12611 example, @expr{1+2} is simplified to @expr{3}, and @expr{a+(2-2)} is
12612 simplified to @expr{a+0} but no further, since one argument of the sum
12613 is not a constant. Unfortunately, @expr{(a+2)-2} is @emph{not} simplified
12614 because the top-level @samp{-} operator's arguments are not both
12615 constant numbers (one of them is the formula @expr{a+2}).
12616 A constant is a number or other numeric object (such as a constant
12617 error form or modulo form), or a vector all of whose
12618 elements are constant.
12621 @pindex calc-default-simplify-mode
12622 The @kbd{m D} (@code{calc-default-simplify-mode}) command restores the
12623 default simplifications for all formulas. This includes many easy and
12624 fast algebraic simplifications such as @expr{a+0} to @expr{a}, and
12625 @expr{a + 2 a} to @expr{3 a}, as well as evaluating functions like
12626 @expr{@tfn{deriv}(x^2, x)} to @expr{2 x}.
12629 @pindex calc-bin-simplify-mode
12630 The @kbd{m B} (@code{calc-bin-simplify-mode}) mode applies the default
12631 simplifications to a result and then, if the result is an integer,
12632 uses the @kbd{b c} (@code{calc-clip}) command to clip the integer according
12633 to the current binary word size. @xref{Binary Functions}. Real numbers
12634 are rounded to the nearest integer and then clipped; other kinds of
12635 results (after the default simplifications) are left alone.
12638 @pindex calc-alg-simplify-mode
12639 The @kbd{m A} (@code{calc-alg-simplify-mode}) mode does algebraic
12640 simplification; it applies all the default simplifications, and also
12641 the more powerful (and slower) simplifications made by @kbd{a s}
12642 (@code{calc-simplify}). @xref{Algebraic Simplifications}.
12645 @pindex calc-ext-simplify-mode
12646 The @kbd{m E} (@code{calc-ext-simplify-mode}) mode does ``extended''
12647 algebraic simplification, as by the @kbd{a e} (@code{calc-simplify-extended})
12648 command. @xref{Unsafe Simplifications}.
12651 @pindex calc-units-simplify-mode
12652 The @kbd{m U} (@code{calc-units-simplify-mode}) mode does units
12653 simplification; it applies the command @kbd{u s}
12654 (@code{calc-simplify-units}), which in turn
12655 is a superset of @kbd{a s}. In this mode, variable names which
12656 are identifiable as unit names (like @samp{mm} for ``millimeters'')
12657 are simplified with their unit definitions in mind.
12659 A common technique is to set the simplification mode down to the lowest
12660 amount of simplification you will allow to be applied automatically, then
12661 use manual commands like @kbd{a s} and @kbd{c c} (@code{calc-clean}) to
12662 perform higher types of simplifications on demand. @xref{Algebraic
12663 Definitions}, for another sample use of No-Simplification mode.
12665 @node Declarations, Display Modes, Simplification Modes, Mode Settings
12666 @section Declarations
12669 A @dfn{declaration} is a statement you make that promises you will
12670 use a certain variable or function in a restricted way. This may
12671 give Calc the freedom to do things that it couldn't do if it had to
12672 take the fully general situation into account.
12675 * Declaration Basics::
12676 * Kinds of Declarations::
12677 * Functions for Declarations::
12680 @node Declaration Basics, Kinds of Declarations, Declarations, Declarations
12681 @subsection Declaration Basics
12685 @pindex calc-declare-variable
12686 The @kbd{s d} (@code{calc-declare-variable}) command is the easiest
12687 way to make a declaration for a variable. This command prompts for
12688 the variable name, then prompts for the declaration. The default
12689 at the declaration prompt is the previous declaration, if any.
12690 You can edit this declaration, or press @kbd{C-k} to erase it and
12691 type a new declaration. (Or, erase it and press @key{RET} to clear
12692 the declaration, effectively ``undeclaring'' the variable.)
12694 A declaration is in general a vector of @dfn{type symbols} and
12695 @dfn{range} values. If there is only one type symbol or range value,
12696 you can write it directly rather than enclosing it in a vector.
12697 For example, @kbd{s d foo @key{RET} real @key{RET}} declares @code{foo} to
12698 be a real number, and @kbd{s d bar @key{RET} [int, const, [1..6]] @key{RET}}
12699 declares @code{bar} to be a constant integer between 1 and 6.
12700 (Actually, you can omit the outermost brackets and Calc will
12701 provide them for you: @kbd{s d bar @key{RET} int, const, [1..6] @key{RET}}.)
12703 @cindex @code{Decls} variable
12705 Declarations in Calc are kept in a special variable called @code{Decls}.
12706 This variable encodes the set of all outstanding declarations in
12707 the form of a matrix. Each row has two elements: A variable or
12708 vector of variables declared by that row, and the declaration
12709 specifier as described above. You can use the @kbd{s D} command to
12710 edit this variable if you wish to see all the declarations at once.
12711 @xref{Operations on Variables}, for a description of this command
12712 and the @kbd{s p} command that allows you to save your declarations
12713 permanently if you wish.
12715 Items being declared can also be function calls. The arguments in
12716 the call are ignored; the effect is to say that this function returns
12717 values of the declared type for any valid arguments. The @kbd{s d}
12718 command declares only variables, so if you wish to make a function
12719 declaration you will have to edit the @code{Decls} matrix yourself.
12721 For example, the declaration matrix
12727 [ f(1,2,3), [0 .. inf) ] ]
12732 declares that @code{foo} represents a real number, @code{j}, @code{k}
12733 and @code{n} represent integers, and the function @code{f} always
12734 returns a real number in the interval shown.
12737 If there is a declaration for the variable @code{All}, then that
12738 declaration applies to all variables that are not otherwise declared.
12739 It does not apply to function names. For example, using the row
12740 @samp{[All, real]} says that all your variables are real unless they
12741 are explicitly declared without @code{real} in some other row.
12742 The @kbd{s d} command declares @code{All} if you give a blank
12743 response to the variable-name prompt.
12745 @node Kinds of Declarations, Functions for Declarations, Declaration Basics, Declarations
12746 @subsection Kinds of Declarations
12749 The type-specifier part of a declaration (that is, the second prompt
12750 in the @kbd{s d} command) can be a type symbol, an interval, or a
12751 vector consisting of zero or more type symbols followed by zero or
12752 more intervals or numbers that represent the set of possible values
12757 [ [ a, [1, 2, 3, 4, 5] ]
12759 [ c, [int, 1 .. 5] ] ]
12763 Here @code{a} is declared to contain one of the five integers shown;
12764 @code{b} is any number in the interval from 1 to 5 (any real number
12765 since we haven't specified), and @code{c} is any integer in that
12766 interval. Thus the declarations for @code{a} and @code{c} are
12767 nearly equivalent (see below).
12769 The type-specifier can be the empty vector @samp{[]} to say that
12770 nothing is known about a given variable's value. This is the same
12771 as not declaring the variable at all except that it overrides any
12772 @code{All} declaration which would otherwise apply.
12774 The initial value of @code{Decls} is the empty vector @samp{[]}.
12775 If @code{Decls} has no stored value or if the value stored in it
12776 is not valid, it is ignored and there are no declarations as far
12777 as Calc is concerned. (The @kbd{s d} command will replace such a
12778 malformed value with a fresh empty matrix, @samp{[]}, before recording
12779 the new declaration.) Unrecognized type symbols are ignored.
12781 The following type symbols describe what sorts of numbers will be
12782 stored in a variable:
12788 Numerical integers. (Integers or integer-valued floats.)
12790 Fractions. (Rational numbers which are not integers.)
12792 Rational numbers. (Either integers or fractions.)
12794 Floating-point numbers.
12796 Real numbers. (Integers, fractions, or floats. Actually,
12797 intervals and error forms with real components also count as
12800 Positive real numbers. (Strictly greater than zero.)
12802 Nonnegative real numbers. (Greater than or equal to zero.)
12804 Numbers. (Real or complex.)
12807 Calc uses this information to determine when certain simplifications
12808 of formulas are safe. For example, @samp{(x^y)^z} cannot be
12809 simplified to @samp{x^(y z)} in general; for example,
12810 @samp{((-3)^2)^1:2} is 3, but @samp{(-3)^(2*1:2) = (-3)^1} is @mathit{-3}.
12811 However, this simplification @emph{is} safe if @code{z} is known
12812 to be an integer, or if @code{x} is known to be a nonnegative
12813 real number. If you have given declarations that allow Calc to
12814 deduce either of these facts, Calc will perform this simplification
12817 Calc can apply a certain amount of logic when using declarations.
12818 For example, @samp{(x^y)^(2n+1)} will be simplified if @code{n}
12819 has been declared @code{int}; Calc knows that an integer times an
12820 integer, plus an integer, must always be an integer. (In fact,
12821 Calc would simplify @samp{(-x)^(2n+1)} to @samp{-(x^(2n+1))} since
12822 it is able to determine that @samp{2n+1} must be an odd integer.)
12824 Similarly, @samp{(abs(x)^y)^z} will be simplified to @samp{abs(x)^(y z)}
12825 because Calc knows that the @code{abs} function always returns a
12826 nonnegative real. If you had a @code{myabs} function that also had
12827 this property, you could get Calc to recognize it by adding the row
12828 @samp{[myabs(), nonneg]} to the @code{Decls} matrix.
12830 One instance of this simplification is @samp{sqrt(x^2)} (since the
12831 @code{sqrt} function is effectively a one-half power). Normally
12832 Calc leaves this formula alone. After the command
12833 @kbd{s d x @key{RET} real @key{RET}}, however, it can simplify the formula to
12834 @samp{abs(x)}. And after @kbd{s d x @key{RET} nonneg @key{RET}}, Calc can
12835 simplify this formula all the way to @samp{x}.
12837 If there are any intervals or real numbers in the type specifier,
12838 they comprise the set of possible values that the variable or
12839 function being declared can have. In particular, the type symbol
12840 @code{real} is effectively the same as the range @samp{[-inf .. inf]}
12841 (note that infinity is included in the range of possible values);
12842 @code{pos} is the same as @samp{(0 .. inf]}, and @code{nonneg} is
12843 the same as @samp{[0 .. inf]}. Saying @samp{[real, [-5 .. 5]]} is
12844 redundant because the fact that the variable is real can be
12845 deduced just from the interval, but @samp{[int, [-5 .. 5]]} and
12846 @samp{[rat, [-5 .. 5]]} are useful combinations.
12848 Note that the vector of intervals or numbers is in the same format
12849 used by Calc's set-manipulation commands. @xref{Set Operations}.
12851 The type specifier @samp{[1, 2, 3]} is equivalent to
12852 @samp{[numint, 1, 2, 3]}, @emph{not} to @samp{[int, 1, 2, 3]}.
12853 In other words, the range of possible values means only that
12854 the variable's value must be numerically equal to a number in
12855 that range, but not that it must be equal in type as well.
12856 Calc's set operations act the same way; @samp{in(2, [1., 2., 3.])}
12857 and @samp{in(1.5, [1:2, 3:2, 5:2])} both report ``true.''
12859 If you use a conflicting combination of type specifiers, the
12860 results are unpredictable. An example is @samp{[pos, [0 .. 5]]},
12861 where the interval does not lie in the range described by the
12864 ``Real'' declarations mostly affect simplifications involving powers
12865 like the one described above. Another case where they are used
12866 is in the @kbd{a P} command which returns a list of all roots of a
12867 polynomial; if the variable has been declared real, only the real
12868 roots (if any) will be included in the list.
12870 ``Integer'' declarations are used for simplifications which are valid
12871 only when certain values are integers (such as @samp{(x^y)^z}
12874 Another command that makes use of declarations is @kbd{a s}, when
12875 simplifying equations and inequalities. It will cancel @code{x}
12876 from both sides of @samp{a x = b x} only if it is sure @code{x}
12877 is non-zero, say, because it has a @code{pos} declaration.
12878 To declare specifically that @code{x} is real and non-zero,
12879 use @samp{[[-inf .. 0), (0 .. inf]]}. (There is no way in the
12880 current notation to say that @code{x} is nonzero but not necessarily
12881 real.) The @kbd{a e} command does ``unsafe'' simplifications,
12882 including cancelling @samp{x} from the equation when @samp{x} is
12883 not known to be nonzero.
12885 Another set of type symbols distinguish between scalars and vectors.
12889 The value is not a vector.
12891 The value is a vector.
12893 The value is a matrix (a rectangular vector of vectors).
12895 The value is a square matrix.
12898 These type symbols can be combined with the other type symbols
12899 described above; @samp{[int, matrix]} describes an object which
12900 is a matrix of integers.
12902 Scalar/vector declarations are used to determine whether certain
12903 algebraic operations are safe. For example, @samp{[a, b, c] + x}
12904 is normally not simplified to @samp{[a + x, b + x, c + x]}, but
12905 it will be if @code{x} has been declared @code{scalar}. On the
12906 other hand, multiplication is usually assumed to be commutative,
12907 but the terms in @samp{x y} will never be exchanged if both @code{x}
12908 and @code{y} are known to be vectors or matrices. (Calc currently
12909 never distinguishes between @code{vector} and @code{matrix}
12912 @xref{Matrix Mode}, for a discussion of Matrix mode and
12913 Scalar mode, which are similar to declaring @samp{[All, matrix]}
12914 or @samp{[All, scalar]} but much more convenient.
12916 One more type symbol that is recognized is used with the @kbd{H a d}
12917 command for taking total derivatives of a formula. @xref{Calculus}.
12921 The value is a constant with respect to other variables.
12924 Calc does not check the declarations for a variable when you store
12925 a value in it. However, storing @mathit{-3.5} in a variable that has
12926 been declared @code{pos}, @code{int}, or @code{matrix} may have
12927 unexpected effects; Calc may evaluate @samp{sqrt(x^2)} to @expr{3.5}
12928 if it substitutes the value first, or to @expr{-3.5} if @code{x}
12929 was declared @code{pos} and the formula @samp{sqrt(x^2)} is
12930 simplified to @samp{x} before the value is substituted. Before
12931 using a variable for a new purpose, it is best to use @kbd{s d}
12932 or @kbd{s D} to check to make sure you don't still have an old
12933 declaration for the variable that will conflict with its new meaning.
12935 @node Functions for Declarations, , Kinds of Declarations, Declarations
12936 @subsection Functions for Declarations
12939 Calc has a set of functions for accessing the current declarations
12940 in a convenient manner. These functions return 1 if the argument
12941 can be shown to have the specified property, or 0 if the argument
12942 can be shown @emph{not} to have that property; otherwise they are
12943 left unevaluated. These functions are suitable for use with rewrite
12944 rules (@pxref{Conditional Rewrite Rules}) or programming constructs
12945 (@pxref{Conditionals in Macros}). They can be entered only using
12946 algebraic notation. @xref{Logical Operations}, for functions
12947 that perform other tests not related to declarations.
12949 For example, @samp{dint(17)} returns 1 because 17 is an integer, as
12950 do @samp{dint(n)} and @samp{dint(2 n - 3)} if @code{n} has been declared
12951 @code{int}, but @samp{dint(2.5)} and @samp{dint(n + 0.5)} return 0.
12952 Calc consults knowledge of its own built-in functions as well as your
12953 own declarations: @samp{dint(floor(x))} returns 1.
12967 The @code{dint} function checks if its argument is an integer.
12968 The @code{dnatnum} function checks if its argument is a natural
12969 number, i.e., a nonnegative integer. The @code{dnumint} function
12970 checks if its argument is numerically an integer, i.e., either an
12971 integer or an integer-valued float. Note that these and the other
12972 data type functions also accept vectors or matrices composed of
12973 suitable elements, and that real infinities @samp{inf} and @samp{-inf}
12974 are considered to be integers for the purposes of these functions.
12980 The @code{drat} function checks if its argument is rational, i.e.,
12981 an integer or fraction. Infinities count as rational, but intervals
12982 and error forms do not.
12988 The @code{dreal} function checks if its argument is real. This
12989 includes integers, fractions, floats, real error forms, and intervals.
12995 The @code{dimag} function checks if its argument is imaginary,
12996 i.e., is mathematically equal to a real number times @expr{i}.
13010 The @code{dpos} function checks for positive (but nonzero) reals.
13011 The @code{dneg} function checks for negative reals. The @code{dnonneg}
13012 function checks for nonnegative reals, i.e., reals greater than or
13013 equal to zero. Note that the @kbd{a s} command can simplify an
13014 expression like @expr{x > 0} to 1 or 0 using @code{dpos}, and that
13015 @kbd{a s} is effectively applied to all conditions in rewrite rules,
13016 so the actual functions @code{dpos}, @code{dneg}, and @code{dnonneg}
13017 are rarely necessary.
13023 The @code{dnonzero} function checks that its argument is nonzero.
13024 This includes all nonzero real or complex numbers, all intervals that
13025 do not include zero, all nonzero modulo forms, vectors all of whose
13026 elements are nonzero, and variables or formulas whose values can be
13027 deduced to be nonzero. It does not include error forms, since they
13028 represent values which could be anything including zero. (This is
13029 also the set of objects considered ``true'' in conditional contexts.)
13039 The @code{deven} function returns 1 if its argument is known to be
13040 an even integer (or integer-valued float); it returns 0 if its argument
13041 is known not to be even (because it is known to be odd or a non-integer).
13042 The @kbd{a s} command uses this to simplify a test of the form
13043 @samp{x % 2 = 0}. There is also an analogous @code{dodd} function.
13049 The @code{drange} function returns a set (an interval or a vector
13050 of intervals and/or numbers; @pxref{Set Operations}) that describes
13051 the set of possible values of its argument. If the argument is
13052 a variable or a function with a declaration, the range is copied
13053 from the declaration. Otherwise, the possible signs of the
13054 expression are determined using a method similar to @code{dpos},
13055 etc., and a suitable set like @samp{[0 .. inf]} is returned. If
13056 the expression is not provably real, the @code{drange} function
13057 remains unevaluated.
13063 The @code{dscalar} function returns 1 if its argument is provably
13064 scalar, or 0 if its argument is provably non-scalar. It is left
13065 unevaluated if this cannot be determined. (If Matrix mode or Scalar
13066 mode is in effect, this function returns 1 or 0, respectively,
13067 if it has no other information.) When Calc interprets a condition
13068 (say, in a rewrite rule) it considers an unevaluated formula to be
13069 ``false.'' Thus, @samp{dscalar(a)} is ``true'' only if @code{a} is
13070 provably scalar, and @samp{!dscalar(a)} is ``true'' only if @code{a}
13071 is provably non-scalar; both are ``false'' if there is insufficient
13072 information to tell.
13074 @node Display Modes, Language Modes, Declarations, Mode Settings
13075 @section Display Modes
13078 The commands in this section are two-key sequences beginning with the
13079 @kbd{d} prefix. The @kbd{d l} (@code{calc-line-numbering}) and @kbd{d b}
13080 (@code{calc-line-breaking}) commands are described elsewhere;
13081 @pxref{Stack Basics} and @pxref{Normal Language Modes}, respectively.
13082 Display formats for vectors and matrices are also covered elsewhere;
13083 @pxref{Vector and Matrix Formats}.
13085 One thing all display modes have in common is their treatment of the
13086 @kbd{H} prefix. This prefix causes any mode command that would normally
13087 refresh the stack to leave the stack display alone. The word ``Dirty''
13088 will appear in the mode line when Calc thinks the stack display may not
13089 reflect the latest mode settings.
13091 @kindex d @key{RET}
13092 @pindex calc-refresh-top
13093 The @kbd{d @key{RET}} (@code{calc-refresh-top}) command reformats the
13094 top stack entry according to all the current modes. Positive prefix
13095 arguments reformat the top @var{n} entries; negative prefix arguments
13096 reformat the specified entry, and a prefix of zero is equivalent to
13097 @kbd{d @key{SPC}} (@code{calc-refresh}), which reformats the entire stack.
13098 For example, @kbd{H d s M-2 d @key{RET}} changes to scientific notation
13099 but reformats only the top two stack entries in the new mode.
13101 The @kbd{I} prefix has another effect on the display modes. The mode
13102 is set only temporarily; the top stack entry is reformatted according
13103 to that mode, then the original mode setting is restored. In other
13104 words, @kbd{I d s} is equivalent to @kbd{H d s d @key{RET} H d (@var{old mode})}.
13108 * Grouping Digits::
13110 * Complex Formats::
13111 * Fraction Formats::
13114 * Truncating the Stack::
13119 @node Radix Modes, Grouping Digits, Display Modes, Display Modes
13120 @subsection Radix Modes
13123 @cindex Radix display
13124 @cindex Non-decimal numbers
13125 @cindex Decimal and non-decimal numbers
13126 Calc normally displays numbers in decimal (@dfn{base-10} or @dfn{radix-10})
13127 notation. Calc can actually display in any radix from two (binary) to 36.
13128 When the radix is above 10, the letters @code{A} to @code{Z} are used as
13129 digits. When entering such a number, letter keys are interpreted as
13130 potential digits rather than terminating numeric entry mode.
13136 @cindex Hexadecimal integers
13137 @cindex Octal integers
13138 The key sequences @kbd{d 2}, @kbd{d 8}, @kbd{d 6}, and @kbd{d 0} select
13139 binary, octal, hexadecimal, and decimal as the current display radix,
13140 respectively. Numbers can always be entered in any radix, though the
13141 current radix is used as a default if you press @kbd{#} without any initial
13142 digits. A number entered without a @kbd{#} is @emph{always} interpreted
13147 To set the radix generally, use @kbd{d r} (@code{calc-radix}) and enter
13148 an integer from 2 to 36. You can specify the radix as a numeric prefix
13149 argument; otherwise you will be prompted for it.
13152 @pindex calc-leading-zeros
13153 @cindex Leading zeros
13154 Integers normally are displayed with however many digits are necessary to
13155 represent the integer and no more. The @kbd{d z} (@code{calc-leading-zeros})
13156 command causes integers to be padded out with leading zeros according to the
13157 current binary word size. (@xref{Binary Functions}, for a discussion of
13158 word size.) If the absolute value of the word size is @expr{w}, all integers
13159 are displayed with at least enough digits to represent
13160 @texline @math{2^w-1}
13161 @infoline @expr{(2^w)-1}
13162 in the current radix. (Larger integers will still be displayed in their
13165 @cindex Two's complements
13166 Calc can display @expr{w}-bit integers using two's complement
13167 notation, although this is most useful with the binary, octal and
13168 hexadecimal display modes. This option is selected by using the
13169 @kbd{O} option prefix before setting the display radix, and a negative word
13170 size might be appropriate (@pxref{Binary Functions}). In two's
13171 complement notation, the integers in the (nearly) symmetric interval
13173 @texline @math{-2^{w-1}}
13174 @infoline @expr{-2^(w-1)}
13176 @texline @math{2^{w-1}-1}
13177 @infoline @expr{2^(w-1)-1}
13178 are represented by the integers from @expr{0} to @expr{2^w-1}:
13179 the integers from @expr{0} to
13180 @texline @math{2^{w-1}-1}
13181 @infoline @expr{2^(w-1)-1}
13182 are represented by themselves and the integers from
13183 @texline @math{-2^{w-1}}
13184 @infoline @expr{-2^(w-1)}
13185 to @expr{-1} are represented by the integers from
13186 @texline @math{2^{w-1}}
13187 @infoline @expr{2^(w-1)}
13188 to @expr{2^w-1} (the integer @expr{k} is represented by @expr{k+2^w}).
13189 Calc will display a two's complement integer by the radix (either
13190 @expr{2}, @expr{8} or @expr{16}), two @kbd{#} symbols, and then its
13191 representation (including any leading zeros necessary to include all
13192 @expr{w} bits). In a two's complement display mode, numbers that
13193 are not displayed in two's complement notation (i.e., that aren't
13195 @texline @math{-2^{w-1}}
13196 @infoline @expr{-2^(w-1)}
13199 @texline @math{2^{w-1}-1})
13200 @infoline @expr{2^(w-1)-1})
13201 will be represented using Calc's usual notation (in the appropriate
13204 @node Grouping Digits, Float Formats, Radix Modes, Display Modes
13205 @subsection Grouping Digits
13209 @pindex calc-group-digits
13210 @cindex Grouping digits
13211 @cindex Digit grouping
13212 Long numbers can be hard to read if they have too many digits. For
13213 example, the factorial of 30 is 33 digits long! Press @kbd{d g}
13214 (@code{calc-group-digits}) to enable @dfn{Grouping} mode, in which digits
13215 are displayed in clumps of 3 or 4 (depending on the current radix)
13216 separated by commas.
13218 The @kbd{d g} command toggles grouping on and off.
13219 With a numeric prefix of 0, this command displays the current state of
13220 the grouping flag; with an argument of minus one it disables grouping;
13221 with a positive argument @expr{N} it enables grouping on every @expr{N}
13222 digits. For floating-point numbers, grouping normally occurs only
13223 before the decimal point. A negative prefix argument @expr{-N} enables
13224 grouping every @expr{N} digits both before and after the decimal point.
13227 @pindex calc-group-char
13228 The @kbd{d ,} (@code{calc-group-char}) command allows you to choose any
13229 character as the grouping separator. The default is the comma character.
13230 If you find it difficult to read vectors of large integers grouped with
13231 commas, you may wish to use spaces or some other character instead.
13232 This command takes the next character you type, whatever it is, and
13233 uses it as the digit separator. As a special case, @kbd{d , \} selects
13234 @samp{\,} (@TeX{}'s thin-space symbol) as the digit separator.
13236 Please note that grouped numbers will not generally be parsed correctly
13237 if re-read in textual form, say by the use of @kbd{C-x * y} and @kbd{C-x * g}.
13238 (@xref{Kill and Yank}, for details on these commands.) One exception is
13239 the @samp{\,} separator, which doesn't interfere with parsing because it
13240 is ignored by @TeX{} language mode.
13242 @node Float Formats, Complex Formats, Grouping Digits, Display Modes
13243 @subsection Float Formats
13246 Floating-point quantities are normally displayed in standard decimal
13247 form, with scientific notation used if the exponent is especially high
13248 or low. All significant digits are normally displayed. The commands
13249 in this section allow you to choose among several alternative display
13250 formats for floats.
13253 @pindex calc-normal-notation
13254 The @kbd{d n} (@code{calc-normal-notation}) command selects the normal
13255 display format. All significant figures in a number are displayed.
13256 With a positive numeric prefix, numbers are rounded if necessary to
13257 that number of significant digits. With a negative numerix prefix,
13258 the specified number of significant digits less than the current
13259 precision is used. (Thus @kbd{C-u -2 d n} displays 10 digits if the
13260 current precision is 12.)
13263 @pindex calc-fix-notation
13264 The @kbd{d f} (@code{calc-fix-notation}) command selects fixed-point
13265 notation. The numeric argument is the number of digits after the
13266 decimal point, zero or more. This format will relax into scientific
13267 notation if a nonzero number would otherwise have been rounded all the
13268 way to zero. Specifying a negative number of digits is the same as
13269 for a positive number, except that small nonzero numbers will be rounded
13270 to zero rather than switching to scientific notation.
13273 @pindex calc-sci-notation
13274 @cindex Scientific notation, display of
13275 The @kbd{d s} (@code{calc-sci-notation}) command selects scientific
13276 notation. A positive argument sets the number of significant figures
13277 displayed, of which one will be before and the rest after the decimal
13278 point. A negative argument works the same as for @kbd{d n} format.
13279 The default is to display all significant digits.
13282 @pindex calc-eng-notation
13283 @cindex Engineering notation, display of
13284 The @kbd{d e} (@code{calc-eng-notation}) command selects engineering
13285 notation. This is similar to scientific notation except that the
13286 exponent is rounded down to a multiple of three, with from one to three
13287 digits before the decimal point. An optional numeric prefix sets the
13288 number of significant digits to display, as for @kbd{d s}.
13290 It is important to distinguish between the current @emph{precision} and
13291 the current @emph{display format}. After the commands @kbd{C-u 10 p}
13292 and @kbd{C-u 6 d n} the Calculator computes all results to ten
13293 significant figures but displays only six. (In fact, intermediate
13294 calculations are often carried to one or two more significant figures,
13295 but values placed on the stack will be rounded down to ten figures.)
13296 Numbers are never actually rounded to the display precision for storage,
13297 except by commands like @kbd{C-k} and @kbd{C-x * y} which operate on the
13298 actual displayed text in the Calculator buffer.
13301 @pindex calc-point-char
13302 The @kbd{d .} (@code{calc-point-char}) command selects the character used
13303 as a decimal point. Normally this is a period; users in some countries
13304 may wish to change this to a comma. Note that this is only a display
13305 style; on entry, periods must always be used to denote floating-point
13306 numbers, and commas to separate elements in a list.
13308 @node Complex Formats, Fraction Formats, Float Formats, Display Modes
13309 @subsection Complex Formats
13313 @pindex calc-complex-notation
13314 There are three supported notations for complex numbers in rectangular
13315 form. The default is as a pair of real numbers enclosed in parentheses
13316 and separated by a comma: @samp{(a,b)}. The @kbd{d c}
13317 (@code{calc-complex-notation}) command selects this style.
13320 @pindex calc-i-notation
13322 @pindex calc-j-notation
13323 The other notations are @kbd{d i} (@code{calc-i-notation}), in which
13324 numbers are displayed in @samp{a+bi} form, and @kbd{d j}
13325 (@code{calc-j-notation}) which displays the form @samp{a+bj} preferred
13326 in some disciplines.
13328 @cindex @code{i} variable
13330 Complex numbers are normally entered in @samp{(a,b)} format.
13331 If you enter @samp{2+3i} as an algebraic formula, it will be stored as
13332 the formula @samp{2 + 3 * i}. However, if you use @kbd{=} to evaluate
13333 this formula and you have not changed the variable @samp{i}, the @samp{i}
13334 will be interpreted as @samp{(0,1)} and the formula will be simplified
13335 to @samp{(2,3)}. Other commands (like @code{calc-sin}) will @emph{not}
13336 interpret the formula @samp{2 + 3 * i} as a complex number.
13337 @xref{Variables}, under ``special constants.''
13339 @node Fraction Formats, HMS Formats, Complex Formats, Display Modes
13340 @subsection Fraction Formats
13344 @pindex calc-over-notation
13345 Display of fractional numbers is controlled by the @kbd{d o}
13346 (@code{calc-over-notation}) command. By default, a number like
13347 eight thirds is displayed in the form @samp{8:3}. The @kbd{d o} command
13348 prompts for a one- or two-character format. If you give one character,
13349 that character is used as the fraction separator. Common separators are
13350 @samp{:} and @samp{/}. (During input of numbers, the @kbd{:} key must be
13351 used regardless of the display format; in particular, the @kbd{/} is used
13352 for RPN-style division, @emph{not} for entering fractions.)
13354 If you give two characters, fractions use ``integer-plus-fractional-part''
13355 notation. For example, the format @samp{+/} would display eight thirds
13356 as @samp{2+2/3}. If two colons are present in a number being entered,
13357 the number is interpreted in this form (so that the entries @kbd{2:2:3}
13358 and @kbd{8:3} are equivalent).
13360 It is also possible to follow the one- or two-character format with
13361 a number. For example: @samp{:10} or @samp{+/3}. In this case,
13362 Calc adjusts all fractions that are displayed to have the specified
13363 denominator, if possible. Otherwise it adjusts the denominator to
13364 be a multiple of the specified value. For example, in @samp{:6} mode
13365 the fraction @expr{1:6} will be unaffected, but @expr{2:3} will be
13366 displayed as @expr{4:6}, @expr{1:2} will be displayed as @expr{3:6},
13367 and @expr{1:8} will be displayed as @expr{3:24}. Integers are also
13368 affected by this mode: 3 is displayed as @expr{18:6}. Note that the
13369 format @samp{:1} writes fractions the same as @samp{:}, but it writes
13370 integers as @expr{n:1}.
13372 The fraction format does not affect the way fractions or integers are
13373 stored, only the way they appear on the screen. The fraction format
13374 never affects floats.
13376 @node HMS Formats, Date Formats, Fraction Formats, Display Modes
13377 @subsection HMS Formats
13381 @pindex calc-hms-notation
13382 The @kbd{d h} (@code{calc-hms-notation}) command controls the display of
13383 HMS (hours-minutes-seconds) forms. It prompts for a string which
13384 consists basically of an ``hours'' marker, optional punctuation, a
13385 ``minutes'' marker, more optional punctuation, and a ``seconds'' marker.
13386 Punctuation is zero or more spaces, commas, or semicolons. The hours
13387 marker is one or more non-punctuation characters. The minutes and
13388 seconds markers must be single non-punctuation characters.
13390 The default HMS format is @samp{@@ ' "}, producing HMS values of the form
13391 @samp{23@@ 30' 15.75"}. The format @samp{deg, ms} would display this same
13392 value as @samp{23deg, 30m15.75s}. During numeric entry, the @kbd{h} or @kbd{o}
13393 keys are recognized as synonyms for @kbd{@@} regardless of display format.
13394 The @kbd{m} and @kbd{s} keys are recognized as synonyms for @kbd{'} and
13395 @kbd{"}, respectively, but only if an @kbd{@@} (or @kbd{h} or @kbd{o}) has
13396 already been typed; otherwise, they have their usual meanings
13397 (@kbd{m-} prefix and @kbd{s-} prefix). Thus, @kbd{5 "}, @kbd{0 @@ 5 "}, and
13398 @kbd{0 h 5 s} are some of the ways to enter the quantity ``five seconds.''
13399 The @kbd{'} key is recognized as ``minutes'' only if @kbd{@@} (or @kbd{h} or
13400 @kbd{o}) has already been pressed; otherwise it means to switch to algebraic
13403 @node Date Formats, Truncating the Stack, HMS Formats, Display Modes
13404 @subsection Date Formats
13408 @pindex calc-date-notation
13409 The @kbd{d d} (@code{calc-date-notation}) command controls the display
13410 of date forms (@pxref{Date Forms}). It prompts for a string which
13411 contains letters that represent the various parts of a date and time.
13412 To show which parts should be omitted when the form represents a pure
13413 date with no time, parts of the string can be enclosed in @samp{< >}
13414 marks. If you don't include @samp{< >} markers in the format, Calc
13415 guesses at which parts, if any, should be omitted when formatting
13418 The default format is: @samp{<H:mm:SSpp >Www Mmm D, YYYY}.
13419 An example string in this format is @samp{3:32pm Wed Jan 9, 1991}.
13420 If you enter a blank format string, this default format is
13423 Calc uses @samp{< >} notation for nameless functions as well as for
13424 dates. @xref{Specifying Operators}. To avoid confusion with nameless
13425 functions, your date formats should avoid using the @samp{#} character.
13428 * Date Formatting Codes::
13429 * Free-Form Dates::
13430 * Standard Date Formats::
13433 @node Date Formatting Codes, Free-Form Dates, Date Formats, Date Formats
13434 @subsubsection Date Formatting Codes
13437 When displaying a date, the current date format is used. All
13438 characters except for letters and @samp{<} and @samp{>} are
13439 copied literally when dates are formatted. The portion between
13440 @samp{< >} markers is omitted for pure dates, or included for
13441 date/time forms. Letters are interpreted according to the table
13444 When dates are read in during algebraic entry, Calc first tries to
13445 match the input string to the current format either with or without
13446 the time part. The punctuation characters (including spaces) must
13447 match exactly; letter fields must correspond to suitable text in
13448 the input. If this doesn't work, Calc checks if the input is a
13449 simple number; if so, the number is interpreted as a number of days
13450 since Jan 1, 1 AD. Otherwise, Calc tries a much more relaxed and
13451 flexible algorithm which is described in the next section.
13453 Weekday names are ignored during reading.
13455 Two-digit year numbers are interpreted as lying in the range
13456 from 1941 to 2039. Years outside that range are always
13457 entered and displayed in full. Year numbers with a leading
13458 @samp{+} sign are always interpreted exactly, allowing the
13459 entry and display of the years 1 through 99 AD.
13461 Here is a complete list of the formatting codes for dates:
13465 Year: ``91'' for 1991, ``7'' for 2007, ``+23'' for 23 AD.
13467 Year: ``91'' for 1991, ``07'' for 2007, ``+23'' for 23 AD.
13469 Year: ``91'' for 1991, `` 7'' for 2007, ``+23'' for 23 AD.
13471 Year: ``1991'' for 1991, ``23'' for 23 AD.
13473 Year: ``1991'' for 1991, ``+23'' for 23 AD.
13475 Year: ``ad'' or blank.
13477 Year: ``AD'' or blank.
13479 Year: ``ad '' or blank. (Note trailing space.)
13481 Year: ``AD '' or blank.
13483 Year: ``a.d.'' or blank.
13485 Year: ``A.D.'' or blank.
13487 Year: ``bc'' or blank.
13489 Year: ``BC'' or blank.
13491 Year: `` bc'' or blank. (Note leading space.)
13493 Year: `` BC'' or blank.
13495 Year: ``b.c.'' or blank.
13497 Year: ``B.C.'' or blank.
13499 Month: ``8'' for August.
13501 Month: ``08'' for August.
13503 Month: `` 8'' for August.
13505 Month: ``AUG'' for August.
13507 Month: ``Aug'' for August.
13509 Month: ``aug'' for August.
13511 Month: ``AUGUST'' for August.
13513 Month: ``August'' for August.
13515 Day: ``7'' for 7th day of month.
13517 Day: ``07'' for 7th day of month.
13519 Day: `` 7'' for 7th day of month.
13521 Weekday: ``0'' for Sunday, ``6'' for Saturday.
13523 Weekday: ``SUN'' for Sunday.
13525 Weekday: ``Sun'' for Sunday.
13527 Weekday: ``sun'' for Sunday.
13529 Weekday: ``SUNDAY'' for Sunday.
13531 Weekday: ``Sunday'' for Sunday.
13533 Day of year: ``34'' for Feb. 3.
13535 Day of year: ``034'' for Feb. 3.
13537 Day of year: `` 34'' for Feb. 3.
13539 Hour: ``5'' for 5 AM; ``17'' for 5 PM.
13541 Hour: ``05'' for 5 AM; ``17'' for 5 PM.
13543 Hour: `` 5'' for 5 AM; ``17'' for 5 PM.
13545 Hour: ``5'' for 5 AM and 5 PM.
13547 Hour: ``05'' for 5 AM and 5 PM.
13549 Hour: `` 5'' for 5 AM and 5 PM.
13551 AM/PM: ``a'' or ``p''.
13553 AM/PM: ``A'' or ``P''.
13555 AM/PM: ``am'' or ``pm''.
13557 AM/PM: ``AM'' or ``PM''.
13559 AM/PM: ``a.m.'' or ``p.m.''.
13561 AM/PM: ``A.M.'' or ``P.M.''.
13563 Minutes: ``7'' for 7.
13565 Minutes: ``07'' for 7.
13567 Minutes: `` 7'' for 7.
13569 Seconds: ``7'' for 7; ``7.23'' for 7.23.
13571 Seconds: ``07'' for 7; ``07.23'' for 7.23.
13573 Seconds: `` 7'' for 7; `` 7.23'' for 7.23.
13575 Optional seconds: ``07'' for 7; blank for 0.
13577 Optional seconds: `` 7'' for 7; blank for 0.
13579 Numeric date/time: ``726842.25'' for 6:00am Wed Jan 9, 1991.
13581 Numeric date: ``726842'' for any time on Wed Jan 9, 1991.
13583 Julian date/time: ``2448265.75'' for 6:00am Wed Jan 9, 1991.
13585 Julian date: ``2448266'' for any time on Wed Jan 9, 1991.
13587 Unix time: ``663400800'' for 6:00am Wed Jan 9, 1991.
13589 Brackets suppression. An ``X'' at the front of the format
13590 causes the surrounding @w{@samp{< >}} delimiters to be omitted
13591 when formatting dates. Note that the brackets are still
13592 required for algebraic entry.
13595 If ``SS'' or ``BS'' (optional seconds) is preceded by a colon, the
13596 colon is also omitted if the seconds part is zero.
13598 If ``bb,'' ``bbb'' or ``bbbb'' or their upper-case equivalents
13599 appear in the format, then negative year numbers are displayed
13600 without a minus sign. Note that ``aa'' and ``bb'' are mutually
13601 exclusive. Some typical usages would be @samp{YYYY AABB};
13602 @samp{AAAYYYYBBB}; @samp{YYYYBBB}.
13604 The formats ``YY,'' ``YYYY,'' ``MM,'' ``DD,'' ``ddd,'' ``hh,'' ``HH,''
13605 ``mm,'' ``ss,'' and ``SS'' actually match any number of digits during
13606 reading unless several of these codes are strung together with no
13607 punctuation in between, in which case the input must have exactly as
13608 many digits as there are letters in the format.
13610 The ``j,'' ``J,'' and ``U'' formats do not make any time zone
13611 adjustment. They effectively use @samp{julian(x,0)} and
13612 @samp{unixtime(x,0)} to make the conversion; @pxref{Date Arithmetic}.
13614 @node Free-Form Dates, Standard Date Formats, Date Formatting Codes, Date Formats
13615 @subsubsection Free-Form Dates
13618 When reading a date form during algebraic entry, Calc falls back
13619 on the algorithm described here if the input does not exactly
13620 match the current date format. This algorithm generally
13621 ``does the right thing'' and you don't have to worry about it,
13622 but it is described here in full detail for the curious.
13624 Calc does not distinguish between upper- and lower-case letters
13625 while interpreting dates.
13627 First, the time portion, if present, is located somewhere in the
13628 text and then removed. The remaining text is then interpreted as
13631 A time is of the form @samp{hh:mm:ss}, possibly with the seconds
13632 part omitted and possibly with an AM/PM indicator added to indicate
13633 12-hour time. If the AM/PM is present, the minutes may also be
13634 omitted. The AM/PM part may be any of the words @samp{am},
13635 @samp{pm}, @samp{noon}, or @samp{midnight}; each of these may be
13636 abbreviated to one letter, and the alternate forms @samp{a.m.},
13637 @samp{p.m.}, and @samp{mid} are also understood. Obviously
13638 @samp{noon} and @samp{midnight} are allowed only on 12:00:00.
13639 The words @samp{noon}, @samp{mid}, and @samp{midnight} are also
13640 recognized with no number attached.
13642 If there is no AM/PM indicator, the time is interpreted in 24-hour
13645 To read the date portion, all words and numbers are isolated
13646 from the string; other characters are ignored. All words must
13647 be either month names or day-of-week names (the latter of which
13648 are ignored). Names can be written in full or as three-letter
13651 Large numbers, or numbers with @samp{+} or @samp{-} signs,
13652 are interpreted as years. If one of the other numbers is
13653 greater than 12, then that must be the day and the remaining
13654 number in the input is therefore the month. Otherwise, Calc
13655 assumes the month, day and year are in the same order that they
13656 appear in the current date format. If the year is omitted, the
13657 current year is taken from the system clock.
13659 If there are too many or too few numbers, or any unrecognizable
13660 words, then the input is rejected.
13662 If there are any large numbers (of five digits or more) other than
13663 the year, they are ignored on the assumption that they are something
13664 like Julian dates that were included along with the traditional
13665 date components when the date was formatted.
13667 One of the words @samp{ad}, @samp{a.d.}, @samp{bc}, or @samp{b.c.}
13668 may optionally be used; the latter two are equivalent to a
13669 minus sign on the year value.
13671 If you always enter a four-digit year, and use a name instead
13672 of a number for the month, there is no danger of ambiguity.
13674 @node Standard Date Formats, , Free-Form Dates, Date Formats
13675 @subsubsection Standard Date Formats
13678 There are actually ten standard date formats, numbered 0 through 9.
13679 Entering a blank line at the @kbd{d d} command's prompt gives
13680 you format number 1, Calc's usual format. You can enter any digit
13681 to select the other formats.
13683 To create your own standard date formats, give a numeric prefix
13684 argument from 0 to 9 to the @w{@kbd{d d}} command. The format you
13685 enter will be recorded as the new standard format of that
13686 number, as well as becoming the new current date format.
13687 You can save your formats permanently with the @w{@kbd{m m}}
13688 command (@pxref{Mode Settings}).
13692 @samp{N} (Numerical format)
13694 @samp{<H:mm:SSpp >Www Mmm D, YYYY} (American format)
13696 @samp{D Mmm YYYY<, h:mm:SS>} (European format)
13698 @samp{Www Mmm BD< hh:mm:ss> YYYY} (Unix written date format)
13700 @samp{M/D/Y< H:mm:SSpp>} (American slashed format)
13702 @samp{D.M.Y< h:mm:SS>} (European dotted format)
13704 @samp{M-D-Y< H:mm:SSpp>} (American dashed format)
13706 @samp{D-M-Y< h:mm:SS>} (European dashed format)
13708 @samp{j<, h:mm:ss>} (Julian day plus time)
13710 @samp{YYddd< hh:mm:ss>} (Year-day format)
13713 @node Truncating the Stack, Justification, Date Formats, Display Modes
13714 @subsection Truncating the Stack
13718 @pindex calc-truncate-stack
13719 @cindex Truncating the stack
13720 @cindex Narrowing the stack
13721 The @kbd{d t} (@code{calc-truncate-stack}) command moves the @samp{.}@:
13722 line that marks the top-of-stack up or down in the Calculator buffer.
13723 The number right above that line is considered to the be at the top of
13724 the stack. Any numbers below that line are ``hidden'' from all stack
13725 operations (although still visible to the user). This is similar to the
13726 Emacs ``narrowing'' feature, except that the values below the @samp{.}
13727 are @emph{visible}, just temporarily frozen. This feature allows you to
13728 keep several independent calculations running at once in different parts
13729 of the stack, or to apply a certain command to an element buried deep in
13732 Pressing @kbd{d t} by itself moves the @samp{.} to the line the cursor
13733 is on. Thus, this line and all those below it become hidden. To un-hide
13734 these lines, move down to the end of the buffer and press @w{@kbd{d t}}.
13735 With a positive numeric prefix argument @expr{n}, @kbd{d t} hides the
13736 bottom @expr{n} values in the buffer. With a negative argument, it hides
13737 all but the top @expr{n} values. With an argument of zero, it hides zero
13738 values, i.e., moves the @samp{.} all the way down to the bottom.
13741 @pindex calc-truncate-up
13743 @pindex calc-truncate-down
13744 The @kbd{d [} (@code{calc-truncate-up}) and @kbd{d ]}
13745 (@code{calc-truncate-down}) commands move the @samp{.} up or down one
13746 line at a time (or several lines with a prefix argument).
13748 @node Justification, Labels, Truncating the Stack, Display Modes
13749 @subsection Justification
13753 @pindex calc-left-justify
13755 @pindex calc-center-justify
13757 @pindex calc-right-justify
13758 Values on the stack are normally left-justified in the window. You can
13759 control this arrangement by typing @kbd{d <} (@code{calc-left-justify}),
13760 @kbd{d >} (@code{calc-right-justify}), or @kbd{d =}
13761 (@code{calc-center-justify}). For example, in Right-Justification mode,
13762 stack entries are displayed flush-right against the right edge of the
13765 If you change the width of the Calculator window you may have to type
13766 @kbd{d @key{SPC}} (@code{calc-refresh}) to re-align right-justified or centered
13769 Right-justification is especially useful together with fixed-point
13770 notation (see @code{d f}; @code{calc-fix-notation}). With these modes
13771 together, the decimal points on numbers will always line up.
13773 With a numeric prefix argument, the justification commands give you
13774 a little extra control over the display. The argument specifies the
13775 horizontal ``origin'' of a display line. It is also possible to
13776 specify a maximum line width using the @kbd{d b} command (@pxref{Normal
13777 Language Modes}). For reference, the precise rules for formatting and
13778 breaking lines are given below. Notice that the interaction between
13779 origin and line width is slightly different in each justification
13782 In Left-Justified mode, the line is indented by a number of spaces
13783 given by the origin (default zero). If the result is longer than the
13784 maximum line width, if given, or too wide to fit in the Calc window
13785 otherwise, then it is broken into lines which will fit; each broken
13786 line is indented to the origin.
13788 In Right-Justified mode, lines are shifted right so that the rightmost
13789 character is just before the origin, or just before the current
13790 window width if no origin was specified. If the line is too long
13791 for this, then it is broken; the current line width is used, if
13792 specified, or else the origin is used as a width if that is
13793 specified, or else the line is broken to fit in the window.
13795 In Centering mode, the origin is the column number of the center of
13796 each stack entry. If a line width is specified, lines will not be
13797 allowed to go past that width; Calc will either indent less or
13798 break the lines if necessary. If no origin is specified, half the
13799 line width or Calc window width is used.
13801 Note that, in each case, if line numbering is enabled the display
13802 is indented an additional four spaces to make room for the line
13803 number. The width of the line number is taken into account when
13804 positioning according to the current Calc window width, but not
13805 when positioning by explicit origins and widths. In the latter
13806 case, the display is formatted as specified, and then uniformly
13807 shifted over four spaces to fit the line numbers.
13809 @node Labels, , Justification, Display Modes
13814 @pindex calc-left-label
13815 The @kbd{d @{} (@code{calc-left-label}) command prompts for a string,
13816 then displays that string to the left of every stack entry. If the
13817 entries are left-justified (@pxref{Justification}), then they will
13818 appear immediately after the label (unless you specified an origin
13819 greater than the length of the label). If the entries are centered
13820 or right-justified, the label appears on the far left and does not
13821 affect the horizontal position of the stack entry.
13823 Give a blank string (with @kbd{d @{ @key{RET}}) to turn the label off.
13826 @pindex calc-right-label
13827 The @kbd{d @}} (@code{calc-right-label}) command similarly adds a
13828 label on the righthand side. It does not affect positioning of
13829 the stack entries unless they are right-justified. Also, if both
13830 a line width and an origin are given in Right-Justified mode, the
13831 stack entry is justified to the origin and the righthand label is
13832 justified to the line width.
13834 One application of labels would be to add equation numbers to
13835 formulas you are manipulating in Calc and then copying into a
13836 document (possibly using Embedded mode). The equations would
13837 typically be centered, and the equation numbers would be on the
13838 left or right as you prefer.
13840 @node Language Modes, Modes Variable, Display Modes, Mode Settings
13841 @section Language Modes
13844 The commands in this section change Calc to use a different notation for
13845 entry and display of formulas, corresponding to the conventions of some
13846 other common language such as Pascal or La@TeX{}. Objects displayed on the
13847 stack or yanked from the Calculator to an editing buffer will be formatted
13848 in the current language; objects entered in algebraic entry or yanked from
13849 another buffer will be interpreted according to the current language.
13851 The current language has no effect on things written to or read from the
13852 trail buffer, nor does it affect numeric entry. Only algebraic entry is
13853 affected. You can make even algebraic entry ignore the current language
13854 and use the standard notation by giving a numeric prefix, e.g., @kbd{C-u '}.
13856 For example, suppose the formula @samp{2*a[1] + atan(a[2])} occurs in a C
13857 program; elsewhere in the program you need the derivatives of this formula
13858 with respect to @samp{a[1]} and @samp{a[2]}. First, type @kbd{d C}
13859 to switch to C notation. Now use @code{C-u C-x * g} to grab the formula
13860 into the Calculator, @kbd{a d a[1] @key{RET}} to differentiate with respect
13861 to the first variable, and @kbd{C-x * y} to yank the formula for the derivative
13862 back into your C program. Press @kbd{U} to undo the differentiation and
13863 repeat with @kbd{a d a[2] @key{RET}} for the other derivative.
13865 Without being switched into C mode first, Calc would have misinterpreted
13866 the brackets in @samp{a[1]} and @samp{a[2]}, would not have known that
13867 @code{atan} was equivalent to Calc's built-in @code{arctan} function,
13868 and would have written the formula back with notations (like implicit
13869 multiplication) which would not have been valid for a C program.
13871 As another example, suppose you are maintaining a C program and a La@TeX{}
13872 document, each of which needs a copy of the same formula. You can grab the
13873 formula from the program in C mode, switch to La@TeX{} mode, and yank the
13874 formula into the document in La@TeX{} math-mode format.
13876 Language modes are selected by typing the letter @kbd{d} followed by a
13877 shifted letter key.
13880 * Normal Language Modes::
13881 * C FORTRAN Pascal::
13882 * TeX and LaTeX Language Modes::
13883 * Eqn Language Mode::
13884 * Yacas Language Mode::
13885 * Maxima Language Mode::
13886 * Giac Language Mode::
13887 * Mathematica Language Mode::
13888 * Maple Language Mode::
13893 @node Normal Language Modes, C FORTRAN Pascal, Language Modes, Language Modes
13894 @subsection Normal Language Modes
13898 @pindex calc-normal-language
13899 The @kbd{d N} (@code{calc-normal-language}) command selects the usual
13900 notation for Calc formulas, as described in the rest of this manual.
13901 Matrices are displayed in a multi-line tabular format, but all other
13902 objects are written in linear form, as they would be typed from the
13906 @pindex calc-flat-language
13907 @cindex Matrix display
13908 The @kbd{d O} (@code{calc-flat-language}) command selects a language
13909 identical with the normal one, except that matrices are written in
13910 one-line form along with everything else. In some applications this
13911 form may be more suitable for yanking data into other buffers.
13914 @pindex calc-line-breaking
13915 @cindex Line breaking
13916 @cindex Breaking up long lines
13917 Even in one-line mode, long formulas or vectors will still be split
13918 across multiple lines if they exceed the width of the Calculator window.
13919 The @kbd{d b} (@code{calc-line-breaking}) command turns this line-breaking
13920 feature on and off. (It works independently of the current language.)
13921 If you give a numeric prefix argument of five or greater to the @kbd{d b}
13922 command, that argument will specify the line width used when breaking
13926 @pindex calc-big-language
13927 The @kbd{d B} (@code{calc-big-language}) command selects a language
13928 which uses textual approximations to various mathematical notations,
13929 such as powers, quotients, and square roots:
13939 in place of @samp{sqrt((a+1)/b + c^2)}.
13941 Subscripts like @samp{a_i} are displayed as actual subscripts in Big
13942 mode. Double subscripts, @samp{a_i_j} (@samp{subscr(subscr(a, i), j)})
13943 are displayed as @samp{a} with subscripts separated by commas:
13944 @samp{i, j}. They must still be entered in the usual underscore
13947 One slight ambiguity of Big notation is that
13956 can represent either the negative rational number @expr{-3:4}, or the
13957 actual expression @samp{-(3/4)}; but the latter formula would normally
13958 never be displayed because it would immediately be evaluated to
13959 @expr{-3:4} or @expr{-0.75}, so this ambiguity is not a problem in
13962 Non-decimal numbers are displayed with subscripts. Thus there is no
13963 way to tell the difference between @samp{16#C2} and @samp{C2_16},
13964 though generally you will know which interpretation is correct.
13965 Logarithms @samp{log(x,b)} and @samp{log10(x)} also use subscripts
13968 In Big mode, stack entries often take up several lines. To aid
13969 readability, stack entries are separated by a blank line in this mode.
13970 You may find it useful to expand the Calc window's height using
13971 @kbd{C-x ^} (@code{enlarge-window}) or to make the Calc window the only
13972 one on the screen with @kbd{C-x 1} (@code{delete-other-windows}).
13974 Long lines are currently not rearranged to fit the window width in
13975 Big mode, so you may need to use the @kbd{<} and @kbd{>} keys
13976 to scroll across a wide formula. For really big formulas, you may
13977 even need to use @kbd{@{} and @kbd{@}} to scroll up and down.
13980 @pindex calc-unformatted-language
13981 The @kbd{d U} (@code{calc-unformatted-language}) command altogether disables
13982 the use of operator notation in formulas. In this mode, the formula
13983 shown above would be displayed:
13986 sqrt(add(div(add(a, 1), b), pow(c, 2)))
13989 These four modes differ only in display format, not in the format
13990 expected for algebraic entry. The standard Calc operators work in
13991 all four modes, and unformatted notation works in any language mode
13992 (except that Mathematica mode expects square brackets instead of
13995 @node C FORTRAN Pascal, TeX and LaTeX Language Modes, Normal Language Modes, Language Modes
13996 @subsection C, FORTRAN, and Pascal Modes
14000 @pindex calc-c-language
14002 The @kbd{d C} (@code{calc-c-language}) command selects the conventions
14003 of the C language for display and entry of formulas. This differs from
14004 the normal language mode in a variety of (mostly minor) ways. In
14005 particular, C language operators and operator precedences are used in
14006 place of Calc's usual ones. For example, @samp{a^b} means @samp{xor(a,b)}
14007 in C mode; a value raised to a power is written as a function call,
14010 In C mode, vectors and matrices use curly braces instead of brackets.
14011 Octal and hexadecimal values are written with leading @samp{0} or @samp{0x}
14012 rather than using the @samp{#} symbol. Array subscripting is
14013 translated into @code{subscr} calls, so that @samp{a[i]} in C
14014 mode is the same as @samp{a_i} in Normal mode. Assignments
14015 turn into the @code{assign} function, which Calc normally displays
14016 using the @samp{:=} symbol.
14018 The variables @code{pi} and @code{e} would be displayed @samp{pi}
14019 and @samp{e} in Normal mode, but in C mode they are displayed as
14020 @samp{M_PI} and @samp{M_E}, corresponding to the names of constants
14021 typically provided in the @file{<math.h>} header. Functions whose
14022 names are different in C are translated automatically for entry and
14023 display purposes. For example, entering @samp{asin(x)} will push the
14024 formula @samp{arcsin(x)} onto the stack; this formula will be displayed
14025 as @samp{asin(x)} as long as C mode is in effect.
14028 @pindex calc-pascal-language
14029 @cindex Pascal language
14030 The @kbd{d P} (@code{calc-pascal-language}) command selects Pascal
14031 conventions. Like C mode, Pascal mode interprets array brackets and uses
14032 a different table of operators. Hexadecimal numbers are entered and
14033 displayed with a preceding dollar sign. (Thus the regular meaning of
14034 @kbd{$2} during algebraic entry does not work in Pascal mode, though
14035 @kbd{$} (and @kbd{$$}, etc.) not followed by digits works the same as
14036 always.) No special provisions are made for other non-decimal numbers,
14037 vectors, and so on, since there is no universally accepted standard way
14038 of handling these in Pascal.
14041 @pindex calc-fortran-language
14042 @cindex FORTRAN language
14043 The @kbd{d F} (@code{calc-fortran-language}) command selects FORTRAN
14044 conventions. Various function names are transformed into FORTRAN
14045 equivalents. Vectors are written as @samp{/1, 2, 3/}, and may be
14046 entered this way or using square brackets. Since FORTRAN uses round
14047 parentheses for both function calls and array subscripts, Calc displays
14048 both in the same way; @samp{a(i)} is interpreted as a function call
14049 upon reading, and subscripts must be entered as @samp{subscr(a, i)}.
14050 If the variable @code{a} has been declared to have type
14051 @code{vector} or @code{matrix}, however, then @samp{a(i)} will be
14052 parsed as a subscript. (@xref{Declarations}.) Usually it doesn't
14053 matter, though; if you enter the subscript expression @samp{a(i)} and
14054 Calc interprets it as a function call, you'll never know the difference
14055 unless you switch to another language mode or replace @code{a} with an
14056 actual vector (or unless @code{a} happens to be the name of a built-in
14059 Underscores are allowed in variable and function names in all of these
14060 language modes. The underscore here is equivalent to the @samp{#} in
14061 Normal mode, or to hyphens in the underlying Emacs Lisp variable names.
14063 FORTRAN and Pascal modes normally do not adjust the case of letters in
14064 formulas. Most built-in Calc names use lower-case letters. If you use a
14065 positive numeric prefix argument with @kbd{d P} or @kbd{d F}, these
14066 modes will use upper-case letters exclusively for display, and will
14067 convert to lower-case on input. With a negative prefix, these modes
14068 convert to lower-case for display and input.
14070 @node TeX and LaTeX Language Modes, Eqn Language Mode, C FORTRAN Pascal, Language Modes
14071 @subsection @TeX{} and La@TeX{} Language Modes
14075 @pindex calc-tex-language
14076 @cindex TeX language
14078 @pindex calc-latex-language
14079 @cindex LaTeX language
14080 The @kbd{d T} (@code{calc-tex-language}) command selects the conventions
14081 of ``math mode'' in Donald Knuth's @TeX{} typesetting language,
14082 and the @kbd{d L} (@code{calc-latex-language}) command selects the
14083 conventions of ``math mode'' in La@TeX{}, a typesetting language that
14084 uses @TeX{} as its formatting engine. Calc's La@TeX{} language mode can
14085 read any formula that the @TeX{} language mode can, although La@TeX{}
14086 mode may display it differently.
14088 Formulas are entered and displayed in the appropriate notation;
14089 @texline @math{\sin(a/b)}
14090 @infoline @expr{sin(a/b)}
14091 will appear as @samp{\sin\left( @{a \over b@} \right)} in @TeX{} mode and
14092 @samp{\sin\left(\frac@{a@}@{b@}\right)} in La@TeX{} mode.
14093 Math formulas are often enclosed by @samp{$ $} signs in @TeX{} and
14094 La@TeX{}; these should be omitted when interfacing with Calc. To Calc,
14095 the @samp{$} sign has the same meaning it always does in algebraic
14096 formulas (a reference to an existing entry on the stack).
14098 Complex numbers are displayed as in @samp{3 + 4i}. Fractions and
14099 quotients are written using @code{\over} in @TeX{} mode (as in
14100 @code{@{a \over b@}}) and @code{\frac} in La@TeX{} mode (as in
14101 @code{\frac@{a@}@{b@}}); binomial coefficients are written with
14102 @code{\choose} in @TeX{} mode (as in @code{@{a \choose b@}}) and
14103 @code{\binom} in La@TeX{} mode (as in @code{\binom@{a@}@{b@}}).
14104 Interval forms are written with @code{\ldots}, and error forms are
14105 written with @code{\pm}. Absolute values are written as in
14106 @samp{|x + 1|}, and the floor and ceiling functions are written with
14107 @code{\lfloor}, @code{\rfloor}, etc. The words @code{\left} and
14108 @code{\right} are ignored when reading formulas in @TeX{} and La@TeX{}
14109 modes. Both @code{inf} and @code{uinf} are written as @code{\infty};
14110 when read, @code{\infty} always translates to @code{inf}.
14112 Function calls are written the usual way, with the function name followed
14113 by the arguments in parentheses. However, functions for which @TeX{}
14114 and La@TeX{} have special names (like @code{\sin}) will use curly braces
14115 instead of parentheses for very simple arguments. During input, curly
14116 braces and parentheses work equally well for grouping, but when the
14117 document is formatted the curly braces will be invisible. Thus the
14119 @texline @math{\sin{2 x}}
14120 @infoline @expr{sin 2x}
14122 @texline @math{\sin(2 + x)}.
14123 @infoline @expr{sin(2 + x)}.
14125 The @TeX{} specific unit names (@pxref{Predefined Units}) will not use
14126 the @samp{tex} prefix; the unit name for a @TeX{} point will be
14127 @samp{pt} instead of @samp{texpt}, for example.
14129 Function and variable names not treated specially by @TeX{} and La@TeX{}
14130 are simply written out as-is, which will cause them to come out in
14131 italic letters in the printed document. If you invoke @kbd{d T} or
14132 @kbd{d L} with a positive numeric prefix argument, names of more than
14133 one character will instead be enclosed in a protective commands that
14134 will prevent them from being typeset in the math italics; they will be
14135 written @samp{\hbox@{@var{name}@}} in @TeX{} mode and
14136 @samp{\text@{@var{name}@}} in La@TeX{} mode. The
14137 @samp{\hbox@{ @}} and @samp{\text@{ @}} notations are ignored during
14138 reading. If you use a negative prefix argument, such function names are
14139 written @samp{\@var{name}}, and function names that begin with @code{\} during
14140 reading have the @code{\} removed. (Note that in this mode, long
14141 variable names are still written with @code{\hbox} or @code{\text}.
14142 However, you can always make an actual variable name like @code{\bar} in
14145 During reading, text of the form @samp{\matrix@{ ...@: @}} is replaced
14146 by @samp{[ ...@: ]}. The same also applies to @code{\pmatrix} and
14147 @code{\bmatrix}. In La@TeX{} mode this also applies to
14148 @samp{\begin@{matrix@} ... \end@{matrix@}},
14149 @samp{\begin@{bmatrix@} ... \end@{bmatrix@}},
14150 @samp{\begin@{pmatrix@} ... \end@{pmatrix@}}, as well as
14151 @samp{\begin@{smallmatrix@} ... \end@{smallmatrix@}}.
14152 The symbol @samp{&} is interpreted as a comma,
14153 and the symbols @samp{\cr} and @samp{\\} are interpreted as semicolons.
14154 During output, matrices are displayed in @samp{\matrix@{ a & b \\ c & d@}}
14155 format in @TeX{} mode and in
14156 @samp{\begin@{pmatrix@} a & b \\ c & d \end@{pmatrix@}} format in
14157 La@TeX{} mode; you may need to edit this afterwards to change to your
14158 preferred matrix form. If you invoke @kbd{d T} or @kbd{d L} with an
14159 argument of 2 or -2, then matrices will be displayed in two-dimensional
14170 This may be convenient for isolated matrices, but could lead to
14171 expressions being displayed like
14174 \begin@{pmatrix@} \times x
14181 While this wouldn't bother Calc, it is incorrect La@TeX{}.
14182 (Similarly for @TeX{}.)
14184 Accents like @code{\tilde} and @code{\bar} translate into function
14185 calls internally (@samp{tilde(x)}, @samp{bar(x)}). The @code{\underline}
14186 sequence is treated as an accent. The @code{\vec} accent corresponds
14187 to the function name @code{Vec}, because @code{vec} is the name of
14188 a built-in Calc function. The following table shows the accents
14189 in Calc, @TeX{}, La@TeX{} and @dfn{eqn} (described in the next section):
14194 @let@calcindexershow=@calcindexernoshow @c Suppress marginal notes
14195 @let@calcindexersh=@calcindexernoshow
14304 acute \acute \acute
14308 breve \breve \breve
14310 check \check \check
14316 dotdot \ddot \ddot dotdot
14319 grave \grave \grave
14324 tilde \tilde \tilde tilde
14326 under \underline \underline under
14331 The @samp{=>} (evaluates-to) operator appears as a @code{\to} symbol:
14332 @samp{@{@var{a} \to @var{b}@}}. @TeX{} defines @code{\to} as an
14333 alias for @code{\rightarrow}. However, if the @samp{=>} is the
14334 top-level expression being formatted, a slightly different notation
14335 is used: @samp{\evalto @var{a} \to @var{b}}. The @code{\evalto}
14336 word is ignored by Calc's input routines, and is undefined in @TeX{}.
14337 You will typically want to include one of the following definitions
14338 at the top of a @TeX{} file that uses @code{\evalto}:
14342 \def\evalto#1\to@{@}
14345 The first definition formats evaluates-to operators in the usual
14346 way. The second causes only the @var{b} part to appear in the
14347 printed document; the @var{a} part and the arrow are hidden.
14348 Another definition you may wish to use is @samp{\let\to=\Rightarrow}
14349 which causes @code{\to} to appear more like Calc's @samp{=>} symbol.
14350 @xref{Evaluates-To Operator}, for a discussion of @code{evalto}.
14352 The complete set of @TeX{} control sequences that are ignored during
14356 \hbox \mbox \text \left \right
14357 \, \> \: \; \! \quad \qquad \hfil \hfill
14358 \displaystyle \textstyle \dsize \tsize
14359 \scriptstyle \scriptscriptstyle \ssize \ssize
14360 \rm \bf \it \sl \roman \bold \italic \slanted
14361 \cal \mit \Cal \Bbb \frak \goth
14365 Note that, because these symbols are ignored, reading a @TeX{} or
14366 La@TeX{} formula into Calc and writing it back out may lose spacing and
14369 Also, the ``discretionary multiplication sign'' @samp{\*} is read
14370 the same as @samp{*}.
14373 The @TeX{} version of this manual includes some printed examples at the
14374 end of this section.
14377 Here are some examples of how various Calc formulas are formatted in @TeX{}:
14382 \sin\left( {a^2 \over b_i} \right)
14386 $$ \sin\left( a^2 \over b_i \right) $$
14392 [(3, 4), 3:4, 3 +/- 4, [3 .. inf)]
14393 [3 + 4i, @{3 \over 4@}, 3 \pm 4, [3 \ldots \infty)]
14397 $$ [3 + 4i, {3 \over 4}, 3 \pm 4, [ 3 \ldots \infty)] $$
14403 [abs(a), abs(a / b), floor(a), ceil(a / b)]
14404 [|a|, \left| a \over b \right|,
14405 \lfloor a \rfloor, \left\lceil a \over b \right\rceil]
14409 $$ [|a|, \left| a \over b \right|,
14410 \lfloor a \rfloor, \left\lceil a \over b \right\rceil] $$
14416 [sin(a), sin(2 a), sin(2 + a), sin(a / b)]
14417 [\sin@{a@}, \sin@{2 a@}, \sin(2 + a),
14418 \sin\left( @{a \over b@} \right)]
14422 $$ [\sin{a}, \sin{2 a}, \sin(2 + a), \sin\left( {a \over b} \right)] $$
14426 First with plain @kbd{d T}, then with @kbd{C-u d T}, then finally with
14427 @kbd{C-u - d T} (using the example definition
14428 @samp{\def\foo#1@{\tilde F(#1)@}}:
14432 [f(a), foo(bar), sin(pi)]
14433 [f(a), foo(bar), \sin{\pi}]
14434 [f(a), \hbox@{foo@}(\hbox@{bar@}), \sin@{\pi@}]
14435 [f(a), \foo@{\hbox@{bar@}@}, \sin@{\pi@}]
14439 $$ [f(a), foo(bar), \sin{\pi}] $$
14440 $$ [f(a), \hbox{foo}(\hbox{bar}), \sin{\pi}] $$
14441 $$ [f(a), \tilde F(\hbox{bar}), \sin{\pi}] $$
14445 First with @samp{\def\evalto@{@}}, then with @samp{\def\evalto#1\to@{@}}:
14450 \evalto 2 + 3 \to 5
14459 First with standard @code{\to}, then with @samp{\let\to\Rightarrow}:
14463 [2 + 3 => 5, a / 2 => (b + c) / 2]
14464 [@{2 + 3 \to 5@}, @{@{a \over 2@} \to @{b + c \over 2@}@}]
14468 $$ [{2 + 3 \to 5}, {{a \over 2} \to {b + c \over 2}}] $$
14469 {\let\to\Rightarrow
14470 $$ [{2 + 3 \to 5}, {{a \over 2} \to {b + c \over 2}}] $$}
14474 Matrices normally, then changing @code{\matrix} to @code{\pmatrix}:
14478 [ [ a / b, 0 ], [ 0, 2^(x + 1) ] ]
14479 \matrix@{ @{a \over b@} & 0 \\ 0 & 2^@{(x + 1)@} @}
14480 \pmatrix@{ @{a \over b@} & 0 \\ 0 & 2^@{(x + 1)@} @}
14484 $$ \matrix{ {a \over b} & 0 \cr 0 & 2^{(x + 1)} } $$
14485 $$ \pmatrix{ {a \over b} & 0 \cr 0 & 2^{(x + 1)} } $$
14490 @node Eqn Language Mode, Yacas Language Mode, TeX and LaTeX Language Modes, Language Modes
14491 @subsection Eqn Language Mode
14495 @pindex calc-eqn-language
14496 @dfn{Eqn} is another popular formatter for math formulas. It is
14497 designed for use with the TROFF text formatter, and comes standard
14498 with many versions of Unix. The @kbd{d E} (@code{calc-eqn-language})
14499 command selects @dfn{eqn} notation.
14501 The @dfn{eqn} language's main idiosyncrasy is that whitespace plays
14502 a significant part in the parsing of the language. For example,
14503 @samp{sqrt x+1 + y} treats @samp{x+1} as the argument of the
14504 @code{sqrt} operator. @dfn{Eqn} also understands more conventional
14505 grouping using curly braces: @samp{sqrt@{x+1@} + y}. Braces are
14506 required only when the argument contains spaces.
14508 In Calc's @dfn{eqn} mode, however, curly braces are required to
14509 delimit arguments of operators like @code{sqrt}. The first of the
14510 above examples would treat only the @samp{x} as the argument of
14511 @code{sqrt}, and in fact @samp{sin x+1} would be interpreted as
14512 @samp{sin * x + 1}, because @code{sin} is not a special operator
14513 in the @dfn{eqn} language. If you always surround the argument
14514 with curly braces, Calc will never misunderstand.
14516 Calc also understands parentheses as grouping characters. Another
14517 peculiarity of @dfn{eqn}'s syntax makes it advisable to separate
14518 words with spaces from any surrounding characters that aren't curly
14519 braces, so Calc writes @samp{sin ( x + y )} in @dfn{eqn} mode.
14520 (The spaces around @code{sin} are important to make @dfn{eqn}
14521 recognize that @code{sin} should be typeset in a roman font, and
14522 the spaces around @code{x} and @code{y} are a good idea just in
14523 case the @dfn{eqn} document has defined special meanings for these
14526 Powers and subscripts are written with the @code{sub} and @code{sup}
14527 operators, respectively. Note that the caret symbol @samp{^} is
14528 treated the same as a space in @dfn{eqn} mode, as is the @samp{~}
14529 symbol (these are used to introduce spaces of various widths into
14530 the typeset output of @dfn{eqn}).
14532 As in La@TeX{} mode, Calc's formatter omits parentheses around the
14533 arguments of functions like @code{ln} and @code{sin} if they are
14534 ``simple-looking''; in this case Calc surrounds the argument with
14535 braces, separated by a @samp{~} from the function name: @samp{sin~@{x@}}.
14537 Font change codes (like @samp{roman @var{x}}) and positioning codes
14538 (like @samp{~} and @samp{down @var{n} @var{x}}) are ignored by the
14539 @dfn{eqn} reader. Also ignored are the words @code{left}, @code{right},
14540 @code{mark}, and @code{lineup}. Quotation marks in @dfn{eqn} mode input
14541 are treated the same as curly braces: @samp{sqrt "1+x"} is equivalent to
14542 @samp{sqrt @{1+x@}}; this is only an approximation to the true meaning
14543 of quotes in @dfn{eqn}, but it is good enough for most uses.
14545 Accent codes (@samp{@var{x} dot}) are handled by treating them as
14546 function calls (@samp{dot(@var{x})}) internally.
14547 @xref{TeX and LaTeX Language Modes}, for a table of these accent
14548 functions. The @code{prime} accent is treated specially if it occurs on
14549 a variable or function name: @samp{f prime prime @w{( x prime )}} is
14550 stored internally as @samp{f'@w{'}(x')}. For example, taking the
14551 derivative of @samp{f(2 x)} with @kbd{a d x} will produce @samp{2 f'(2
14552 x)}, which @dfn{eqn} mode will display as @samp{2 f prime ( 2 x )}.
14554 Assignments are written with the @samp{<-} (left-arrow) symbol,
14555 and @code{evalto} operators are written with @samp{->} or
14556 @samp{evalto ... ->} (@pxref{TeX and LaTeX Language Modes}, for a discussion
14557 of this). The regular Calc symbols @samp{:=} and @samp{=>} are also
14558 recognized for these operators during reading.
14560 Vectors in @dfn{eqn} mode use regular Calc square brackets, but
14561 matrices are formatted as @samp{matrix @{ ccol @{ a above b @} ... @}}.
14562 The words @code{lcol} and @code{rcol} are recognized as synonyms
14563 for @code{ccol} during input, and are generated instead of @code{ccol}
14564 if the matrix justification mode so specifies.
14566 @node Yacas Language Mode, Maxima Language Mode, Eqn Language Mode, Language Modes
14567 @subsection Yacas Language Mode
14571 @pindex calc-yacas-language
14572 @cindex Yacas language
14573 The @kbd{d Y} (@code{calc-yacas-language}) command selects the
14574 conventions of Yacas, a free computer algebra system. While the
14575 operators and functions in Yacas are similar to those of Calc, the names
14576 of built-in functions in Yacas are capitalized. The Calc formula
14577 @samp{sin(2 x)}, for example, is entered and displayed @samp{Sin(2 x)}
14578 in Yacas mode, and `@samp{arcsin(x^2)} is @samp{ArcSin(x^2)} in Yacas
14579 mode. Complex numbers are written are written @samp{3 + 4 I}.
14580 The standard special constants are written @code{Pi}, @code{E},
14581 @code{I}, @code{GoldenRatio} and @code{Gamma}. @code{Infinity}
14582 represents both @code{inf} and @code{uinf}, and @code{Undefined}
14583 represents @code{nan}.
14585 Certain operators on functions, such as @code{D} for differentiation
14586 and @code{Integrate} for integration, take a prefix form in Yacas. For
14587 example, the derivative of @w{@samp{e^x sin(x)}} can be computed with
14588 @w{@samp{D(x) Exp(x)*Sin(x)}}.
14590 Other notable differences between Yacas and standard Calc expressions
14591 are that vectors and matrices use curly braces in Yacas, and subscripts
14592 use square brackets. If, for example, @samp{A} represents the list
14593 @samp{@{a,2,c,4@}}, then @samp{A[3]} would equal @samp{c}.
14596 @node Maxima Language Mode, Giac Language Mode, Yacas Language Mode, Language Modes
14597 @subsection Maxima Language Mode
14601 @pindex calc-maxima-language
14602 @cindex Maxima language
14603 The @kbd{d X} (@code{calc-maxima-language}) command selects the
14604 conventions of Maxima, another free computer algebra system. The
14605 function names in Maxima are similar, but not always identical, to Calc.
14606 For example, instead of @samp{arcsin(x)}, Maxima will use
14607 @samp{asin(x)}. Complex numbers are written @samp{3 + 4 %i}. The
14608 standard special constants are written @code{%pi}, @code{%e},
14609 @code{%i}, @code{%phi} and @code{%gamma}. In Maxima, @code{inf} means
14610 the same as in Calc, but @code{infinity} represents Calc's @code{uinf}.
14612 Underscores as well as percent signs are allowed in function and
14613 variable names in Maxima mode. The underscore again is equivalent to
14614 the @samp{#} in Normal mode, and the percent sign is equivalent to
14617 Maxima uses square brackets for lists and vectors, and matrices are
14618 written as calls to the function @code{matrix}, given the row vectors of
14619 the matrix as arguments. Square brackets are also used as subscripts.
14621 @node Giac Language Mode, Mathematica Language Mode, Maxima Language Mode, Language Modes
14622 @subsection Giac Language Mode
14626 @pindex calc-giac-language
14627 @cindex Giac language
14628 The @kbd{d A} (@code{calc-giac-language}) command selects the
14629 conventions of Giac, another free computer algebra system. The function
14630 names in Giac are similar to Maxima. Complex numbers are written
14631 @samp{3 + 4 i}. The standard special constants in Giac are the same as
14632 in Calc, except that @code{infinity} represents both Calc's @code{inf}
14635 Underscores are allowed in function and variable names in Giac mode.
14636 Brackets are used for subscripts. In Giac, indexing of lists begins at
14637 0, instead of 1 as in Calc. So if @samp{A} represents the list
14638 @samp{[a,2,c,4]}, then @samp{A[2]} would equal @samp{c}. In general,
14639 @samp{A[n]} in Giac mode corresponds to @samp{A_(n+1)} in Normal mode.
14641 The Giac interval notation @samp{2 .. 3} has no surrounding brackets;
14642 Calc reads @samp{2 .. 3} as the closed interval @samp{[2 .. 3]} and
14643 writes any kind of interval as @samp{2 .. 3}. This means you cannot see
14644 the difference between an open and a closed interval while in Giac mode.
14646 @node Mathematica Language Mode, Maple Language Mode, Giac Language Mode, Language Modes
14647 @subsection Mathematica Language Mode
14651 @pindex calc-mathematica-language
14652 @cindex Mathematica language
14653 The @kbd{d M} (@code{calc-mathematica-language}) command selects the
14654 conventions of Mathematica. Notable differences in Mathematica mode
14655 are that the names of built-in functions are capitalized, and function
14656 calls use square brackets instead of parentheses. Thus the Calc
14657 formula @samp{sin(2 x)} is entered and displayed @w{@samp{Sin[2 x]}} in
14660 Vectors and matrices use curly braces in Mathematica. Complex numbers
14661 are written @samp{3 + 4 I}. The standard special constants in Calc are
14662 written @code{Pi}, @code{E}, @code{I}, @code{GoldenRatio}, @code{EulerGamma},
14663 @code{Infinity}, @code{ComplexInfinity}, and @code{Indeterminate} in
14665 Non-decimal numbers are written, e.g., @samp{16^^7fff}. Floating-point
14666 numbers in scientific notation are written @samp{1.23*10.^3}.
14667 Subscripts use double square brackets: @samp{a[[i]]}.
14669 @node Maple Language Mode, Compositions, Mathematica Language Mode, Language Modes
14670 @subsection Maple Language Mode
14674 @pindex calc-maple-language
14675 @cindex Maple language
14676 The @kbd{d W} (@code{calc-maple-language}) command selects the
14677 conventions of Maple.
14679 Maple's language is much like C. Underscores are allowed in symbol
14680 names; square brackets are used for subscripts; explicit @samp{*}s for
14681 multiplications are required. Use either @samp{^} or @samp{**} to
14684 Maple uses square brackets for lists and curly braces for sets. Calc
14685 interprets both notations as vectors, and displays vectors with square
14686 brackets. This means Maple sets will be converted to lists when they
14687 pass through Calc. As a special case, matrices are written as calls
14688 to the function @code{matrix}, given a list of lists as the argument,
14689 and can be read in this form or with all-capitals @code{MATRIX}.
14691 The Maple interval notation @samp{2 .. 3} is like Giac's interval
14692 notation, and is handled the same by Calc.
14694 Maple writes complex numbers as @samp{3 + 4*I}. Its special constants
14695 are @code{Pi}, @code{E}, @code{I}, and @code{infinity} (all three of
14696 @code{inf}, @code{uinf}, and @code{nan} display as @code{infinity}).
14697 Floating-point numbers are written @samp{1.23*10.^3}.
14699 Among things not currently handled by Calc's Maple mode are the
14700 various quote symbols, procedures and functional operators, and
14701 inert (@samp{&}) operators.
14703 @node Compositions, Syntax Tables, Maple Language Mode, Language Modes
14704 @subsection Compositions
14707 @cindex Compositions
14708 There are several @dfn{composition functions} which allow you to get
14709 displays in a variety of formats similar to those in Big language
14710 mode. Most of these functions do not evaluate to anything; they are
14711 placeholders which are left in symbolic form by Calc's evaluator but
14712 are recognized by Calc's display formatting routines.
14714 Two of these, @code{string} and @code{bstring}, are described elsewhere.
14715 @xref{Strings}. For example, @samp{string("ABC")} is displayed as
14716 @samp{ABC}. When viewed on the stack it will be indistinguishable from
14717 the variable @code{ABC}, but internally it will be stored as
14718 @samp{string([65, 66, 67])} and can still be manipulated this way; for
14719 example, the selection and vector commands @kbd{j 1 v v j u} would
14720 select the vector portion of this object and reverse the elements, then
14721 deselect to reveal a string whose characters had been reversed.
14723 The composition functions do the same thing in all language modes
14724 (although their components will of course be formatted in the current
14725 language mode). The one exception is Unformatted mode (@kbd{d U}),
14726 which does not give the composition functions any special treatment.
14727 The functions are discussed here because of their relationship to
14728 the language modes.
14731 * Composition Basics::
14732 * Horizontal Compositions::
14733 * Vertical Compositions::
14734 * Other Compositions::
14735 * Information about Compositions::
14736 * User-Defined Compositions::
14739 @node Composition Basics, Horizontal Compositions, Compositions, Compositions
14740 @subsubsection Composition Basics
14743 Compositions are generally formed by stacking formulas together
14744 horizontally or vertically in various ways. Those formulas are
14745 themselves compositions. @TeX{} users will find this analogous
14746 to @TeX{}'s ``boxes.'' Each multi-line composition has a
14747 @dfn{baseline}; horizontal compositions use the baselines to
14748 decide how formulas should be positioned relative to one another.
14749 For example, in the Big mode formula
14761 the second term of the sum is four lines tall and has line three as
14762 its baseline. Thus when the term is combined with 17, line three
14763 is placed on the same level as the baseline of 17.
14769 Another important composition concept is @dfn{precedence}. This is
14770 an integer that represents the binding strength of various operators.
14771 For example, @samp{*} has higher precedence (195) than @samp{+} (180),
14772 which means that @samp{(a * b) + c} will be formatted without the
14773 parentheses, but @samp{a * (b + c)} will keep the parentheses.
14775 The operator table used by normal and Big language modes has the
14776 following precedences:
14779 _ 1200 @r{(subscripts)}
14780 % 1100 @r{(as in n}%@r{)}
14781 ! 1000 @r{(as in }!@r{n)}
14784 !! 210 @r{(as in n}!!@r{)}
14785 ! 210 @r{(as in n}!@r{)}
14787 - 197 @r{(as in }-@r{n)}
14788 * 195 @r{(or implicit multiplication)}
14790 + - 180 @r{(as in a}+@r{b)}
14792 < = 160 @r{(and other relations)}
14804 The general rule is that if an operator with precedence @expr{n}
14805 occurs as an argument to an operator with precedence @expr{m}, then
14806 the argument is enclosed in parentheses if @expr{n < m}. Top-level
14807 expressions and expressions which are function arguments, vector
14808 components, etc., are formatted with precedence zero (so that they
14809 normally never get additional parentheses).
14811 For binary left-associative operators like @samp{+}, the righthand
14812 argument is actually formatted with one-higher precedence than shown
14813 in the table. This makes sure @samp{(a + b) + c} omits the parentheses,
14814 but the unnatural form @samp{a + (b + c)} keeps its parentheses.
14815 Right-associative operators like @samp{^} format the lefthand argument
14816 with one-higher precedence.
14822 The @code{cprec} function formats an expression with an arbitrary
14823 precedence. For example, @samp{cprec(abc, 185)} will combine into
14824 sums and products as follows: @samp{7 + abc}, @samp{7 (abc)} (because
14825 this @code{cprec} form has higher precedence than addition, but lower
14826 precedence than multiplication).
14832 A final composition issue is @dfn{line breaking}. Calc uses two
14833 different strategies for ``flat'' and ``non-flat'' compositions.
14834 A non-flat composition is anything that appears on multiple lines
14835 (not counting line breaking). Examples would be matrices and Big
14836 mode powers and quotients. Non-flat compositions are displayed
14837 exactly as specified. If they come out wider than the current
14838 window, you must use horizontal scrolling (@kbd{<} and @kbd{>}) to
14841 Flat compositions, on the other hand, will be broken across several
14842 lines if they are too wide to fit the window. Certain points in a
14843 composition are noted internally as @dfn{break points}. Calc's
14844 general strategy is to fill each line as much as possible, then to
14845 move down to the next line starting at the first break point that
14846 didn't fit. However, the line breaker understands the hierarchical
14847 structure of formulas. It will not break an ``inner'' formula if
14848 it can use an earlier break point from an ``outer'' formula instead.
14849 For example, a vector of sums might be formatted as:
14853 [ a + b + c, d + e + f,
14854 g + h + i, j + k + l, m ]
14859 If the @samp{m} can fit, then so, it seems, could the @samp{g}.
14860 But Calc prefers to break at the comma since the comma is part
14861 of a ``more outer'' formula. Calc would break at a plus sign
14862 only if it had to, say, if the very first sum in the vector had
14863 itself been too large to fit.
14865 Of the composition functions described below, only @code{choriz}
14866 generates break points. The @code{bstring} function (@pxref{Strings})
14867 also generates breakable items: A break point is added after every
14868 space (or group of spaces) except for spaces at the very beginning or
14871 Composition functions themselves count as levels in the formula
14872 hierarchy, so a @code{choriz} that is a component of a larger
14873 @code{choriz} will be less likely to be broken. As a special case,
14874 if a @code{bstring} occurs as a component of a @code{choriz} or
14875 @code{choriz}-like object (such as a vector or a list of arguments
14876 in a function call), then the break points in that @code{bstring}
14877 will be on the same level as the break points of the surrounding
14880 @node Horizontal Compositions, Vertical Compositions, Composition Basics, Compositions
14881 @subsubsection Horizontal Compositions
14888 The @code{choriz} function takes a vector of objects and composes
14889 them horizontally. For example, @samp{choriz([17, a b/c, d])} formats
14890 as @w{@samp{17a b / cd}} in Normal language mode, or as
14901 in Big language mode. This is actually one case of the general
14902 function @samp{choriz(@var{vec}, @var{sep}, @var{prec})}, where
14903 either or both of @var{sep} and @var{prec} may be omitted.
14904 @var{Prec} gives the @dfn{precedence} to use when formatting
14905 each of the components of @var{vec}. The default precedence is
14906 the precedence from the surrounding environment.
14908 @var{Sep} is a string (i.e., a vector of character codes as might
14909 be entered with @code{" "} notation) which should separate components
14910 of the composition. Also, if @var{sep} is given, the line breaker
14911 will allow lines to be broken after each occurrence of @var{sep}.
14912 If @var{sep} is omitted, the composition will not be breakable
14913 (unless any of its component compositions are breakable).
14915 For example, @samp{2 choriz([a, b c, d = e], " + ", 180)} is
14916 formatted as @samp{2 a + b c + (d = e)}. To get the @code{choriz}
14917 to have precedence 180 ``outwards'' as well as ``inwards,''
14918 enclose it in a @code{cprec} form: @samp{2 cprec(choriz(...), 180)}
14919 formats as @samp{2 (a + b c + (d = e))}.
14921 The baseline of a horizontal composition is the same as the
14922 baselines of the component compositions, which are all aligned.
14924 @node Vertical Compositions, Other Compositions, Horizontal Compositions, Compositions
14925 @subsubsection Vertical Compositions
14932 The @code{cvert} function makes a vertical composition. Each
14933 component of the vector is centered in a column. The baseline of
14934 the result is by default the top line of the resulting composition.
14935 For example, @samp{f(cvert([a, bb, ccc]), cvert([a^2 + 1, b^2]))}
14936 formats in Big mode as
14951 There are several special composition functions that work only as
14952 components of a vertical composition. The @code{cbase} function
14953 controls the baseline of the vertical composition; the baseline
14954 will be the same as the baseline of whatever component is enclosed
14955 in @code{cbase}. Thus @samp{f(cvert([a, cbase(bb), ccc]),
14956 cvert([a^2 + 1, cbase(b^2)]))} displays as
14976 There are also @code{ctbase} and @code{cbbase} functions which
14977 make the baseline of the vertical composition equal to the top
14978 or bottom line (rather than the baseline) of that component.
14979 Thus @samp{cvert([cbase(a / b)]) + cvert([ctbase(a / b)]) +
14980 cvert([cbbase(a / b)])} gives
14992 There should be only one @code{cbase}, @code{ctbase}, or @code{cbbase}
14993 function in a given vertical composition. These functions can also
14994 be written with no arguments: @samp{ctbase()} is a zero-height object
14995 which means the baseline is the top line of the following item, and
14996 @samp{cbbase()} means the baseline is the bottom line of the preceding
15003 The @code{crule} function builds a ``rule,'' or horizontal line,
15004 across a vertical composition. By itself @samp{crule()} uses @samp{-}
15005 characters to build the rule. You can specify any other character,
15006 e.g., @samp{crule("=")}. The argument must be a character code or
15007 vector of exactly one character code. It is repeated to match the
15008 width of the widest item in the stack. For example, a quotient
15009 with a thick line is @samp{cvert([a + 1, cbase(crule("=")), b^2])}:
15028 Finally, the functions @code{clvert} and @code{crvert} act exactly
15029 like @code{cvert} except that the items are left- or right-justified
15030 in the stack. Thus @samp{clvert([a, bb, ccc]) + crvert([a, bb, ccc])}
15041 Like @code{choriz}, the vertical compositions accept a second argument
15042 which gives the precedence to use when formatting the components.
15043 Vertical compositions do not support separator strings.
15045 @node Other Compositions, Information about Compositions, Vertical Compositions, Compositions
15046 @subsubsection Other Compositions
15053 The @code{csup} function builds a superscripted expression. For
15054 example, @samp{csup(a, b)} looks the same as @samp{a^b} does in Big
15055 language mode. This is essentially a horizontal composition of
15056 @samp{a} and @samp{b}, where @samp{b} is shifted up so that its
15057 bottom line is one above the baseline.
15063 Likewise, the @code{csub} function builds a subscripted expression.
15064 This shifts @samp{b} down so that its top line is one below the
15065 bottom line of @samp{a} (note that this is not quite analogous to
15066 @code{csup}). Other arrangements can be obtained by using
15067 @code{choriz} and @code{cvert} directly.
15073 The @code{cflat} function formats its argument in ``flat'' mode,
15074 as obtained by @samp{d O}, if the current language mode is normal
15075 or Big. It has no effect in other language modes. For example,
15076 @samp{a^(b/c)} is formatted by Big mode like @samp{csup(a, cflat(b/c))}
15077 to improve its readability.
15083 The @code{cspace} function creates horizontal space. For example,
15084 @samp{cspace(4)} is effectively the same as @samp{string(" ")}.
15085 A second string (i.e., vector of characters) argument is repeated
15086 instead of the space character. For example, @samp{cspace(4, "ab")}
15087 looks like @samp{abababab}. If the second argument is not a string,
15088 it is formatted in the normal way and then several copies of that
15089 are composed together: @samp{cspace(4, a^2)} yields
15099 If the number argument is zero, this is a zero-width object.
15105 The @code{cvspace} function creates vertical space, or a vertical
15106 stack of copies of a certain string or formatted object. The
15107 baseline is the center line of the resulting stack. A numerical
15108 argument of zero will produce an object which contributes zero
15109 height if used in a vertical composition.
15119 There are also @code{ctspace} and @code{cbspace} functions which
15120 create vertical space with the baseline the same as the baseline
15121 of the top or bottom copy, respectively, of the second argument.
15122 Thus @samp{cvspace(2, a/b) + ctspace(2, a/b) + cbspace(2, a/b)}
15139 @node Information about Compositions, User-Defined Compositions, Other Compositions, Compositions
15140 @subsubsection Information about Compositions
15143 The functions in this section are actual functions; they compose their
15144 arguments according to the current language and other display modes,
15145 then return a certain measurement of the composition as an integer.
15151 The @code{cwidth} function measures the width, in characters, of a
15152 composition. For example, @samp{cwidth(a + b)} is 5, and
15153 @samp{cwidth(a / b)} is 5 in Normal mode, 1 in Big mode, and 11 in
15154 @TeX{} mode (for @samp{@{a \over b@}}). The argument may involve
15155 the composition functions described in this section.
15161 The @code{cheight} function measures the height of a composition.
15162 This is the total number of lines in the argument's printed form.
15172 The functions @code{cascent} and @code{cdescent} measure the amount
15173 of the height that is above (and including) the baseline, or below
15174 the baseline, respectively. Thus @samp{cascent(@var{x}) + cdescent(@var{x})}
15175 always equals @samp{cheight(@var{x})}. For a one-line formula like
15176 @samp{a + b}, @code{cascent} returns 1 and @code{cdescent} returns 0.
15177 For @samp{a / b} in Big mode, @code{cascent} returns 2 and @code{cdescent}
15178 returns 1. The only formula for which @code{cascent} will return zero
15179 is @samp{cvspace(0)} or equivalents.
15181 @node User-Defined Compositions, , Information about Compositions, Compositions
15182 @subsubsection User-Defined Compositions
15186 @pindex calc-user-define-composition
15187 The @kbd{Z C} (@code{calc-user-define-composition}) command lets you
15188 define the display format for any algebraic function. You provide a
15189 formula containing a certain number of argument variables on the stack.
15190 Any time Calc formats a call to the specified function in the current
15191 language mode and with that number of arguments, Calc effectively
15192 replaces the function call with that formula with the arguments
15195 Calc builds the default argument list by sorting all the variable names
15196 that appear in the formula into alphabetical order. You can edit this
15197 argument list before pressing @key{RET} if you wish. Any variables in
15198 the formula that do not appear in the argument list will be displayed
15199 literally; any arguments that do not appear in the formula will not
15200 affect the display at all.
15202 You can define formats for built-in functions, for functions you have
15203 defined with @kbd{Z F} (@pxref{Algebraic Definitions}), or for functions
15204 which have no definitions but are being used as purely syntactic objects.
15205 You can define different formats for each language mode, and for each
15206 number of arguments, using a succession of @kbd{Z C} commands. When
15207 Calc formats a function call, it first searches for a format defined
15208 for the current language mode (and number of arguments); if there is
15209 none, it uses the format defined for the Normal language mode. If
15210 neither format exists, Calc uses its built-in standard format for that
15211 function (usually just @samp{@var{func}(@var{args})}).
15213 If you execute @kbd{Z C} with the number 0 on the stack instead of a
15214 formula, any defined formats for the function in the current language
15215 mode will be removed. The function will revert to its standard format.
15217 For example, the default format for the binomial coefficient function
15218 @samp{choose(n, m)} in the Big language mode is
15229 You might prefer the notation,
15239 To define this notation, first make sure you are in Big mode,
15240 then put the formula
15243 choriz([cvert([cvspace(1), n]), C, cvert([cvspace(1), m])])
15247 on the stack and type @kbd{Z C}. Answer the first prompt with
15248 @code{choose}. The second prompt will be the default argument list
15249 of @samp{(C m n)}. Edit this list to be @samp{(n m)} and press
15250 @key{RET}. Now, try it out: For example, turn simplification
15251 off with @kbd{m O} and enter @samp{choose(a,b) + choose(7,3)}
15252 as an algebraic entry.
15261 As another example, let's define the usual notation for Stirling
15262 numbers of the first kind, @samp{stir1(n, m)}. This is just like
15263 the regular format for binomial coefficients but with square brackets
15264 instead of parentheses.
15267 choriz([string("["), cvert([n, cbase(cvspace(1)), m]), string("]")])
15270 Now type @kbd{Z C stir1 @key{RET}}, edit the argument list to
15271 @samp{(n m)}, and type @key{RET}.
15273 The formula provided to @kbd{Z C} usually will involve composition
15274 functions, but it doesn't have to. Putting the formula @samp{a + b + c}
15275 onto the stack and typing @kbd{Z C foo @key{RET} @key{RET}} would define
15276 the function @samp{foo(x,y,z)} to display like @samp{x + y + z}.
15277 This ``sum'' will act exactly like a real sum for all formatting
15278 purposes (it will be parenthesized the same, and so on). However
15279 it will be computationally unrelated to a sum. For example, the
15280 formula @samp{2 * foo(1, 2, 3)} will display as @samp{2 (1 + 2 + 3)}.
15281 Operator precedences have caused the ``sum'' to be written in
15282 parentheses, but the arguments have not actually been summed.
15283 (Generally a display format like this would be undesirable, since
15284 it can easily be confused with a real sum.)
15286 The special function @code{eval} can be used inside a @kbd{Z C}
15287 composition formula to cause all or part of the formula to be
15288 evaluated at display time. For example, if the formula is
15289 @samp{a + eval(b + c)}, then @samp{foo(1, 2, 3)} will be displayed
15290 as @samp{1 + 5}. Evaluation will use the default simplifications,
15291 regardless of the current simplification mode. There are also
15292 @code{evalsimp} and @code{evalextsimp} which simplify as if by
15293 @kbd{a s} and @kbd{a e} (respectively). Note that these ``functions''
15294 operate only in the context of composition formulas (and also in
15295 rewrite rules, where they serve a similar purpose; @pxref{Rewrite
15296 Rules}). On the stack, a call to @code{eval} will be left in
15299 It is not a good idea to use @code{eval} except as a last resort.
15300 It can cause the display of formulas to be extremely slow. For
15301 example, while @samp{eval(a + b)} might seem quite fast and simple,
15302 there are several situations where it could be slow. For example,
15303 @samp{a} and/or @samp{b} could be polar complex numbers, in which
15304 case doing the sum requires trigonometry. Or, @samp{a} could be
15305 the factorial @samp{fact(100)} which is unevaluated because you
15306 have typed @kbd{m O}; @code{eval} will evaluate it anyway to
15307 produce a large, unwieldy integer.
15309 You can save your display formats permanently using the @kbd{Z P}
15310 command (@pxref{Creating User Keys}).
15312 @node Syntax Tables, , Compositions, Language Modes
15313 @subsection Syntax Tables
15316 @cindex Syntax tables
15317 @cindex Parsing formulas, customized
15318 Syntax tables do for input what compositions do for output: They
15319 allow you to teach custom notations to Calc's formula parser.
15320 Calc keeps a separate syntax table for each language mode.
15322 (Note that the Calc ``syntax tables'' discussed here are completely
15323 unrelated to the syntax tables described in the Emacs manual.)
15326 @pindex calc-edit-user-syntax
15327 The @kbd{Z S} (@code{calc-edit-user-syntax}) command edits the
15328 syntax table for the current language mode. If you want your
15329 syntax to work in any language, define it in the Normal language
15330 mode. Type @kbd{C-c C-c} to finish editing the syntax table, or
15331 @kbd{C-x k} to cancel the edit. The @kbd{m m} command saves all
15332 the syntax tables along with the other mode settings;
15333 @pxref{General Mode Commands}.
15336 * Syntax Table Basics::
15337 * Precedence in Syntax Tables::
15338 * Advanced Syntax Patterns::
15339 * Conditional Syntax Rules::
15342 @node Syntax Table Basics, Precedence in Syntax Tables, Syntax Tables, Syntax Tables
15343 @subsubsection Syntax Table Basics
15346 @dfn{Parsing} is the process of converting a raw string of characters,
15347 such as you would type in during algebraic entry, into a Calc formula.
15348 Calc's parser works in two stages. First, the input is broken down
15349 into @dfn{tokens}, such as words, numbers, and punctuation symbols
15350 like @samp{+}, @samp{:=}, and @samp{+/-}. Space between tokens is
15351 ignored (except when it serves to separate adjacent words). Next,
15352 the parser matches this string of tokens against various built-in
15353 syntactic patterns, such as ``an expression followed by @samp{+}
15354 followed by another expression'' or ``a name followed by @samp{(},
15355 zero or more expressions separated by commas, and @samp{)}.''
15357 A @dfn{syntax table} is a list of user-defined @dfn{syntax rules},
15358 which allow you to specify new patterns to define your own
15359 favorite input notations. Calc's parser always checks the syntax
15360 table for the current language mode, then the table for the Normal
15361 language mode, before it uses its built-in rules to parse an
15362 algebraic formula you have entered. Each syntax rule should go on
15363 its own line; it consists of a @dfn{pattern}, a @samp{:=} symbol,
15364 and a Calc formula with an optional @dfn{condition}. (Syntax rules
15365 resemble algebraic rewrite rules, but the notation for patterns is
15366 completely different.)
15368 A syntax pattern is a list of tokens, separated by spaces.
15369 Except for a few special symbols, tokens in syntax patterns are
15370 matched literally, from left to right. For example, the rule,
15377 would cause Calc to parse the formula @samp{4+foo()*5} as if it
15378 were @samp{4+(2+3)*5}. Notice that the parentheses were written
15379 as two separate tokens in the rule. As a result, the rule works
15380 for both @samp{foo()} and @w{@samp{foo ( )}}. If we had written
15381 the rule as @samp{foo () := 2+3}, then Calc would treat @samp{()}
15382 as a single, indivisible token, so that @w{@samp{foo( )}} would
15383 not be recognized by the rule. (It would be parsed as a regular
15384 zero-argument function call instead.) In fact, this rule would
15385 also make trouble for the rest of Calc's parser: An unrelated
15386 formula like @samp{bar()} would now be tokenized into @samp{bar ()}
15387 instead of @samp{bar ( )}, so that the standard parser for function
15388 calls would no longer recognize it!
15390 While it is possible to make a token with a mixture of letters
15391 and punctuation symbols, this is not recommended. It is better to
15392 break it into several tokens, as we did with @samp{foo()} above.
15394 The symbol @samp{#} in a syntax pattern matches any Calc expression.
15395 On the righthand side, the things that matched the @samp{#}s can
15396 be referred to as @samp{#1}, @samp{#2}, and so on (where @samp{#1}
15397 matches the leftmost @samp{#} in the pattern). For example, these
15398 rules match a user-defined function, prefix operator, infix operator,
15399 and postfix operator, respectively:
15402 foo ( # ) := myfunc(#1)
15403 foo # := myprefix(#1)
15404 # foo # := myinfix(#1,#2)
15405 # foo := mypostfix(#1)
15408 Thus @samp{foo(3)} will parse as @samp{myfunc(3)}, and @samp{2+3 foo}
15409 will parse as @samp{mypostfix(2+3)}.
15411 It is important to write the first two rules in the order shown,
15412 because Calc tries rules in order from first to last. If the
15413 pattern @samp{foo #} came first, it would match anything that could
15414 match the @samp{foo ( # )} rule, since an expression in parentheses
15415 is itself a valid expression. Thus the @w{@samp{foo ( # )}} rule would
15416 never get to match anything. Likewise, the last two rules must be
15417 written in the order shown or else @samp{3 foo 4} will be parsed as
15418 @samp{mypostfix(3) * 4}. (Of course, the best way to avoid these
15419 ambiguities is not to use the same symbol in more than one way at
15420 the same time! In case you're not convinced, try the following
15421 exercise: How will the above rules parse the input @samp{foo(3,4)},
15422 if at all? Work it out for yourself, then try it in Calc and see.)
15424 Calc is quite flexible about what sorts of patterns are allowed.
15425 The only rule is that every pattern must begin with a literal
15426 token (like @samp{foo} in the first two patterns above), or with
15427 a @samp{#} followed by a literal token (as in the last two
15428 patterns). After that, any mixture is allowed, although putting
15429 two @samp{#}s in a row will not be very useful since two
15430 expressions with nothing between them will be parsed as one
15431 expression that uses implicit multiplication.
15433 As a more practical example, Maple uses the notation
15434 @samp{sum(a(i), i=1..10)} for sums, which Calc's Maple mode doesn't
15435 recognize at present. To handle this syntax, we simply add the
15439 sum ( # , # = # .. # ) := sum(#1,#2,#3,#4)
15443 to the Maple mode syntax table. As another example, C mode can't
15444 read assignment operators like @samp{++} and @samp{*=}. We can
15445 define these operators quite easily:
15448 # *= # := muleq(#1,#2)
15449 # ++ := postinc(#1)
15454 To complete the job, we would use corresponding composition functions
15455 and @kbd{Z C} to cause these functions to display in their respective
15456 Maple and C notations. (Note that the C example ignores issues of
15457 operator precedence, which are discussed in the next section.)
15459 You can enclose any token in quotes to prevent its usual
15460 interpretation in syntax patterns:
15463 # ":=" # := becomes(#1,#2)
15466 Quotes also allow you to include spaces in a token, although once
15467 again it is generally better to use two tokens than one token with
15468 an embedded space. To include an actual quotation mark in a quoted
15469 token, precede it with a backslash. (This also works to include
15470 backslashes in tokens.)
15473 # "bad token" # "/\"\\" # := silly(#1,#2,#3)
15477 This will parse @samp{3 bad token 4 /"\ 5} to @samp{silly(3,4,5)}.
15479 The token @kbd{#} has a predefined meaning in Calc's formula parser;
15480 it is not valid to use @samp{"#"} in a syntax rule. However, longer
15481 tokens that include the @samp{#} character are allowed. Also, while
15482 @samp{"$"} and @samp{"\""} are allowed as tokens, their presence in
15483 the syntax table will prevent those characters from working in their
15484 usual ways (referring to stack entries and quoting strings,
15487 Finally, the notation @samp{%%} anywhere in a syntax table causes
15488 the rest of the line to be ignored as a comment.
15490 @node Precedence in Syntax Tables, Advanced Syntax Patterns, Syntax Table Basics, Syntax Tables
15491 @subsubsection Precedence
15494 Different operators are generally assigned different @dfn{precedences}.
15495 By default, an operator defined by a rule like
15498 # foo # := foo(#1,#2)
15502 will have an extremely low precedence, so that @samp{2*3+4 foo 5 == 6}
15503 will be parsed as @samp{(2*3+4) foo (5 == 6)}. To change the
15504 precedence of an operator, use the notation @samp{#/@var{p}} in
15505 place of @samp{#}, where @var{p} is an integer precedence level.
15506 For example, 185 lies between the precedences for @samp{+} and
15507 @samp{*}, so if we change this rule to
15510 #/185 foo #/186 := foo(#1,#2)
15514 then @samp{2+3 foo 4*5} will be parsed as @samp{2+(3 foo (4*5))}.
15515 Also, because we've given the righthand expression slightly higher
15516 precedence, our new operator will be left-associative:
15517 @samp{1 foo 2 foo 3} will be parsed as @samp{(1 foo 2) foo 3}.
15518 By raising the precedence of the lefthand expression instead, we
15519 can create a right-associative operator.
15521 @xref{Composition Basics}, for a table of precedences of the
15522 standard Calc operators. For the precedences of operators in other
15523 language modes, look in the Calc source file @file{calc-lang.el}.
15525 @node Advanced Syntax Patterns, Conditional Syntax Rules, Precedence in Syntax Tables, Syntax Tables
15526 @subsubsection Advanced Syntax Patterns
15529 To match a function with a variable number of arguments, you could
15533 foo ( # ) := myfunc(#1)
15534 foo ( # , # ) := myfunc(#1,#2)
15535 foo ( # , # , # ) := myfunc(#1,#2,#3)
15539 but this isn't very elegant. To match variable numbers of items,
15540 Calc uses some notations inspired regular expressions and the
15541 ``extended BNF'' style used by some language designers.
15544 foo ( @{ # @}*, ) := apply(myfunc,#1)
15547 The token @samp{@{} introduces a repeated or optional portion.
15548 One of the three tokens @samp{@}*}, @samp{@}+}, or @samp{@}?}
15549 ends the portion. These will match zero or more, one or more,
15550 or zero or one copies of the enclosed pattern, respectively.
15551 In addition, @samp{@}*} and @samp{@}+} can be followed by a
15552 separator token (with no space in between, as shown above).
15553 Thus @samp{@{ # @}*,} matches nothing, or one expression, or
15554 several expressions separated by commas.
15556 A complete @samp{@{ ... @}} item matches as a vector of the
15557 items that matched inside it. For example, the above rule will
15558 match @samp{foo(1,2,3)} to get @samp{apply(myfunc,[1,2,3])}.
15559 The Calc @code{apply} function takes a function name and a vector
15560 of arguments and builds a call to the function with those
15561 arguments, so the net result is the formula @samp{myfunc(1,2,3)}.
15563 If the body of a @samp{@{ ... @}} contains several @samp{#}s
15564 (or nested @samp{@{ ... @}} constructs), then the items will be
15565 strung together into the resulting vector. If the body
15566 does not contain anything but literal tokens, the result will
15567 always be an empty vector.
15570 foo ( @{ # , # @}+, ) := bar(#1)
15571 foo ( @{ @{ # @}*, @}*; ) := matrix(#1)
15575 will parse @samp{foo(1, 2, 3, 4)} as @samp{bar([1, 2, 3, 4])}, and
15576 @samp{foo(1, 2; 3, 4)} as @samp{matrix([[1, 2], [3, 4]])}. Also, after
15577 some thought it's easy to see how this pair of rules will parse
15578 @samp{foo(1, 2, 3)} as @samp{matrix([[1, 2, 3]])}, since the first
15579 rule will only match an even number of arguments. The rule
15582 foo ( # @{ , # , # @}? ) := bar(#1,#2)
15586 will parse @samp{foo(2,3,4)} as @samp{bar(2,[3,4])}, and
15587 @samp{foo(2)} as @samp{bar(2,[])}.
15589 The notation @samp{@{ ... @}?.} (note the trailing period) works
15590 just the same as regular @samp{@{ ... @}?}, except that it does not
15591 count as an argument; the following two rules are equivalent:
15594 foo ( # , @{ also @}? # ) := bar(#1,#3)
15595 foo ( # , @{ also @}?. # ) := bar(#1,#2)
15599 Note that in the first case the optional text counts as @samp{#2},
15600 which will always be an empty vector, but in the second case no
15601 empty vector is produced.
15603 Another variant is @samp{@{ ... @}?$}, which means the body is
15604 optional only at the end of the input formula. All built-in syntax
15605 rules in Calc use this for closing delimiters, so that during
15606 algebraic entry you can type @kbd{[sqrt(2), sqrt(3 @key{RET}}, omitting
15607 the closing parenthesis and bracket. Calc does this automatically
15608 for trailing @samp{)}, @samp{]}, and @samp{>} tokens in syntax
15609 rules, but you can use @samp{@{ ... @}?$} explicitly to get
15610 this effect with any token (such as @samp{"@}"} or @samp{end}).
15611 Like @samp{@{ ... @}?.}, this notation does not count as an
15612 argument. Conversely, you can use quotes, as in @samp{")"}, to
15613 prevent a closing-delimiter token from being automatically treated
15616 Calc's parser does not have full backtracking, which means some
15617 patterns will not work as you might expect:
15620 foo ( @{ # , @}? # , # ) := bar(#1,#2,#3)
15624 Here we are trying to make the first argument optional, so that
15625 @samp{foo(2,3)} parses as @samp{bar([],2,3)}. Unfortunately, Calc
15626 first tries to match @samp{2,} against the optional part of the
15627 pattern, finds a match, and so goes ahead to match the rest of the
15628 pattern. Later on it will fail to match the second comma, but it
15629 doesn't know how to go back and try the other alternative at that
15630 point. One way to get around this would be to use two rules:
15633 foo ( # , # , # ) := bar([#1],#2,#3)
15634 foo ( # , # ) := bar([],#1,#2)
15637 More precisely, when Calc wants to match an optional or repeated
15638 part of a pattern, it scans forward attempting to match that part.
15639 If it reaches the end of the optional part without failing, it
15640 ``finalizes'' its choice and proceeds. If it fails, though, it
15641 backs up and tries the other alternative. Thus Calc has ``partial''
15642 backtracking. A fully backtracking parser would go on to make sure
15643 the rest of the pattern matched before finalizing the choice.
15645 @node Conditional Syntax Rules, , Advanced Syntax Patterns, Syntax Tables
15646 @subsubsection Conditional Syntax Rules
15649 It is possible to attach a @dfn{condition} to a syntax rule. For
15653 foo ( # ) := ifoo(#1) :: integer(#1)
15654 foo ( # ) := gfoo(#1)
15658 will parse @samp{foo(3)} as @samp{ifoo(3)}, but will parse
15659 @samp{foo(3.5)} and @samp{foo(x)} as calls to @code{gfoo}. Any
15660 number of conditions may be attached; all must be true for the
15661 rule to succeed. A condition is ``true'' if it evaluates to a
15662 nonzero number. @xref{Logical Operations}, for a list of Calc
15663 functions like @code{integer} that perform logical tests.
15665 The exact sequence of events is as follows: When Calc tries a
15666 rule, it first matches the pattern as usual. It then substitutes
15667 @samp{#1}, @samp{#2}, etc., in the conditions, if any. Next, the
15668 conditions are simplified and evaluated in order from left to right,
15669 as if by the @w{@kbd{a s}} algebra command (@pxref{Simplifying Formulas}).
15670 Each result is true if it is a nonzero number, or an expression
15671 that can be proven to be nonzero (@pxref{Declarations}). If the
15672 results of all conditions are true, the expression (such as
15673 @samp{ifoo(#1)}) has its @samp{#}s substituted, and that is the
15674 result of the parse. If the result of any condition is false, Calc
15675 goes on to try the next rule in the syntax table.
15677 Syntax rules also support @code{let} conditions, which operate in
15678 exactly the same way as they do in algebraic rewrite rules.
15679 @xref{Other Features of Rewrite Rules}, for details. A @code{let}
15680 condition is always true, but as a side effect it defines a
15681 variable which can be used in later conditions, and also in the
15682 expression after the @samp{:=} sign:
15685 foo ( # ) := hifoo(x) :: let(x := #1 + 0.5) :: dnumint(x)
15689 The @code{dnumint} function tests if a value is numerically an
15690 integer, i.e., either a true integer or an integer-valued float.
15691 This rule will parse @code{foo} with a half-integer argument,
15692 like @samp{foo(3.5)}, to a call like @samp{hifoo(4.)}.
15694 The lefthand side of a syntax rule @code{let} must be a simple
15695 variable, not the arbitrary pattern that is allowed in rewrite
15698 The @code{matches} function is also treated specially in syntax
15699 rule conditions (again, in the same way as in rewrite rules).
15700 @xref{Matching Commands}. If the matching pattern contains
15701 meta-variables, then those meta-variables may be used in later
15702 conditions and in the result expression. The arguments to
15703 @code{matches} are not evaluated in this situation.
15706 sum ( # , # ) := sum(#1,a,b,c) :: matches(#2, a=[b..c])
15710 This is another way to implement the Maple mode @code{sum} notation.
15711 In this approach, we allow @samp{#2} to equal the whole expression
15712 @samp{i=1..10}. Then, we use @code{matches} to break it apart into
15713 its components. If the expression turns out not to match the pattern,
15714 the syntax rule will fail. Note that @kbd{Z S} always uses Calc's
15715 Normal language mode for editing expressions in syntax rules, so we
15716 must use regular Calc notation for the interval @samp{[b..c]} that
15717 will correspond to the Maple mode interval @samp{1..10}.
15719 @node Modes Variable, Calc Mode Line, Language Modes, Mode Settings
15720 @section The @code{Modes} Variable
15724 @pindex calc-get-modes
15725 The @kbd{m g} (@code{calc-get-modes}) command pushes onto the stack
15726 a vector of numbers that describes the various mode settings that
15727 are in effect. With a numeric prefix argument, it pushes only the
15728 @var{n}th mode, i.e., the @var{n}th element of this vector. Keyboard
15729 macros can use the @kbd{m g} command to modify their behavior based
15730 on the current mode settings.
15732 @cindex @code{Modes} variable
15734 The modes vector is also available in the special variable
15735 @code{Modes}. In other words, @kbd{m g} is like @kbd{s r Modes @key{RET}}.
15736 It will not work to store into this variable; in fact, if you do,
15737 @code{Modes} will cease to track the current modes. (The @kbd{m g}
15738 command will continue to work, however.)
15740 In general, each number in this vector is suitable as a numeric
15741 prefix argument to the associated mode-setting command. (Recall
15742 that the @kbd{~} key takes a number from the stack and gives it as
15743 a numeric prefix to the next command.)
15745 The elements of the modes vector are as follows:
15749 Current precision. Default is 12; associated command is @kbd{p}.
15752 Binary word size. Default is 32; associated command is @kbd{b w}.
15755 Stack size (not counting the value about to be pushed by @kbd{m g}).
15756 This is zero if @kbd{m g} is executed with an empty stack.
15759 Number radix. Default is 10; command is @kbd{d r}.
15762 Floating-point format. This is the number of digits, plus the
15763 constant 0 for normal notation, 10000 for scientific notation,
15764 20000 for engineering notation, or 30000 for fixed-point notation.
15765 These codes are acceptable as prefix arguments to the @kbd{d n}
15766 command, but note that this may lose information: For example,
15767 @kbd{d s} and @kbd{C-u 12 d s} have similar (but not quite
15768 identical) effects if the current precision is 12, but they both
15769 produce a code of 10012, which will be treated by @kbd{d n} as
15770 @kbd{C-u 12 d s}. If the precision then changes, the float format
15771 will still be frozen at 12 significant figures.
15774 Angular mode. Default is 1 (degrees). Other values are 2 (radians)
15775 and 3 (HMS). The @kbd{m d} command accepts these prefixes.
15778 Symbolic mode. Value is 0 or 1; default is 0. Command is @kbd{m s}.
15781 Fraction mode. Value is 0 or 1; default is 0. Command is @kbd{m f}.
15784 Polar mode. Value is 0 (rectangular) or 1 (polar); default is 0.
15785 Command is @kbd{m p}.
15788 Matrix/Scalar mode. Default value is @mathit{-1}. Value is 0 for Scalar
15789 mode, @mathit{-2} for Matrix mode, @mathit{-3} for square Matrix mode,
15791 @texline @math{N\times N}
15792 @infoline @var{N}x@var{N}
15793 Matrix mode. Command is @kbd{m v}.
15796 Simplification mode. Default is 1. Value is @mathit{-1} for off (@kbd{m O}),
15797 0 for @kbd{m N}, 2 for @kbd{m B}, 3 for @kbd{m A}, 4 for @kbd{m E},
15798 or 5 for @w{@kbd{m U}}. The @kbd{m D} command accepts these prefixes.
15801 Infinite mode. Default is @mathit{-1} (off). Value is 1 if the mode is on,
15802 or 0 if the mode is on with positive zeros. Command is @kbd{m i}.
15805 For example, the sequence @kbd{M-1 m g @key{RET} 2 + ~ p} increases the
15806 precision by two, leaving a copy of the old precision on the stack.
15807 Later, @kbd{~ p} will restore the original precision using that
15808 stack value. (This sequence might be especially useful inside a
15811 As another example, @kbd{M-3 m g 1 - ~ @key{DEL}} deletes all but the
15812 oldest (bottommost) stack entry.
15814 Yet another example: The HP-48 ``round'' command rounds a number
15815 to the current displayed precision. You could roughly emulate this
15816 in Calc with the sequence @kbd{M-5 m g 10000 % ~ c c}. (This
15817 would not work for fixed-point mode, but it wouldn't be hard to
15818 do a full emulation with the help of the @kbd{Z [} and @kbd{Z ]}
15819 programming commands. @xref{Conditionals in Macros}.)
15821 @node Calc Mode Line, , Modes Variable, Mode Settings
15822 @section The Calc Mode Line
15825 @cindex Mode line indicators
15826 This section is a summary of all symbols that can appear on the
15827 Calc mode line, the highlighted bar that appears under the Calc
15828 stack window (or under an editing window in Embedded mode).
15830 The basic mode line format is:
15833 --%*-Calc: 12 Deg @var{other modes} (Calculator)
15836 The @samp{%*} indicates that the buffer is ``read-only''; it shows that
15837 regular Emacs commands are not allowed to edit the stack buffer
15838 as if it were text.
15840 The word @samp{Calc:} changes to @samp{CalcEmbed:} if Embedded mode
15841 is enabled. The words after this describe the various Calc modes
15842 that are in effect.
15844 The first mode is always the current precision, an integer.
15845 The second mode is always the angular mode, either @code{Deg},
15846 @code{Rad}, or @code{Hms}.
15848 Here is a complete list of the remaining symbols that can appear
15853 Algebraic mode (@kbd{m a}; @pxref{Algebraic Entry}).
15856 Incomplete algebraic mode (@kbd{C-u m a}).
15859 Total algebraic mode (@kbd{m t}).
15862 Symbolic mode (@kbd{m s}; @pxref{Symbolic Mode}).
15865 Matrix mode (@kbd{m v}; @pxref{Matrix Mode}).
15867 @item Matrix@var{n}
15868 Dimensioned Matrix mode (@kbd{C-u @var{n} m v}; @pxref{Matrix Mode}).
15871 Square Matrix mode (@kbd{C-u m v}; @pxref{Matrix Mode}).
15874 Scalar mode (@kbd{m v}; @pxref{Matrix Mode}).
15877 Polar complex mode (@kbd{m p}; @pxref{Polar Mode}).
15880 Fraction mode (@kbd{m f}; @pxref{Fraction Mode}).
15883 Infinite mode (@kbd{m i}; @pxref{Infinite Mode}).
15886 Positive Infinite mode (@kbd{C-u 0 m i}).
15889 Default simplifications off (@kbd{m O}; @pxref{Simplification Modes}).
15892 Default simplifications for numeric arguments only (@kbd{m N}).
15894 @item BinSimp@var{w}
15895 Binary-integer simplification mode; word size @var{w} (@kbd{m B}, @kbd{b w}).
15898 Algebraic simplification mode (@kbd{m A}).
15901 Extended algebraic simplification mode (@kbd{m E}).
15904 Units simplification mode (@kbd{m U}).
15907 Current radix is 2 (@kbd{d 2}; @pxref{Radix Modes}).
15910 Current radix is 8 (@kbd{d 8}).
15913 Current radix is 16 (@kbd{d 6}).
15916 Current radix is @var{n} (@kbd{d r}).
15919 Leading zeros (@kbd{d z}; @pxref{Radix Modes}).
15922 Big language mode (@kbd{d B}; @pxref{Normal Language Modes}).
15925 One-line normal language mode (@kbd{d O}).
15928 Unformatted language mode (@kbd{d U}).
15931 C language mode (@kbd{d C}; @pxref{C FORTRAN Pascal}).
15934 Pascal language mode (@kbd{d P}).
15937 FORTRAN language mode (@kbd{d F}).
15940 @TeX{} language mode (@kbd{d T}; @pxref{TeX and LaTeX Language Modes}).
15943 La@TeX{} language mode (@kbd{d L}; @pxref{TeX and LaTeX Language Modes}).
15946 @dfn{Eqn} language mode (@kbd{d E}; @pxref{Eqn Language Mode}).
15949 Mathematica language mode (@kbd{d M}; @pxref{Mathematica Language Mode}).
15952 Maple language mode (@kbd{d W}; @pxref{Maple Language Mode}).
15955 Normal float mode with @var{n} digits (@kbd{d n}; @pxref{Float Formats}).
15958 Fixed point mode with @var{n} digits after the point (@kbd{d f}).
15961 Scientific notation mode (@kbd{d s}).
15964 Scientific notation with @var{n} digits (@kbd{d s}).
15967 Engineering notation mode (@kbd{d e}).
15970 Engineering notation with @var{n} digits (@kbd{d e}).
15973 Left-justified display indented by @var{n} (@kbd{d <}; @pxref{Justification}).
15976 Right-justified display (@kbd{d >}).
15979 Right-justified display with width @var{n} (@kbd{d >}).
15982 Centered display (@kbd{d =}).
15984 @item Center@var{n}
15985 Centered display with center column @var{n} (@kbd{d =}).
15988 Line breaking with width @var{n} (@kbd{d b}; @pxref{Normal Language Modes}).
15991 No line breaking (@kbd{d b}).
15994 Selections show deep structure (@kbd{j b}; @pxref{Making Selections}).
15997 Record modes in @file{~/.emacs.d/calc.el} (@kbd{m R}; @pxref{General Mode Commands}).
16000 Record modes in Embedded buffer (@kbd{m R}).
16003 Record modes as editing-only in Embedded buffer (@kbd{m R}).
16006 Record modes as permanent-only in Embedded buffer (@kbd{m R}).
16009 Record modes as global in Embedded buffer (@kbd{m R}).
16012 Automatic recomputation turned off (@kbd{m C}; @pxref{Automatic
16016 GNUPLOT process is alive in background (@pxref{Graphics}).
16019 Top-of-stack has a selection (Embedded only; @pxref{Making Selections}).
16022 The stack display may not be up-to-date (@pxref{Display Modes}).
16025 ``Inverse'' prefix was pressed (@kbd{I}; @pxref{Inverse and Hyperbolic}).
16028 ``Hyperbolic'' prefix was pressed (@kbd{H}).
16031 ``Keep-arguments'' prefix was pressed (@kbd{K}).
16034 Stack is truncated (@kbd{d t}; @pxref{Truncating the Stack}).
16037 In addition, the symbols @code{Active} and @code{~Active} can appear
16038 as minor modes on an Embedded buffer's mode line. @xref{Embedded Mode}.
16040 @node Arithmetic, Scientific Functions, Mode Settings, Top
16041 @chapter Arithmetic Functions
16044 This chapter describes the Calc commands for doing simple calculations
16045 on numbers, such as addition, absolute value, and square roots. These
16046 commands work by removing the top one or two values from the stack,
16047 performing the desired operation, and pushing the result back onto the
16048 stack. If the operation cannot be performed, the result pushed is a
16049 formula instead of a number, such as @samp{2/0} (because division by zero
16050 is invalid) or @samp{sqrt(x)} (because the argument @samp{x} is a formula).
16052 Most of the commands described here can be invoked by a single keystroke.
16053 Some of the more obscure ones are two-letter sequences beginning with
16054 the @kbd{f} (``functions'') prefix key.
16056 @xref{Prefix Arguments}, for a discussion of the effect of numeric
16057 prefix arguments on commands in this chapter which do not otherwise
16058 interpret a prefix argument.
16061 * Basic Arithmetic::
16062 * Integer Truncation::
16063 * Complex Number Functions::
16065 * Date Arithmetic::
16066 * Financial Functions::
16067 * Binary Functions::
16070 @node Basic Arithmetic, Integer Truncation, Arithmetic, Arithmetic
16071 @section Basic Arithmetic
16080 The @kbd{+} (@code{calc-plus}) command adds two numbers. The numbers may
16081 be any of the standard Calc data types. The resulting sum is pushed back
16084 If both arguments of @kbd{+} are vectors or matrices (of matching dimensions),
16085 the result is a vector or matrix sum. If one argument is a vector and the
16086 other a scalar (i.e., a non-vector), the scalar is added to each of the
16087 elements of the vector to form a new vector. If the scalar is not a
16088 number, the operation is left in symbolic form: Suppose you added @samp{x}
16089 to the vector @samp{[1,2]}. You may want the result @samp{[1+x,2+x]}, or
16090 you may plan to substitute a 2-vector for @samp{x} in the future. Since
16091 the Calculator can't tell which interpretation you want, it makes the
16092 safest assumption. @xref{Reducing and Mapping}, for a way to add @samp{x}
16093 to every element of a vector.
16095 If either argument of @kbd{+} is a complex number, the result will in general
16096 be complex. If one argument is in rectangular form and the other polar,
16097 the current Polar mode determines the form of the result. If Symbolic
16098 mode is enabled, the sum may be left as a formula if the necessary
16099 conversions for polar addition are non-trivial.
16101 If both arguments of @kbd{+} are HMS forms, the forms are added according to
16102 the usual conventions of hours-minutes-seconds notation. If one argument
16103 is an HMS form and the other is a number, that number is converted from
16104 degrees or radians (depending on the current Angular mode) to HMS format
16105 and then the two HMS forms are added.
16107 If one argument of @kbd{+} is a date form, the other can be either a
16108 real number, which advances the date by a certain number of days, or
16109 an HMS form, which advances the date by a certain amount of time.
16110 Subtracting two date forms yields the number of days between them.
16111 Adding two date forms is meaningless, but Calc interprets it as the
16112 subtraction of one date form and the negative of the other. (The
16113 negative of a date form can be understood by remembering that dates
16114 are stored as the number of days before or after Jan 1, 1 AD.)
16116 If both arguments of @kbd{+} are error forms, the result is an error form
16117 with an appropriately computed standard deviation. If one argument is an
16118 error form and the other is a number, the number is taken to have zero error.
16119 Error forms may have symbolic formulas as their mean and/or error parts;
16120 adding these will produce a symbolic error form result. However, adding an
16121 error form to a plain symbolic formula (as in @samp{(a +/- b) + c}) will not
16122 work, for the same reasons just mentioned for vectors. Instead you must
16123 write @samp{(a +/- b) + (c +/- 0)}.
16125 If both arguments of @kbd{+} are modulo forms with equal values of @expr{M},
16126 or if one argument is a modulo form and the other a plain number, the
16127 result is a modulo form which represents the sum, modulo @expr{M}, of
16130 If both arguments of @kbd{+} are intervals, the result is an interval
16131 which describes all possible sums of the possible input values. If
16132 one argument is a plain number, it is treated as the interval
16133 @w{@samp{[x ..@: x]}}.
16135 If one argument of @kbd{+} is an infinity and the other is not, the
16136 result is that same infinity. If both arguments are infinite and in
16137 the same direction, the result is the same infinity, but if they are
16138 infinite in different directions the result is @code{nan}.
16146 The @kbd{-} (@code{calc-minus}) command subtracts two values. The top
16147 number on the stack is subtracted from the one behind it, so that the
16148 computation @kbd{5 @key{RET} 2 -} produces 3, not @mathit{-3}. All options
16149 available for @kbd{+} are available for @kbd{-} as well.
16157 The @kbd{*} (@code{calc-times}) command multiplies two numbers. If one
16158 argument is a vector and the other a scalar, the scalar is multiplied by
16159 the elements of the vector to produce a new vector. If both arguments
16160 are vectors, the interpretation depends on the dimensions of the
16161 vectors: If both arguments are matrices, a matrix multiplication is
16162 done. If one argument is a matrix and the other a plain vector, the
16163 vector is interpreted as a row vector or column vector, whichever is
16164 dimensionally correct. If both arguments are plain vectors, the result
16165 is a single scalar number which is the dot product of the two vectors.
16167 If one argument of @kbd{*} is an HMS form and the other a number, the
16168 HMS form is multiplied by that amount. It is an error to multiply two
16169 HMS forms together, or to attempt any multiplication involving date
16170 forms. Error forms, modulo forms, and intervals can be multiplied;
16171 see the comments for addition of those forms. When two error forms
16172 or intervals are multiplied they are considered to be statistically
16173 independent; thus, @samp{[-2 ..@: 3] * [-2 ..@: 3]} is @samp{[-6 ..@: 9]},
16174 whereas @w{@samp{[-2 ..@: 3] ^ 2}} is @samp{[0 ..@: 9]}.
16177 @pindex calc-divide
16182 The @kbd{/} (@code{calc-divide}) command divides two numbers.
16184 When combining multiplication and division in an algebraic formula, it
16185 is good style to use parentheses to distinguish between possible
16186 interpretations; the expression @samp{a/b*c} should be written
16187 @samp{(a/b)*c} or @samp{a/(b*c)}, as appropriate. Without the
16188 parentheses, Calc will interpret @samp{a/b*c} as @samp{a/(b*c)}, since
16189 in algebraic entry Calc gives division a lower precedence than
16190 multiplication. (This is not standard across all computer languages, and
16191 Calc may change the precedence depending on the language mode being used.
16192 @xref{Language Modes}.) This default ordering can be changed by setting
16193 the customizable variable @code{calc-multiplication-has-precedence} to
16194 @code{nil} (@pxref{Customizing Calc}); this will give multiplication and
16195 division equal precedences. Note that Calc's default choice of
16196 precedence allows @samp{a b / c d} to be used as a shortcut for
16205 When dividing a scalar @expr{B} by a square matrix @expr{A}, the
16206 computation performed is @expr{B} times the inverse of @expr{A}. This
16207 also occurs if @expr{B} is itself a vector or matrix, in which case the
16208 effect is to solve the set of linear equations represented by @expr{B}.
16209 If @expr{B} is a matrix with the same number of rows as @expr{A}, or a
16210 plain vector (which is interpreted here as a column vector), then the
16211 equation @expr{A X = B} is solved for the vector or matrix @expr{X}.
16212 Otherwise, if @expr{B} is a non-square matrix with the same number of
16213 @emph{columns} as @expr{A}, the equation @expr{X A = B} is solved. If
16214 you wish a vector @expr{B} to be interpreted as a row vector to be
16215 solved as @expr{X A = B}, make it into a one-row matrix with @kbd{C-u 1
16216 v p} first. To force a left-handed solution with a square matrix
16217 @expr{B}, transpose @expr{A} and @expr{B} before dividing, then
16218 transpose the result.
16220 HMS forms can be divided by real numbers or by other HMS forms. Error
16221 forms can be divided in any combination of ways. Modulo forms where both
16222 values and the modulo are integers can be divided to get an integer modulo
16223 form result. Intervals can be divided; dividing by an interval that
16224 encompasses zero or has zero as a limit will result in an infinite
16233 The @kbd{^} (@code{calc-power}) command raises a number to a power. If
16234 the power is an integer, an exact result is computed using repeated
16235 multiplications. For non-integer powers, Calc uses Newton's method or
16236 logarithms and exponentials. Square matrices can be raised to integer
16237 powers. If either argument is an error (or interval or modulo) form,
16238 the result is also an error (or interval or modulo) form.
16242 If you press the @kbd{I} (inverse) key first, the @kbd{I ^} command
16243 computes an Nth root: @kbd{125 @key{RET} 3 I ^} computes the number 5.
16244 (This is entirely equivalent to @kbd{125 @key{RET} 1:3 ^}.)
16253 The @kbd{\} (@code{calc-idiv}) command divides two numbers on the stack
16254 to produce an integer result. It is equivalent to dividing with
16255 @key{/}, then rounding down with @kbd{F} (@code{calc-floor}), only a bit
16256 more convenient and efficient. Also, since it is an all-integer
16257 operation when the arguments are integers, it avoids problems that
16258 @kbd{/ F} would have with floating-point roundoff.
16266 The @kbd{%} (@code{calc-mod}) command performs a ``modulo'' (or ``remainder'')
16267 operation. Mathematically, @samp{a%b = a - (a\b)*b}, and is defined
16268 for all real numbers @expr{a} and @expr{b} (except @expr{b=0}). For
16269 positive @expr{b}, the result will always be between 0 (inclusive) and
16270 @expr{b} (exclusive). Modulo does not work for HMS forms and error forms.
16271 If @expr{a} is a modulo form, its modulo is changed to @expr{b}, which
16272 must be positive real number.
16277 The @kbd{:} (@code{calc-fdiv}) [@code{fdiv}] command
16278 divides the two integers on the top of the stack to produce a fractional
16279 result. This is a convenient shorthand for enabling Fraction mode (with
16280 @kbd{m f}) temporarily and using @samp{/}. Note that during numeric entry
16281 the @kbd{:} key is interpreted as a fraction separator, so to divide 8 by 6
16282 you would have to type @kbd{8 @key{RET} 6 @key{RET} :}. (Of course, in
16283 this case, it would be much easier simply to enter the fraction directly
16284 as @kbd{8:6 @key{RET}}!)
16287 @pindex calc-change-sign
16288 The @kbd{n} (@code{calc-change-sign}) command negates the number on the top
16289 of the stack. It works on numbers, vectors and matrices, HMS forms, date
16290 forms, error forms, intervals, and modulo forms.
16295 The @kbd{A} (@code{calc-abs}) [@code{abs}] command computes the absolute
16296 value of a number. The result of @code{abs} is always a nonnegative
16297 real number: With a complex argument, it computes the complex magnitude.
16298 With a vector or matrix argument, it computes the Frobenius norm, i.e.,
16299 the square root of the sum of the squares of the absolute values of the
16300 elements. The absolute value of an error form is defined by replacing
16301 the mean part with its absolute value and leaving the error part the same.
16302 The absolute value of a modulo form is undefined. The absolute value of
16303 an interval is defined in the obvious way.
16306 @pindex calc-abssqr
16308 The @kbd{f A} (@code{calc-abssqr}) [@code{abssqr}] command computes the
16309 absolute value squared of a number, vector or matrix, or error form.
16314 The @kbd{f s} (@code{calc-sign}) [@code{sign}] command returns 1 if its
16315 argument is positive, @mathit{-1} if its argument is negative, or 0 if its
16316 argument is zero. In algebraic form, you can also write @samp{sign(a,x)}
16317 which evaluates to @samp{x * sign(a)}, i.e., either @samp{x}, @samp{-x}, or
16318 zero depending on the sign of @samp{a}.
16324 The @kbd{&} (@code{calc-inv}) [@code{inv}] command computes the
16325 reciprocal of a number, i.e., @expr{1 / x}. Operating on a square
16326 matrix, it computes the inverse of that matrix.
16331 The @kbd{Q} (@code{calc-sqrt}) [@code{sqrt}] command computes the square
16332 root of a number. For a negative real argument, the result will be a
16333 complex number whose form is determined by the current Polar mode.
16338 The @kbd{f h} (@code{calc-hypot}) [@code{hypot}] command computes the square
16339 root of the sum of the squares of two numbers. That is, @samp{hypot(a,b)}
16340 is the length of the hypotenuse of a right triangle with sides @expr{a}
16341 and @expr{b}. If the arguments are complex numbers, their squared
16342 magnitudes are used.
16347 The @kbd{f Q} (@code{calc-isqrt}) [@code{isqrt}] command computes the
16348 integer square root of an integer. This is the true square root of the
16349 number, rounded down to an integer. For example, @samp{isqrt(10)}
16350 produces 3. Note that, like @kbd{\} [@code{idiv}], this uses exact
16351 integer arithmetic throughout to avoid roundoff problems. If the input
16352 is a floating-point number or other non-integer value, this is exactly
16353 the same as @samp{floor(sqrt(x))}.
16361 The @kbd{f n} (@code{calc-min}) [@code{min}] and @kbd{f x} (@code{calc-max})
16362 [@code{max}] commands take the minimum or maximum of two real numbers,
16363 respectively. These commands also work on HMS forms, date forms,
16364 intervals, and infinities. (In algebraic expressions, these functions
16365 take any number of arguments and return the maximum or minimum among
16366 all the arguments.)
16370 @pindex calc-mant-part
16372 @pindex calc-xpon-part
16374 The @kbd{f M} (@code{calc-mant-part}) [@code{mant}] function extracts
16375 the ``mantissa'' part @expr{m} of its floating-point argument; @kbd{f X}
16376 (@code{calc-xpon-part}) [@code{xpon}] extracts the ``exponent'' part
16377 @expr{e}. The original number is equal to
16378 @texline @math{m \times 10^e},
16379 @infoline @expr{m * 10^e},
16380 where @expr{m} is in the interval @samp{[1.0 ..@: 10.0)} except that
16381 @expr{m=e=0} if the original number is zero. For integers
16382 and fractions, @code{mant} returns the number unchanged and @code{xpon}
16383 returns zero. The @kbd{v u} (@code{calc-unpack}) command can also be
16384 used to ``unpack'' a floating-point number; this produces an integer
16385 mantissa and exponent, with the constraint that the mantissa is not
16386 a multiple of ten (again except for the @expr{m=e=0} case).
16389 @pindex calc-scale-float
16391 The @kbd{f S} (@code{calc-scale-float}) [@code{scf}] function scales a number
16392 by a given power of ten. Thus, @samp{scf(mant(x), xpon(x)) = x} for any
16393 real @samp{x}. The second argument must be an integer, but the first
16394 may actually be any numeric value. For example, @samp{scf(5,-2) = 0.05}
16395 or @samp{1:20} depending on the current Fraction mode.
16399 @pindex calc-decrement
16400 @pindex calc-increment
16403 The @kbd{f [} (@code{calc-decrement}) [@code{decr}] and @kbd{f ]}
16404 (@code{calc-increment}) [@code{incr}] functions decrease or increase
16405 a number by one unit. For integers, the effect is obvious. For
16406 floating-point numbers, the change is by one unit in the last place.
16407 For example, incrementing @samp{12.3456} when the current precision
16408 is 6 digits yields @samp{12.3457}. If the current precision had been
16409 8 digits, the result would have been @samp{12.345601}. Incrementing
16410 @samp{0.0} produces
16411 @texline @math{10^{-p}},
16412 @infoline @expr{10^-p},
16413 where @expr{p} is the current
16414 precision. These operations are defined only on integers and floats.
16415 With numeric prefix arguments, they change the number by @expr{n} units.
16417 Note that incrementing followed by decrementing, or vice-versa, will
16418 almost but not quite always cancel out. Suppose the precision is
16419 6 digits and the number @samp{9.99999} is on the stack. Incrementing
16420 will produce @samp{10.0000}; decrementing will produce @samp{9.9999}.
16421 One digit has been dropped. This is an unavoidable consequence of the
16422 way floating-point numbers work.
16424 Incrementing a date/time form adjusts it by a certain number of seconds.
16425 Incrementing a pure date form adjusts it by a certain number of days.
16427 @node Integer Truncation, Complex Number Functions, Basic Arithmetic, Arithmetic
16428 @section Integer Truncation
16431 There are four commands for truncating a real number to an integer,
16432 differing mainly in their treatment of negative numbers. All of these
16433 commands have the property that if the argument is an integer, the result
16434 is the same integer. An integer-valued floating-point argument is converted
16437 If you press @kbd{H} (@code{calc-hyperbolic}) first, the result will be
16438 expressed as an integer-valued floating-point number.
16440 @cindex Integer part of a number
16449 The @kbd{F} (@code{calc-floor}) [@code{floor} or @code{ffloor}] command
16450 truncates a real number to the next lower integer, i.e., toward minus
16451 infinity. Thus @kbd{3.6 F} produces 3, but @kbd{_3.6 F} produces
16455 @pindex calc-ceiling
16462 The @kbd{I F} (@code{calc-ceiling}) [@code{ceil} or @code{fceil}]
16463 command truncates toward positive infinity. Thus @kbd{3.6 I F} produces
16464 4, and @kbd{_3.6 I F} produces @mathit{-3}.
16474 The @kbd{R} (@code{calc-round}) [@code{round} or @code{fround}] command
16475 rounds to the nearest integer. When the fractional part is .5 exactly,
16476 this command rounds away from zero. (All other rounding in the
16477 Calculator uses this convention as well.) Thus @kbd{3.5 R} produces 4
16478 but @kbd{3.4 R} produces 3; @kbd{_3.5 R} produces @mathit{-4}.
16488 The @kbd{I R} (@code{calc-trunc}) [@code{trunc} or @code{ftrunc}]
16489 command truncates toward zero. In other words, it ``chops off''
16490 everything after the decimal point. Thus @kbd{3.6 I R} produces 3 and
16491 @kbd{_3.6 I R} produces @mathit{-3}.
16493 These functions may not be applied meaningfully to error forms, but they
16494 do work for intervals. As a convenience, applying @code{floor} to a
16495 modulo form floors the value part of the form. Applied to a vector,
16496 these functions operate on all elements of the vector one by one.
16497 Applied to a date form, they operate on the internal numerical
16498 representation of dates, converting a date/time form into a pure date.
16516 There are two more rounding functions which can only be entered in
16517 algebraic notation. The @code{roundu} function is like @code{round}
16518 except that it rounds up, toward plus infinity, when the fractional
16519 part is .5. This distinction matters only for negative arguments.
16520 Also, @code{rounde} rounds to an even number in the case of a tie,
16521 rounding up or down as necessary. For example, @samp{rounde(3.5)} and
16522 @samp{rounde(4.5)} both return 4, but @samp{rounde(5.5)} returns 6.
16523 The advantage of round-to-even is that the net error due to rounding
16524 after a long calculation tends to cancel out to zero. An important
16525 subtle point here is that the number being fed to @code{rounde} will
16526 already have been rounded to the current precision before @code{rounde}
16527 begins. For example, @samp{rounde(2.500001)} with a current precision
16528 of 6 will incorrectly, or at least surprisingly, yield 2 because the
16529 argument will first have been rounded down to @expr{2.5} (which
16530 @code{rounde} sees as an exact tie between 2 and 3).
16532 Each of these functions, when written in algebraic formulas, allows
16533 a second argument which specifies the number of digits after the
16534 decimal point to keep. For example, @samp{round(123.4567, 2)} will
16535 produce the answer 123.46, and @samp{round(123.4567, -1)} will
16536 produce 120 (i.e., the cutoff is one digit to the @emph{left} of
16537 the decimal point). A second argument of zero is equivalent to
16538 no second argument at all.
16540 @cindex Fractional part of a number
16541 To compute the fractional part of a number (i.e., the amount which, when
16542 added to `@tfn{floor(}@var{n}@tfn{)}', will produce @var{n}) just take @var{n}
16543 modulo 1 using the @code{%} command.
16545 Note also the @kbd{\} (integer quotient), @kbd{f I} (integer logarithm),
16546 and @kbd{f Q} (integer square root) commands, which are analogous to
16547 @kbd{/}, @kbd{B}, and @kbd{Q}, respectively, except that they take integer
16548 arguments and return the result rounded down to an integer.
16550 @node Complex Number Functions, Conversions, Integer Truncation, Arithmetic
16551 @section Complex Number Functions
16557 The @kbd{J} (@code{calc-conj}) [@code{conj}] command computes the
16558 complex conjugate of a number. For complex number @expr{a+bi}, the
16559 complex conjugate is @expr{a-bi}. If the argument is a real number,
16560 this command leaves it the same. If the argument is a vector or matrix,
16561 this command replaces each element by its complex conjugate.
16564 @pindex calc-argument
16566 The @kbd{G} (@code{calc-argument}) [@code{arg}] command computes the
16567 ``argument'' or polar angle of a complex number. For a number in polar
16568 notation, this is simply the second component of the pair
16569 @texline `@tfn{(}@var{r}@tfn{;}@math{\theta}@tfn{)}'.
16570 @infoline `@tfn{(}@var{r}@tfn{;}@var{theta}@tfn{)}'.
16571 The result is expressed according to the current angular mode and will
16572 be in the range @mathit{-180} degrees (exclusive) to @mathit{+180} degrees
16573 (inclusive), or the equivalent range in radians.
16575 @pindex calc-imaginary
16576 The @code{calc-imaginary} command multiplies the number on the
16577 top of the stack by the imaginary number @expr{i = (0,1)}. This
16578 command is not normally bound to a key in Calc, but it is available
16579 on the @key{IMAG} button in Keypad mode.
16584 The @kbd{f r} (@code{calc-re}) [@code{re}] command replaces a complex number
16585 by its real part. This command has no effect on real numbers. (As an
16586 added convenience, @code{re} applied to a modulo form extracts
16592 The @kbd{f i} (@code{calc-im}) [@code{im}] command replaces a complex number
16593 by its imaginary part; real numbers are converted to zero. With a vector
16594 or matrix argument, these functions operate element-wise.
16599 @kindex v p (complex)
16600 @kindex V p (complex)
16602 The @kbd{v p} (@code{calc-pack}) command can pack the top two numbers on
16603 the stack into a composite object such as a complex number. With
16604 a prefix argument of @mathit{-1}, it produces a rectangular complex number;
16605 with an argument of @mathit{-2}, it produces a polar complex number.
16606 (Also, @pxref{Building Vectors}.)
16611 @kindex v u (complex)
16612 @kindex V u (complex)
16613 @pindex calc-unpack
16614 The @kbd{v u} (@code{calc-unpack}) command takes the complex number
16615 (or other composite object) on the top of the stack and unpacks it
16616 into its separate components.
16618 @node Conversions, Date Arithmetic, Complex Number Functions, Arithmetic
16619 @section Conversions
16622 The commands described in this section convert numbers from one form
16623 to another; they are two-key sequences beginning with the letter @kbd{c}.
16628 The @kbd{c f} (@code{calc-float}) [@code{pfloat}] command converts the
16629 number on the top of the stack to floating-point form. For example,
16630 @expr{23} is converted to @expr{23.0}, @expr{3:2} is converted to
16631 @expr{1.5}, and @expr{2.3} is left the same. If the value is a composite
16632 object such as a complex number or vector, each of the components is
16633 converted to floating-point. If the value is a formula, all numbers
16634 in the formula are converted to floating-point. Note that depending
16635 on the current floating-point precision, conversion to floating-point
16636 format may lose information.
16638 As a special exception, integers which appear as powers or subscripts
16639 are not floated by @kbd{c f}. If you really want to float a power,
16640 you can use a @kbd{j s} command to select the power followed by @kbd{c f}.
16641 Because @kbd{c f} cannot examine the formula outside of the selection,
16642 it does not notice that the thing being floated is a power.
16643 @xref{Selecting Subformulas}.
16645 The normal @kbd{c f} command is ``pervasive'' in the sense that it
16646 applies to all numbers throughout the formula. The @code{pfloat}
16647 algebraic function never stays around in a formula; @samp{pfloat(a + 1)}
16648 changes to @samp{a + 1.0} as soon as it is evaluated.
16652 With the Hyperbolic flag, @kbd{H c f} [@code{float}] operates
16653 only on the number or vector of numbers at the top level of its
16654 argument. Thus, @samp{float(1)} is 1.0, but @samp{float(a + 1)}
16655 is left unevaluated because its argument is not a number.
16657 You should use @kbd{H c f} if you wish to guarantee that the final
16658 value, once all the variables have been assigned, is a float; you
16659 would use @kbd{c f} if you wish to do the conversion on the numbers
16660 that appear right now.
16663 @pindex calc-fraction
16665 The @kbd{c F} (@code{calc-fraction}) [@code{pfrac}] command converts a
16666 floating-point number into a fractional approximation. By default, it
16667 produces a fraction whose decimal representation is the same as the
16668 input number, to within the current precision. You can also give a
16669 numeric prefix argument to specify a tolerance, either directly, or,
16670 if the prefix argument is zero, by using the number on top of the stack
16671 as the tolerance. If the tolerance is a positive integer, the fraction
16672 is correct to within that many significant figures. If the tolerance is
16673 a non-positive integer, it specifies how many digits fewer than the current
16674 precision to use. If the tolerance is a floating-point number, the
16675 fraction is correct to within that absolute amount.
16679 The @code{pfrac} function is pervasive, like @code{pfloat}.
16680 There is also a non-pervasive version, @kbd{H c F} [@code{frac}],
16681 which is analogous to @kbd{H c f} discussed above.
16684 @pindex calc-to-degrees
16686 The @kbd{c d} (@code{calc-to-degrees}) [@code{deg}] command converts a
16687 number into degrees form. The value on the top of the stack may be an
16688 HMS form (interpreted as degrees-minutes-seconds), or a real number which
16689 will be interpreted in radians regardless of the current angular mode.
16692 @pindex calc-to-radians
16694 The @kbd{c r} (@code{calc-to-radians}) [@code{rad}] command converts an
16695 HMS form or angle in degrees into an angle in radians.
16698 @pindex calc-to-hms
16700 The @kbd{c h} (@code{calc-to-hms}) [@code{hms}] command converts a real
16701 number, interpreted according to the current angular mode, to an HMS
16702 form describing the same angle. In algebraic notation, the @code{hms}
16703 function also accepts three arguments: @samp{hms(@var{h}, @var{m}, @var{s})}.
16704 (The three-argument version is independent of the current angular mode.)
16706 @pindex calc-from-hms
16707 The @code{calc-from-hms} command converts the HMS form on the top of the
16708 stack into a real number according to the current angular mode.
16715 The @kbd{c p} (@code{calc-polar}) command converts the complex number on
16716 the top of the stack from polar to rectangular form, or from rectangular
16717 to polar form, whichever is appropriate. Real numbers are left the same.
16718 This command is equivalent to the @code{rect} or @code{polar}
16719 functions in algebraic formulas, depending on the direction of
16720 conversion. (It uses @code{polar}, except that if the argument is
16721 already a polar complex number, it uses @code{rect} instead. The
16722 @kbd{I c p} command always uses @code{rect}.)
16727 The @kbd{c c} (@code{calc-clean}) [@code{pclean}] command ``cleans'' the
16728 number on the top of the stack. Floating point numbers are re-rounded
16729 according to the current precision. Polar numbers whose angular
16730 components have strayed from the @mathit{-180} to @mathit{+180} degree range
16731 are normalized. (Note that results will be undesirable if the current
16732 angular mode is different from the one under which the number was
16733 produced!) Integers and fractions are generally unaffected by this
16734 operation. Vectors and formulas are cleaned by cleaning each component
16735 number (i.e., pervasively).
16737 If the simplification mode is set below the default level, it is raised
16738 to the default level for the purposes of this command. Thus, @kbd{c c}
16739 applies the default simplifications even if their automatic application
16740 is disabled. @xref{Simplification Modes}.
16742 @cindex Roundoff errors, correcting
16743 A numeric prefix argument to @kbd{c c} sets the floating-point precision
16744 to that value for the duration of the command. A positive prefix (of at
16745 least 3) sets the precision to the specified value; a negative or zero
16746 prefix decreases the precision by the specified amount.
16749 @pindex calc-clean-num
16750 The keystroke sequences @kbd{c 0} through @kbd{c 9} are equivalent
16751 to @kbd{c c} with the corresponding negative prefix argument. If roundoff
16752 errors have changed 2.0 into 1.999999, typing @kbd{c 1} to clip off one
16753 decimal place often conveniently does the trick.
16755 The @kbd{c c} command with a numeric prefix argument, and the @kbd{c 0}
16756 through @kbd{c 9} commands, also ``clip'' very small floating-point
16757 numbers to zero. If the exponent is less than or equal to the negative
16758 of the specified precision, the number is changed to 0.0. For example,
16759 if the current precision is 12, then @kbd{c 2} changes the vector
16760 @samp{[1e-8, 1e-9, 1e-10, 1e-11]} to @samp{[1e-8, 1e-9, 0, 0]}.
16761 Numbers this small generally arise from roundoff noise.
16763 If the numbers you are using really are legitimately this small,
16764 you should avoid using the @kbd{c 0} through @kbd{c 9} commands.
16765 (The plain @kbd{c c} command rounds to the current precision but
16766 does not clip small numbers.)
16768 One more property of @kbd{c 0} through @kbd{c 9}, and of @kbd{c c} with
16769 a prefix argument, is that integer-valued floats are converted to
16770 plain integers, so that @kbd{c 1} on @samp{[1., 1.5, 2., 2.5, 3.]}
16771 produces @samp{[1, 1.5, 2, 2.5, 3]}. This is not done for huge
16772 numbers (@samp{1e100} is technically an integer-valued float, but
16773 you wouldn't want it automatically converted to a 100-digit integer).
16778 With the Hyperbolic flag, @kbd{H c c} and @kbd{H c 0} through @kbd{H c 9}
16779 operate non-pervasively [@code{clean}].
16781 @node Date Arithmetic, Financial Functions, Conversions, Arithmetic
16782 @section Date Arithmetic
16785 @cindex Date arithmetic, additional functions
16786 The commands described in this section perform various conversions
16787 and calculations involving date forms (@pxref{Date Forms}). They
16788 use the @kbd{t} (for time/date) prefix key followed by shifted
16791 The simplest date arithmetic is done using the regular @kbd{+} and @kbd{-}
16792 commands. In particular, adding a number to a date form advances the
16793 date form by a certain number of days; adding an HMS form to a date
16794 form advances the date by a certain amount of time; and subtracting two
16795 date forms produces a difference measured in days. The commands
16796 described here provide additional, more specialized operations on dates.
16798 Many of these commands accept a numeric prefix argument; if you give
16799 plain @kbd{C-u} as the prefix, these commands will instead take the
16800 additional argument from the top of the stack.
16803 * Date Conversions::
16809 @node Date Conversions, Date Functions, Date Arithmetic, Date Arithmetic
16810 @subsection Date Conversions
16816 The @kbd{t D} (@code{calc-date}) [@code{date}] command converts a
16817 date form into a number, measured in days since Jan 1, 1 AD. The
16818 result will be an integer if @var{date} is a pure date form, or a
16819 fraction or float if @var{date} is a date/time form. Or, if its
16820 argument is a number, it converts this number into a date form.
16822 With a numeric prefix argument, @kbd{t D} takes that many objects
16823 (up to six) from the top of the stack and interprets them in one
16824 of the following ways:
16826 The @samp{date(@var{year}, @var{month}, @var{day})} function
16827 builds a pure date form out of the specified year, month, and
16828 day, which must all be integers. @var{Year} is a year number,
16829 such as 1991 (@emph{not} the same as 91!). @var{Month} must be
16830 an integer in the range 1 to 12; @var{day} must be in the range
16831 1 to 31. If the specified month has fewer than 31 days and
16832 @var{day} is too large, the equivalent day in the following
16833 month will be used.
16835 The @samp{date(@var{month}, @var{day})} function builds a
16836 pure date form using the current year, as determined by the
16839 The @samp{date(@var{year}, @var{month}, @var{day}, @var{hms})}
16840 function builds a date/time form using an @var{hms} form.
16842 The @samp{date(@var{year}, @var{month}, @var{day}, @var{hour},
16843 @var{minute}, @var{second})} function builds a date/time form.
16844 @var{hour} should be an integer in the range 0 to 23;
16845 @var{minute} should be an integer in the range 0 to 59;
16846 @var{second} should be any real number in the range @samp{[0 .. 60)}.
16847 The last two arguments default to zero if omitted.
16850 @pindex calc-julian
16852 @cindex Julian day counts, conversions
16853 The @kbd{t J} (@code{calc-julian}) [@code{julian}] command converts
16854 a date form into a Julian day count, which is the number of days
16855 since noon (GMT) on Jan 1, 4713 BC. A pure date is converted to an
16856 integer Julian count representing noon of that day. A date/time form
16857 is converted to an exact floating-point Julian count, adjusted to
16858 interpret the date form in the current time zone but the Julian
16859 day count in Greenwich Mean Time. A numeric prefix argument allows
16860 you to specify the time zone; @pxref{Time Zones}. Use a prefix of
16861 zero to suppress the time zone adjustment. Note that pure date forms
16862 are never time-zone adjusted.
16864 This command can also do the opposite conversion, from a Julian day
16865 count (either an integer day, or a floating-point day and time in
16866 the GMT zone), into a pure date form or a date/time form in the
16867 current or specified time zone.
16870 @pindex calc-unix-time
16872 @cindex Unix time format, conversions
16873 The @kbd{t U} (@code{calc-unix-time}) [@code{unixtime}] command
16874 converts a date form into a Unix time value, which is the number of
16875 seconds since midnight on Jan 1, 1970, or vice-versa. The numeric result
16876 will be an integer if the current precision is 12 or less; for higher
16877 precisions, the result may be a float with (@var{precision}@minus{}12)
16878 digits after the decimal. Just as for @kbd{t J}, the numeric time
16879 is interpreted in the GMT time zone and the date form is interpreted
16880 in the current or specified zone. Some systems use Unix-like
16881 numbering but with the local time zone; give a prefix of zero to
16882 suppress the adjustment if so.
16885 @pindex calc-convert-time-zones
16887 @cindex Time Zones, converting between
16888 The @kbd{t C} (@code{calc-convert-time-zones}) [@code{tzconv}]
16889 command converts a date form from one time zone to another. You
16890 are prompted for each time zone name in turn; you can answer with
16891 any suitable Calc time zone expression (@pxref{Time Zones}).
16892 If you answer either prompt with a blank line, the local time
16893 zone is used for that prompt. You can also answer the first
16894 prompt with @kbd{$} to take the two time zone names from the
16895 stack (and the date to be converted from the third stack level).
16897 @node Date Functions, Business Days, Date Conversions, Date Arithmetic
16898 @subsection Date Functions
16904 The @kbd{t N} (@code{calc-now}) [@code{now}] command pushes the
16905 current date and time on the stack as a date form. The time is
16906 reported in terms of the specified time zone; with no numeric prefix
16907 argument, @kbd{t N} reports for the current time zone.
16910 @pindex calc-date-part
16911 The @kbd{t P} (@code{calc-date-part}) command extracts one part
16912 of a date form. The prefix argument specifies the part; with no
16913 argument, this command prompts for a part code from 1 to 9.
16914 The various part codes are described in the following paragraphs.
16917 The @kbd{M-1 t P} [@code{year}] function extracts the year number
16918 from a date form as an integer, e.g., 1991. This and the
16919 following functions will also accept a real number for an
16920 argument, which is interpreted as a standard Calc day number.
16921 Note that this function will never return zero, since the year
16922 1 BC immediately precedes the year 1 AD.
16925 The @kbd{M-2 t P} [@code{month}] function extracts the month number
16926 from a date form as an integer in the range 1 to 12.
16929 The @kbd{M-3 t P} [@code{day}] function extracts the day number
16930 from a date form as an integer in the range 1 to 31.
16933 The @kbd{M-4 t P} [@code{hour}] function extracts the hour from
16934 a date form as an integer in the range 0 (midnight) to 23. Note
16935 that 24-hour time is always used. This returns zero for a pure
16936 date form. This function (and the following two) also accept
16937 HMS forms as input.
16940 The @kbd{M-5 t P} [@code{minute}] function extracts the minute
16941 from a date form as an integer in the range 0 to 59.
16944 The @kbd{M-6 t P} [@code{second}] function extracts the second
16945 from a date form. If the current precision is 12 or less,
16946 the result is an integer in the range 0 to 59. For higher
16947 precisions, the result may instead be a floating-point number.
16950 The @kbd{M-7 t P} [@code{weekday}] function extracts the weekday
16951 number from a date form as an integer in the range 0 (Sunday)
16955 The @kbd{M-8 t P} [@code{yearday}] function extracts the day-of-year
16956 number from a date form as an integer in the range 1 (January 1)
16957 to 366 (December 31 of a leap year).
16960 The @kbd{M-9 t P} [@code{time}] function extracts the time portion
16961 of a date form as an HMS form. This returns @samp{0@@ 0' 0"}
16962 for a pure date form.
16965 @pindex calc-new-month
16967 The @kbd{t M} (@code{calc-new-month}) [@code{newmonth}] command
16968 computes a new date form that represents the first day of the month
16969 specified by the input date. The result is always a pure date
16970 form; only the year and month numbers of the input are retained.
16971 With a numeric prefix argument @var{n} in the range from 1 to 31,
16972 @kbd{t M} computes the @var{n}th day of the month. (If @var{n}
16973 is greater than the actual number of days in the month, or if
16974 @var{n} is zero, the last day of the month is used.)
16977 @pindex calc-new-year
16979 The @kbd{t Y} (@code{calc-new-year}) [@code{newyear}] command
16980 computes a new pure date form that represents the first day of
16981 the year specified by the input. The month, day, and time
16982 of the input date form are lost. With a numeric prefix argument
16983 @var{n} in the range from 1 to 366, @kbd{t Y} computes the
16984 @var{n}th day of the year (366 is treated as 365 in non-leap
16985 years). A prefix argument of 0 computes the last day of the
16986 year (December 31). A negative prefix argument from @mathit{-1} to
16987 @mathit{-12} computes the first day of the @var{n}th month of the year.
16990 @pindex calc-new-week
16992 The @kbd{t W} (@code{calc-new-week}) [@code{newweek}] command
16993 computes a new pure date form that represents the Sunday on or before
16994 the input date. With a numeric prefix argument, it can be made to
16995 use any day of the week as the starting day; the argument must be in
16996 the range from 0 (Sunday) to 6 (Saturday). This function always
16997 subtracts between 0 and 6 days from the input date.
16999 Here's an example use of @code{newweek}: Find the date of the next
17000 Wednesday after a given date. Using @kbd{M-3 t W} or @samp{newweek(d, 3)}
17001 will give you the @emph{preceding} Wednesday, so @samp{newweek(d+7, 3)}
17002 will give you the following Wednesday. A further look at the definition
17003 of @code{newweek} shows that if the input date is itself a Wednesday,
17004 this formula will return the Wednesday one week in the future. An
17005 exercise for the reader is to modify this formula to yield the same day
17006 if the input is already a Wednesday. Another interesting exercise is
17007 to preserve the time-of-day portion of the input (@code{newweek} resets
17008 the time to midnight; hint:@: how can @code{newweek} be defined in terms
17009 of the @code{weekday} function?).
17015 The @samp{pwday(@var{date})} function (not on any key) computes the
17016 day-of-month number of the Sunday on or before @var{date}. With
17017 two arguments, @samp{pwday(@var{date}, @var{day})} computes the day
17018 number of the Sunday on or before day number @var{day} of the month
17019 specified by @var{date}. The @var{day} must be in the range from
17020 7 to 31; if the day number is greater than the actual number of days
17021 in the month, the true number of days is used instead. Thus
17022 @samp{pwday(@var{date}, 7)} finds the first Sunday of the month, and
17023 @samp{pwday(@var{date}, 31)} finds the last Sunday of the month.
17024 With a third @var{weekday} argument, @code{pwday} can be made to look
17025 for any day of the week instead of Sunday.
17028 @pindex calc-inc-month
17030 The @kbd{t I} (@code{calc-inc-month}) [@code{incmonth}] command
17031 increases a date form by one month, or by an arbitrary number of
17032 months specified by a numeric prefix argument. The time portion,
17033 if any, of the date form stays the same. The day also stays the
17034 same, except that if the new month has fewer days the day
17035 number may be reduced to lie in the valid range. For example,
17036 @samp{incmonth(<Jan 31, 1991>)} produces @samp{<Feb 28, 1991>}.
17037 Because of this, @kbd{t I t I} and @kbd{M-2 t I} do not always give
17038 the same results (@samp{<Mar 28, 1991>} versus @samp{<Mar 31, 1991>}
17045 The @samp{incyear(@var{date}, @var{step})} function increases
17046 a date form by the specified number of years, which may be
17047 any positive or negative integer. Note that @samp{incyear(d, n)}
17048 is equivalent to @w{@samp{incmonth(d, 12*n)}}, but these do not have
17049 simple equivalents in terms of day arithmetic because
17050 months and years have varying lengths. If the @var{step}
17051 argument is omitted, 1 year is assumed. There is no keyboard
17052 command for this function; use @kbd{C-u 12 t I} instead.
17054 There is no @code{newday} function at all because @kbd{F} [@code{floor}]
17055 serves this purpose. Similarly, instead of @code{incday} and
17056 @code{incweek} simply use @expr{d + n} or @expr{d + 7 n}.
17058 @xref{Basic Arithmetic}, for the @kbd{f ]} [@code{incr}] command
17059 which can adjust a date/time form by a certain number of seconds.
17061 @node Business Days, Time Zones, Date Functions, Date Arithmetic
17062 @subsection Business Days
17065 Often time is measured in ``business days'' or ``working days,''
17066 where weekends and holidays are skipped. Calc's normal date
17067 arithmetic functions use calendar days, so that subtracting two
17068 consecutive Mondays will yield a difference of 7 days. By contrast,
17069 subtracting two consecutive Mondays would yield 5 business days
17070 (assuming two-day weekends and the absence of holidays).
17076 @pindex calc-business-days-plus
17077 @pindex calc-business-days-minus
17078 The @kbd{t +} (@code{calc-business-days-plus}) [@code{badd}]
17079 and @kbd{t -} (@code{calc-business-days-minus}) [@code{bsub}]
17080 commands perform arithmetic using business days. For @kbd{t +},
17081 one argument must be a date form and the other must be a real
17082 number (positive or negative). If the number is not an integer,
17083 then a certain amount of time is added as well as a number of
17084 days; for example, adding 0.5 business days to a time in Friday
17085 evening will produce a time in Monday morning. It is also
17086 possible to add an HMS form; adding @samp{12@@ 0' 0"} also adds
17087 half a business day. For @kbd{t -}, the arguments are either a
17088 date form and a number or HMS form, or two date forms, in which
17089 case the result is the number of business days between the two
17092 @cindex @code{Holidays} variable
17094 By default, Calc considers any day that is not a Saturday or
17095 Sunday to be a business day. You can define any number of
17096 additional holidays by editing the variable @code{Holidays}.
17097 (There is an @w{@kbd{s H}} convenience command for editing this
17098 variable.) Initially, @code{Holidays} contains the vector
17099 @samp{[sat, sun]}. Entries in the @code{Holidays} vector may
17100 be any of the following kinds of objects:
17104 Date forms (pure dates, not date/time forms). These specify
17105 particular days which are to be treated as holidays.
17108 Intervals of date forms. These specify a range of days, all of
17109 which are holidays (e.g., Christmas week). @xref{Interval Forms}.
17112 Nested vectors of date forms. Each date form in the vector is
17113 considered to be a holiday.
17116 Any Calc formula which evaluates to one of the above three things.
17117 If the formula involves the variable @expr{y}, it stands for a
17118 yearly repeating holiday; @expr{y} will take on various year
17119 numbers like 1992. For example, @samp{date(y, 12, 25)} specifies
17120 Christmas day, and @samp{newweek(date(y, 11, 7), 4) + 21} specifies
17121 Thanksgiving (which is held on the fourth Thursday of November).
17122 If the formula involves the variable @expr{m}, that variable
17123 takes on month numbers from 1 to 12: @samp{date(y, m, 15)} is
17124 a holiday that takes place on the 15th of every month.
17127 A weekday name, such as @code{sat} or @code{sun}. This is really
17128 a variable whose name is a three-letter, lower-case day name.
17131 An interval of year numbers (integers). This specifies the span of
17132 years over which this holiday list is to be considered valid. Any
17133 business-day arithmetic that goes outside this range will result
17134 in an error message. Use this if you are including an explicit
17135 list of holidays, rather than a formula to generate them, and you
17136 want to make sure you don't accidentally go beyond the last point
17137 where the holidays you entered are complete. If there is no
17138 limiting interval in the @code{Holidays} vector, the default
17139 @samp{[1 .. 2737]} is used. (This is the absolute range of years
17140 for which Calc's business-day algorithms will operate.)
17143 An interval of HMS forms. This specifies the span of hours that
17144 are to be considered one business day. For example, if this
17145 range is @samp{[9@@ 0' 0" .. 17@@ 0' 0"]} (i.e., 9am to 5pm), then
17146 the business day is only eight hours long, so that @kbd{1.5 t +}
17147 on @samp{<4:00pm Fri Dec 13, 1991>} will add one business day and
17148 four business hours to produce @samp{<12:00pm Tue Dec 17, 1991>}.
17149 Likewise, @kbd{t -} will now express differences in time as
17150 fractions of an eight-hour day. Times before 9am will be treated
17151 as 9am by business date arithmetic, and times at or after 5pm will
17152 be treated as 4:59:59pm. If there is no HMS interval in @code{Holidays},
17153 the full 24-hour day @samp{[0@ 0' 0" .. 24@ 0' 0"]} is assumed.
17154 (Regardless of the type of bounds you specify, the interval is
17155 treated as inclusive on the low end and exclusive on the high end,
17156 so that the work day goes from 9am up to, but not including, 5pm.)
17159 If the @code{Holidays} vector is empty, then @kbd{t +} and
17160 @kbd{t -} will act just like @kbd{+} and @kbd{-} because there will
17161 then be no difference between business days and calendar days.
17163 Calc expands the intervals and formulas you give into a complete
17164 list of holidays for internal use. This is done mainly to make
17165 sure it can detect multiple holidays. (For example,
17166 @samp{<Jan 1, 1989>} is both New Year's Day and a Sunday, but
17167 Calc's algorithms take care to count it only once when figuring
17168 the number of holidays between two dates.)
17170 Since the complete list of holidays for all the years from 1 to
17171 2737 would be huge, Calc actually computes only the part of the
17172 list between the smallest and largest years that have been involved
17173 in business-day calculations so far. Normally, you won't have to
17174 worry about this. Keep in mind, however, that if you do one
17175 calculation for 1992, and another for 1792, even if both involve
17176 only a small range of years, Calc will still work out all the
17177 holidays that fall in that 200-year span.
17179 If you add a (positive) number of days to a date form that falls on a
17180 weekend or holiday, the date form is treated as if it were the most
17181 recent business day. (Thus adding one business day to a Friday,
17182 Saturday, or Sunday will all yield the following Monday.) If you
17183 subtract a number of days from a weekend or holiday, the date is
17184 effectively on the following business day. (So subtracting one business
17185 day from Saturday, Sunday, or Monday yields the preceding Friday.) The
17186 difference between two dates one or both of which fall on holidays
17187 equals the number of actual business days between them. These
17188 conventions are consistent in the sense that, if you add @var{n}
17189 business days to any date, the difference between the result and the
17190 original date will come out to @var{n} business days. (It can't be
17191 completely consistent though; a subtraction followed by an addition
17192 might come out a bit differently, since @kbd{t +} is incapable of
17193 producing a date that falls on a weekend or holiday.)
17199 There is a @code{holiday} function, not on any keys, that takes
17200 any date form and returns 1 if that date falls on a weekend or
17201 holiday, as defined in @code{Holidays}, or 0 if the date is a
17204 @node Time Zones, , Business Days, Date Arithmetic
17205 @subsection Time Zones
17209 @cindex Daylight saving time
17210 Time zones and daylight saving time are a complicated business.
17211 The conversions to and from Julian and Unix-style dates automatically
17212 compute the correct time zone and daylight saving adjustment to use,
17213 provided they can figure out this information. This section describes
17214 Calc's time zone adjustment algorithm in detail, in case you want to
17215 do conversions in different time zones or in case Calc's algorithms
17216 can't determine the right correction to use.
17218 Adjustments for time zones and daylight saving time are done by
17219 @kbd{t U}, @kbd{t J}, @kbd{t N}, and @kbd{t C}, but not by any other
17220 commands. In particular, @samp{<may 1 1991> - <apr 1 1991>} evaluates
17221 to exactly 30 days even though there is a daylight-saving
17222 transition in between. This is also true for Julian pure dates:
17223 @samp{julian(<may 1 1991>) - julian(<apr 1 1991>)}. But Julian
17224 and Unix date/times will adjust for daylight saving time: using Calc's
17225 default daylight saving time rule (see the explanation below),
17226 @samp{julian(<12am may 1 1991>) - julian(<12am apr 1 1991>)}
17227 evaluates to @samp{29.95833} (that's 29 days and 23 hours)
17228 because one hour was lost when daylight saving commenced on
17231 In brief, the idiom @samp{julian(@var{date1}) - julian(@var{date2})}
17232 computes the actual number of 24-hour periods between two dates, whereas
17233 @samp{@var{date1} - @var{date2}} computes the number of calendar
17234 days between two dates without taking daylight saving into account.
17236 @pindex calc-time-zone
17241 The @code{calc-time-zone} [@code{tzone}] command converts the time
17242 zone specified by its numeric prefix argument into a number of
17243 seconds difference from Greenwich mean time (GMT). If the argument
17244 is a number, the result is simply that value multiplied by 3600.
17245 Typical arguments for North America are 5 (Eastern) or 8 (Pacific). If
17246 Daylight Saving time is in effect, one hour should be subtracted from
17247 the normal difference.
17249 If you give a prefix of plain @kbd{C-u}, @code{calc-time-zone} (like other
17250 date arithmetic commands that include a time zone argument) takes the
17251 zone argument from the top of the stack. (In the case of @kbd{t J}
17252 and @kbd{t U}, the normal argument is then taken from the second-to-top
17253 stack position.) This allows you to give a non-integer time zone
17254 adjustment. The time-zone argument can also be an HMS form, or
17255 it can be a variable which is a time zone name in upper- or lower-case.
17256 For example @samp{tzone(PST) = tzone(8)} and @samp{tzone(pdt) = tzone(7)}
17257 (for Pacific standard and daylight saving times, respectively).
17259 North American and European time zone names are defined as follows;
17260 note that for each time zone there is one name for standard time,
17261 another for daylight saving time, and a third for ``generalized'' time
17262 in which the daylight saving adjustment is computed from context.
17266 YST PST MST CST EST AST NST GMT WET MET MEZ
17267 9 8 7 6 5 4 3.5 0 -1 -2 -2
17269 YDT PDT MDT CDT EDT ADT NDT BST WETDST METDST MESZ
17270 8 7 6 5 4 3 2.5 -1 -2 -3 -3
17272 YGT PGT MGT CGT EGT AGT NGT BGT WEGT MEGT MEGZ
17273 9/8 8/7 7/6 6/5 5/4 4/3 3.5/2.5 0/-1 -1/-2 -2/-3 -2/-3
17277 @vindex math-tzone-names
17278 To define time zone names that do not appear in the above table,
17279 you must modify the Lisp variable @code{math-tzone-names}. This
17280 is a list of lists describing the different time zone names; its
17281 structure is best explained by an example. The three entries for
17282 Pacific Time look like this:
17286 ( ( "PST" 8 0 ) ; Name as an upper-case string, then standard
17287 ( "PDT" 8 -1 ) ; adjustment, then daylight saving adjustment.
17288 ( "PGT" 8 "PST" "PDT" ) ) ; Generalized time zone.
17292 @cindex @code{TimeZone} variable
17294 With no arguments, @code{calc-time-zone} or @samp{tzone()} will by
17295 default get the time zone and daylight saving information from the
17296 calendar (@pxref{Daylight Saving,Calendar/Diary,The Calendar and the Diary,
17297 emacs,The GNU Emacs Manual}). To use a different time zone, or if the
17298 calendar does not give the desired result, you can set the Calc variable
17299 @code{TimeZone} (which is by default @code{nil}) to an appropriate
17300 time zone name. (The easiest way to do this is to edit the
17301 @code{TimeZone} variable using Calc's @kbd{s T} command, then use the
17302 @kbd{s p} (@code{calc-permanent-variable}) command to save the value of
17303 @code{TimeZone} permanently.)
17304 If the time zone given by @code{TimeZone} is a generalized time zone,
17305 e.g., @code{EGT}, Calc examines the date being converted to tell whether
17306 to use standard or daylight saving time. But if the current time zone
17307 is explicit, e.g., @code{EST} or @code{EDT}, then that adjustment is
17308 used exactly and Calc's daylight saving algorithm is not consulted.
17309 The special time zone name @code{local}
17310 is equivalent to no argument; i.e., it uses the information obtained
17313 The @kbd{t J} and @code{t U} commands with no numeric prefix
17314 arguments do the same thing as @samp{tzone()}; namely, use the
17315 information from the calendar if @code{TimeZone} is @code{nil},
17316 otherwise use the time zone given by @code{TimeZone}.
17318 @vindex math-daylight-savings-hook
17319 @findex math-std-daylight-savings
17320 When Calc computes the daylight saving information itself (i.e., when
17321 the @code{TimeZone} variable is set), it will by default consider
17322 daylight saving time to begin at 2 a.m.@: on the second Sunday of March
17323 (for years from 2007 on) or on the last Sunday in April (for years
17324 before 2007), and to end at 2 a.m.@: on the first Sunday of
17325 November. (for years from 2007 on) or the last Sunday in October (for
17326 years before 2007). These are the rules that have been in effect in
17327 much of North America since 1966 and take into account the rule change
17328 that began in 2007. If you are in a country that uses different rules
17329 for computing daylight saving time, you have two choices: Write your own
17330 daylight saving hook, or control time zones explicitly by setting the
17331 @code{TimeZone} variable and/or always giving a time-zone argument for
17332 the conversion functions.
17334 The Lisp variable @code{math-daylight-savings-hook} holds the
17335 name of a function that is used to compute the daylight saving
17336 adjustment for a given date. The default is
17337 @code{math-std-daylight-savings}, which computes an adjustment
17338 (either 0 or @mathit{-1}) using the North American rules given above.
17340 The daylight saving hook function is called with four arguments:
17341 The date, as a floating-point number in standard Calc format;
17342 a six-element list of the date decomposed into year, month, day,
17343 hour, minute, and second, respectively; a string which contains
17344 the generalized time zone name in upper-case, e.g., @code{"WEGT"};
17345 and a special adjustment to be applied to the hour value when
17346 converting into a generalized time zone (see below).
17348 @findex math-prev-weekday-in-month
17349 The Lisp function @code{math-prev-weekday-in-month} is useful for
17350 daylight saving computations. This is an internal version of
17351 the user-level @code{pwday} function described in the previous
17352 section. It takes four arguments: The floating-point date value,
17353 the corresponding six-element date list, the day-of-month number,
17354 and the weekday number (0-6).
17356 The default daylight saving hook ignores the time zone name, but a
17357 more sophisticated hook could use different algorithms for different
17358 time zones. It would also be possible to use different algorithms
17359 depending on the year number, but the default hook always uses the
17360 algorithm for 1987 and later. Here is a listing of the default
17361 daylight saving hook:
17364 (defun math-std-daylight-savings (date dt zone bump)
17365 (cond ((< (nth 1 dt) 4) 0)
17367 (let ((sunday (math-prev-weekday-in-month date dt 7 0)))
17368 (cond ((< (nth 2 dt) sunday) 0)
17369 ((= (nth 2 dt) sunday)
17370 (if (>= (nth 3 dt) (+ 3 bump)) -1 0))
17372 ((< (nth 1 dt) 10) -1)
17374 (let ((sunday (math-prev-weekday-in-month date dt 31 0)))
17375 (cond ((< (nth 2 dt) sunday) -1)
17376 ((= (nth 2 dt) sunday)
17377 (if (>= (nth 3 dt) (+ 2 bump)) 0 -1))
17384 The @code{bump} parameter is equal to zero when Calc is converting
17385 from a date form in a generalized time zone into a GMT date value.
17386 It is @mathit{-1} when Calc is converting in the other direction. The
17387 adjustments shown above ensure that the conversion behaves correctly
17388 and reasonably around the 2 a.m.@: transition in each direction.
17390 There is a ``missing'' hour between 2 a.m.@: and 3 a.m.@: at the
17391 beginning of daylight saving time; converting a date/time form that
17392 falls in this hour results in a time value for the following hour,
17393 from 3 a.m.@: to 4 a.m. At the end of daylight saving time, the
17394 hour from 1 a.m.@: to 2 a.m.@: repeats itself; converting a date/time
17395 form that falls in this hour results in a time value for the first
17396 manifestation of that time (@emph{not} the one that occurs one hour
17399 If @code{math-daylight-savings-hook} is @code{nil}, then the
17400 daylight saving adjustment is always taken to be zero.
17402 In algebraic formulas, @samp{tzone(@var{zone}, @var{date})}
17403 computes the time zone adjustment for a given zone name at a
17404 given date. The @var{date} is ignored unless @var{zone} is a
17405 generalized time zone. If @var{date} is a date form, the
17406 daylight saving computation is applied to it as it appears.
17407 If @var{date} is a numeric date value, it is adjusted for the
17408 daylight-saving version of @var{zone} before being given to
17409 the daylight saving hook. This odd-sounding rule ensures
17410 that the daylight-saving computation is always done in
17411 local time, not in the GMT time that a numeric @var{date}
17412 is typically represented in.
17418 The @samp{dsadj(@var{date}, @var{zone})} function computes the
17419 daylight saving adjustment that is appropriate for @var{date} in
17420 time zone @var{zone}. If @var{zone} is explicitly in or not in
17421 daylight saving time (e.g., @code{PDT} or @code{PST}) the
17422 @var{date} is ignored. If @var{zone} is a generalized time zone,
17423 the algorithms described above are used. If @var{zone} is omitted,
17424 the computation is done for the current time zone.
17426 @node Financial Functions, Binary Functions, Date Arithmetic, Arithmetic
17427 @section Financial Functions
17430 Calc's financial or business functions use the @kbd{b} prefix
17431 key followed by a shifted letter. (The @kbd{b} prefix followed by
17432 a lower-case letter is used for operations on binary numbers.)
17434 Note that the rate and the number of intervals given to these
17435 functions must be on the same time scale, e.g., both months or
17436 both years. Mixing an annual interest rate with a time expressed
17437 in months will give you very wrong answers!
17439 It is wise to compute these functions to a higher precision than
17440 you really need, just to make sure your answer is correct to the
17441 last penny; also, you may wish to check the definitions at the end
17442 of this section to make sure the functions have the meaning you expect.
17448 * Related Financial Functions::
17449 * Depreciation Functions::
17450 * Definitions of Financial Functions::
17453 @node Percentages, Future Value, Financial Functions, Financial Functions
17454 @subsection Percentages
17457 @pindex calc-percent
17460 The @kbd{M-%} (@code{calc-percent}) command takes a percentage value,
17461 say 5.4, and converts it to an equivalent actual number. For example,
17462 @kbd{5.4 M-%} enters 0.054 on the stack. (That's the @key{META} or
17463 @key{ESC} key combined with @kbd{%}.)
17465 Actually, @kbd{M-%} creates a formula of the form @samp{5.4%}.
17466 You can enter @samp{5.4%} yourself during algebraic entry. The
17467 @samp{%} operator simply means, ``the preceding value divided by
17468 100.'' The @samp{%} operator has very high precedence, so that
17469 @samp{1+8%} is interpreted as @samp{1+(8%)}, not as @samp{(1+8)%}.
17470 (The @samp{%} operator is just a postfix notation for the
17471 @code{percent} function, just like @samp{20!} is the notation for
17472 @samp{fact(20)}, or twenty-factorial.)
17474 The formula @samp{5.4%} would normally evaluate immediately to
17475 0.054, but the @kbd{M-%} command suppresses evaluation as it puts
17476 the formula onto the stack. However, the next Calc command that
17477 uses the formula @samp{5.4%} will evaluate it as its first step.
17478 The net effect is that you get to look at @samp{5.4%} on the stack,
17479 but Calc commands see it as @samp{0.054}, which is what they expect.
17481 In particular, @samp{5.4%} and @samp{0.054} are suitable values
17482 for the @var{rate} arguments of the various financial functions,
17483 but the number @samp{5.4} is probably @emph{not} suitable---it
17484 represents a rate of 540 percent!
17486 The key sequence @kbd{M-% *} effectively means ``percent-of.''
17487 For example, @kbd{68 @key{RET} 25 M-% *} computes 17, which is 25% of
17488 68 (and also 68% of 25, which comes out to the same thing).
17491 @pindex calc-convert-percent
17492 The @kbd{c %} (@code{calc-convert-percent}) command converts the
17493 value on the top of the stack from numeric to percentage form.
17494 For example, if 0.08 is on the stack, @kbd{c %} converts it to
17495 @samp{8%}. The quantity is the same, it's just represented
17496 differently. (Contrast this with @kbd{M-%}, which would convert
17497 this number to @samp{0.08%}.) The @kbd{=} key is a convenient way
17498 to convert a formula like @samp{8%} back to numeric form, 0.08.
17500 To compute what percentage one quantity is of another quantity,
17501 use @kbd{/ c %}. For example, @w{@kbd{17 @key{RET} 68 / c %}} displays
17505 @pindex calc-percent-change
17507 The @kbd{b %} (@code{calc-percent-change}) [@code{relch}] command
17508 calculates the percentage change from one number to another.
17509 For example, @kbd{40 @key{RET} 50 b %} produces the answer @samp{25%},
17510 since 50 is 25% larger than 40. A negative result represents a
17511 decrease: @kbd{50 @key{RET} 40 b %} produces @samp{-20%}, since 40 is
17512 20% smaller than 50. (The answers are different in magnitude
17513 because, in the first case, we're increasing by 25% of 40, but
17514 in the second case, we're decreasing by 20% of 50.) The effect
17515 of @kbd{40 @key{RET} 50 b %} is to compute @expr{(50-40)/40}, converting
17516 the answer to percentage form as if by @kbd{c %}.
17518 @node Future Value, Present Value, Percentages, Financial Functions
17519 @subsection Future Value
17523 @pindex calc-fin-fv
17525 The @kbd{b F} (@code{calc-fin-fv}) [@code{fv}] command computes
17526 the future value of an investment. It takes three arguments
17527 from the stack: @samp{fv(@var{rate}, @var{n}, @var{payment})}.
17528 If you give payments of @var{payment} every year for @var{n}
17529 years, and the money you have paid earns interest at @var{rate} per
17530 year, then this function tells you what your investment would be
17531 worth at the end of the period. (The actual interval doesn't
17532 have to be years, as long as @var{n} and @var{rate} are expressed
17533 in terms of the same intervals.) This function assumes payments
17534 occur at the @emph{end} of each interval.
17538 The @kbd{I b F} [@code{fvb}] command does the same computation,
17539 but assuming your payments are at the beginning of each interval.
17540 Suppose you plan to deposit $1000 per year in a savings account
17541 earning 5.4% interest, starting right now. How much will be
17542 in the account after five years? @code{fvb(5.4%, 5, 1000) = 5870.73}.
17543 Thus you will have earned $870 worth of interest over the years.
17544 Using the stack, this calculation would have been
17545 @kbd{5.4 M-% 5 @key{RET} 1000 I b F}. Note that the rate is expressed
17546 as a number between 0 and 1, @emph{not} as a percentage.
17550 The @kbd{H b F} [@code{fvl}] command computes the future value
17551 of an initial lump sum investment. Suppose you could deposit
17552 those five thousand dollars in the bank right now; how much would
17553 they be worth in five years? @code{fvl(5.4%, 5, 5000) = 6503.89}.
17555 The algebraic functions @code{fv} and @code{fvb} accept an optional
17556 fourth argument, which is used as an initial lump sum in the sense
17557 of @code{fvl}. In other words, @code{fv(@var{rate}, @var{n},
17558 @var{payment}, @var{initial}) = fv(@var{rate}, @var{n}, @var{payment})
17559 + fvl(@var{rate}, @var{n}, @var{initial})}.
17561 To illustrate the relationships between these functions, we could
17562 do the @code{fvb} calculation ``by hand'' using @code{fvl}. The
17563 final balance will be the sum of the contributions of our five
17564 deposits at various times. The first deposit earns interest for
17565 five years: @code{fvl(5.4%, 5, 1000) = 1300.78}. The second
17566 deposit only earns interest for four years: @code{fvl(5.4%, 4, 1000) =
17567 1234.13}. And so on down to the last deposit, which earns one
17568 year's interest: @code{fvl(5.4%, 1, 1000) = 1054.00}. The sum of
17569 these five values is, sure enough, $5870.73, just as was computed
17570 by @code{fvb} directly.
17572 What does @code{fv(5.4%, 5, 1000) = 5569.96} mean? The payments
17573 are now at the ends of the periods. The end of one year is the same
17574 as the beginning of the next, so what this really means is that we've
17575 lost the payment at year zero (which contributed $1300.78), but we're
17576 now counting the payment at year five (which, since it didn't have
17577 a chance to earn interest, counts as $1000). Indeed, @expr{5569.96 =
17578 5870.73 - 1300.78 + 1000} (give or take a bit of roundoff error).
17580 @node Present Value, Related Financial Functions, Future Value, Financial Functions
17581 @subsection Present Value
17585 @pindex calc-fin-pv
17587 The @kbd{b P} (@code{calc-fin-pv}) [@code{pv}] command computes
17588 the present value of an investment. Like @code{fv}, it takes
17589 three arguments: @code{pv(@var{rate}, @var{n}, @var{payment})}.
17590 It computes the present value of a series of regular payments.
17591 Suppose you have the chance to make an investment that will
17592 pay $2000 per year over the next four years; as you receive
17593 these payments you can put them in the bank at 9% interest.
17594 You want to know whether it is better to make the investment, or
17595 to keep the money in the bank where it earns 9% interest right
17596 from the start. The calculation @code{pv(9%, 4, 2000)} gives the
17597 result 6479.44. If your initial investment must be less than this,
17598 say, $6000, then the investment is worthwhile. But if you had to
17599 put up $7000, then it would be better just to leave it in the bank.
17601 Here is the interpretation of the result of @code{pv}: You are
17602 trying to compare the return from the investment you are
17603 considering, which is @code{fv(9%, 4, 2000) = 9146.26}, with
17604 the return from leaving the money in the bank, which is
17605 @code{fvl(9%, 4, @var{x})} where @var{x} is the amount of money
17606 you would have to put up in advance. The @code{pv} function
17607 finds the break-even point, @expr{x = 6479.44}, at which
17608 @code{fvl(9%, 4, 6479.44)} is also equal to 9146.26. This is
17609 the largest amount you should be willing to invest.
17613 The @kbd{I b P} [@code{pvb}] command solves the same problem,
17614 but with payments occurring at the beginning of each interval.
17615 It has the same relationship to @code{fvb} as @code{pv} has
17616 to @code{fv}. For example @code{pvb(9%, 4, 2000) = 7062.59},
17617 a larger number than @code{pv} produced because we get to start
17618 earning interest on the return from our investment sooner.
17622 The @kbd{H b P} [@code{pvl}] command computes the present value of
17623 an investment that will pay off in one lump sum at the end of the
17624 period. For example, if we get our $8000 all at the end of the
17625 four years, @code{pvl(9%, 4, 8000) = 5667.40}. This is much
17626 less than @code{pv} reported, because we don't earn any interest
17627 on the return from this investment. Note that @code{pvl} and
17628 @code{fvl} are simple inverses: @code{fvl(9%, 4, 5667.40) = 8000}.
17630 You can give an optional fourth lump-sum argument to @code{pv}
17631 and @code{pvb}; this is handled in exactly the same way as the
17632 fourth argument for @code{fv} and @code{fvb}.
17635 @pindex calc-fin-npv
17637 The @kbd{b N} (@code{calc-fin-npv}) [@code{npv}] command computes
17638 the net present value of a series of irregular investments.
17639 The first argument is the interest rate. The second argument is
17640 a vector which represents the expected return from the investment
17641 at the end of each interval. For example, if the rate represents
17642 a yearly interest rate, then the vector elements are the return
17643 from the first year, second year, and so on.
17645 Thus, @code{npv(9%, [2000,2000,2000,2000]) = pv(9%, 4, 2000) = 6479.44}.
17646 Obviously this function is more interesting when the payments are
17649 The @code{npv} function can actually have two or more arguments.
17650 Multiple arguments are interpreted in the same way as for the
17651 vector statistical functions like @code{vsum}.
17652 @xref{Single-Variable Statistics}. Basically, if there are several
17653 payment arguments, each either a vector or a plain number, all these
17654 values are collected left-to-right into the complete list of payments.
17655 A numeric prefix argument on the @kbd{b N} command says how many
17656 payment values or vectors to take from the stack.
17660 The @kbd{I b N} [@code{npvb}] command computes the net present
17661 value where payments occur at the beginning of each interval
17662 rather than at the end.
17664 @node Related Financial Functions, Depreciation Functions, Present Value, Financial Functions
17665 @subsection Related Financial Functions
17668 The functions in this section are basically inverses of the
17669 present value functions with respect to the various arguments.
17672 @pindex calc-fin-pmt
17674 The @kbd{b M} (@code{calc-fin-pmt}) [@code{pmt}] command computes
17675 the amount of periodic payment necessary to amortize a loan.
17676 Thus @code{pmt(@var{rate}, @var{n}, @var{amount})} equals the
17677 value of @var{payment} such that @code{pv(@var{rate}, @var{n},
17678 @var{payment}) = @var{amount}}.
17682 The @kbd{I b M} [@code{pmtb}] command does the same computation
17683 but using @code{pvb} instead of @code{pv}. Like @code{pv} and
17684 @code{pvb}, these functions can also take a fourth argument which
17685 represents an initial lump-sum investment.
17688 The @kbd{H b M} key just invokes the @code{fvl} function, which is
17689 the inverse of @code{pvl}. There is no explicit @code{pmtl} function.
17692 @pindex calc-fin-nper
17694 The @kbd{b #} (@code{calc-fin-nper}) [@code{nper}] command computes
17695 the number of regular payments necessary to amortize a loan.
17696 Thus @code{nper(@var{rate}, @var{payment}, @var{amount})} equals
17697 the value of @var{n} such that @code{pv(@var{rate}, @var{n},
17698 @var{payment}) = @var{amount}}. If @var{payment} is too small
17699 ever to amortize a loan for @var{amount} at interest rate @var{rate},
17700 the @code{nper} function is left in symbolic form.
17704 The @kbd{I b #} [@code{nperb}] command does the same computation
17705 but using @code{pvb} instead of @code{pv}. You can give a fourth
17706 lump-sum argument to these functions, but the computation will be
17707 rather slow in the four-argument case.
17711 The @kbd{H b #} [@code{nperl}] command does the same computation
17712 using @code{pvl}. By exchanging @var{payment} and @var{amount} you
17713 can also get the solution for @code{fvl}. For example,
17714 @code{nperl(8%, 2000, 1000) = 9.006}, so if you place $1000 in a
17715 bank account earning 8%, it will take nine years to grow to $2000.
17718 @pindex calc-fin-rate
17720 The @kbd{b T} (@code{calc-fin-rate}) [@code{rate}] command computes
17721 the rate of return on an investment. This is also an inverse of @code{pv}:
17722 @code{rate(@var{n}, @var{payment}, @var{amount})} computes the value of
17723 @var{rate} such that @code{pv(@var{rate}, @var{n}, @var{payment}) =
17724 @var{amount}}. The result is expressed as a formula like @samp{6.3%}.
17730 The @kbd{I b T} [@code{rateb}] and @kbd{H b T} [@code{ratel}]
17731 commands solve the analogous equations with @code{pvb} or @code{pvl}
17732 in place of @code{pv}. Also, @code{rate} and @code{rateb} can
17733 accept an optional fourth argument just like @code{pv} and @code{pvb}.
17734 To redo the above example from a different perspective,
17735 @code{ratel(9, 2000, 1000) = 8.00597%}, which says you will need an
17736 interest rate of 8% in order to double your account in nine years.
17739 @pindex calc-fin-irr
17741 The @kbd{b I} (@code{calc-fin-irr}) [@code{irr}] command is the
17742 analogous function to @code{rate} but for net present value.
17743 Its argument is a vector of payments. Thus @code{irr(@var{payments})}
17744 computes the @var{rate} such that @code{npv(@var{rate}, @var{payments}) = 0};
17745 this rate is known as the @dfn{internal rate of return}.
17749 The @kbd{I b I} [@code{irrb}] command computes the internal rate of
17750 return assuming payments occur at the beginning of each period.
17752 @node Depreciation Functions, Definitions of Financial Functions, Related Financial Functions, Financial Functions
17753 @subsection Depreciation Functions
17756 The functions in this section calculate @dfn{depreciation}, which is
17757 the amount of value that a possession loses over time. These functions
17758 are characterized by three parameters: @var{cost}, the original cost
17759 of the asset; @var{salvage}, the value the asset will have at the end
17760 of its expected ``useful life''; and @var{life}, the number of years
17761 (or other periods) of the expected useful life.
17763 There are several methods for calculating depreciation that differ in
17764 the way they spread the depreciation over the lifetime of the asset.
17767 @pindex calc-fin-sln
17769 The @kbd{b S} (@code{calc-fin-sln}) [@code{sln}] command computes the
17770 ``straight-line'' depreciation. In this method, the asset depreciates
17771 by the same amount every year (or period). For example,
17772 @samp{sln(12000, 2000, 5)} returns 2000. The asset costs $12000
17773 initially and will be worth $2000 after five years; it loses $2000
17777 @pindex calc-fin-syd
17779 The @kbd{b Y} (@code{calc-fin-syd}) [@code{syd}] command computes the
17780 accelerated ``sum-of-years'-digits'' depreciation. Here the depreciation
17781 is higher during the early years of the asset's life. Since the
17782 depreciation is different each year, @kbd{b Y} takes a fourth @var{period}
17783 parameter which specifies which year is requested, from 1 to @var{life}.
17784 If @var{period} is outside this range, the @code{syd} function will
17788 @pindex calc-fin-ddb
17790 The @kbd{b D} (@code{calc-fin-ddb}) [@code{ddb}] command computes an
17791 accelerated depreciation using the double-declining balance method.
17792 It also takes a fourth @var{period} parameter.
17794 For symmetry, the @code{sln} function will accept a @var{period}
17795 parameter as well, although it will ignore its value except that the
17796 return value will as usual be zero if @var{period} is out of range.
17798 For example, pushing the vector @expr{[1,2,3,4,5]} (perhaps with @kbd{v x 5})
17799 and then mapping @kbd{V M ' [sln(12000,2000,5,$), syd(12000,2000,5,$),
17800 ddb(12000,2000,5,$)] @key{RET}} produces a matrix that allows us to compare
17801 the three depreciation methods:
17805 [ [ 2000, 3333, 4800 ]
17806 [ 2000, 2667, 2880 ]
17807 [ 2000, 2000, 1728 ]
17808 [ 2000, 1333, 592 ]
17814 (Values have been rounded to nearest integers in this figure.)
17815 We see that @code{sln} depreciates by the same amount each year,
17816 @kbd{syd} depreciates more at the beginning and less at the end,
17817 and @kbd{ddb} weights the depreciation even more toward the beginning.
17819 Summing columns with @kbd{V R : +} yields @expr{[10000, 10000, 10000]};
17820 the total depreciation in any method is (by definition) the
17821 difference between the cost and the salvage value.
17823 @node Definitions of Financial Functions, , Depreciation Functions, Financial Functions
17824 @subsection Definitions
17827 For your reference, here are the actual formulas used to compute
17828 Calc's financial functions.
17830 Calc will not evaluate a financial function unless the @var{rate} or
17831 @var{n} argument is known. However, @var{payment} or @var{amount} can
17832 be a variable. Calc expands these functions according to the
17833 formulas below for symbolic arguments only when you use the @kbd{a "}
17834 (@code{calc-expand-formula}) command, or when taking derivatives or
17835 integrals or solving equations involving the functions.
17838 These formulas are shown using the conventions of Big display
17839 mode (@kbd{d B}); for example, the formula for @code{fv} written
17840 linearly is @samp{pmt * ((1 + rate)^n) - 1) / rate}.
17845 fv(rate, n, pmt) = pmt * ---------------
17849 ((1 + rate) - 1) (1 + rate)
17850 fvb(rate, n, pmt) = pmt * ----------------------------
17854 fvl(rate, n, pmt) = pmt * (1 + rate)
17858 pv(rate, n, pmt) = pmt * ----------------
17862 (1 - (1 + rate) ) (1 + rate)
17863 pvb(rate, n, pmt) = pmt * -----------------------------
17867 pvl(rate, n, pmt) = pmt * (1 + rate)
17870 npv(rate, [a, b, c]) = a*(1 + rate) + b*(1 + rate) + c*(1 + rate)
17873 npvb(rate, [a, b, c]) = a + b*(1 + rate) + c*(1 + rate)
17876 (amt - x * (1 + rate) ) * rate
17877 pmt(rate, n, amt, x) = -------------------------------
17882 (amt - x * (1 + rate) ) * rate
17883 pmtb(rate, n, amt, x) = -------------------------------
17885 (1 - (1 + rate) ) (1 + rate)
17888 nper(rate, pmt, amt) = - log(1 - ------------, 1 + rate)
17892 nperb(rate, pmt, amt) = - log(1 - ---------------, 1 + rate)
17896 nperl(rate, pmt, amt) = - log(---, 1 + rate)
17901 ratel(n, pmt, amt) = ------ - 1
17906 sln(cost, salv, life) = -----------
17909 (cost - salv) * (life - per + 1)
17910 syd(cost, salv, life, per) = --------------------------------
17911 life * (life + 1) / 2
17914 ddb(cost, salv, life, per) = --------, book = cost - depreciation so far
17919 $$ \code{fv}(r, n, p) = p { (1 + r)^n - 1 \over r } $$
17920 $$ \code{fvb}(r, n, p) = p { ((1 + r)^n - 1) (1 + r) \over r } $$
17921 $$ \code{fvl}(r, n, p) = p (1 + r)^n $$
17922 $$ \code{pv}(r, n, p) = p { 1 - (1 + r)^{-n} \over r } $$
17923 $$ \code{pvb}(r, n, p) = p { (1 - (1 + r)^{-n}) (1 + r) \over r } $$
17924 $$ \code{pvl}(r, n, p) = p (1 + r)^{-n} $$
17925 $$ \code{npv}(r, [a,b,c]) = a (1 + r)^{-1} + b (1 + r)^{-2} + c (1 + r)^{-3} $$
17926 $$ \code{npvb}(r, [a,b,c]) = a + b (1 + r)^{-1} + c (1 + r)^{-2} $$
17927 $$ \code{pmt}(r, n, a, x) = { (a - x (1 + r)^{-n}) r \over 1 - (1 + r)^{-n} }$$
17928 $$ \code{pmtb}(r, n, a, x) = { (a - x (1 + r)^{-n}) r \over
17929 (1 - (1 + r)^{-n}) (1 + r) } $$
17930 $$ \code{nper}(r, p, a) = -\code{log}(1 - { a r \over p }, 1 + r) $$
17931 $$ \code{nperb}(r, p, a) = -\code{log}(1 - { a r \over p (1 + r) }, 1 + r) $$
17932 $$ \code{nperl}(r, p, a) = -\code{log}({a \over p}, 1 + r) $$
17933 $$ \code{ratel}(n, p, a) = { p^{1/n} \over a^{1/n} } - 1 $$
17934 $$ \code{sln}(c, s, l) = { c - s \over l } $$
17935 $$ \code{syd}(c, s, l, p) = { (c - s) (l - p + 1) \over l (l+1) / 2 } $$
17936 $$ \code{ddb}(c, s, l, p) = { 2 (c - \hbox{depreciation so far}) \over l } $$
17940 In @code{pmt} and @code{pmtb}, @expr{x=0} if omitted.
17942 These functions accept any numeric objects, including error forms,
17943 intervals, and even (though not very usefully) complex numbers. The
17944 above formulas specify exactly the behavior of these functions with
17945 all sorts of inputs.
17947 Note that if the first argument to the @code{log} in @code{nper} is
17948 negative, @code{nper} leaves itself in symbolic form rather than
17949 returning a (financially meaningless) complex number.
17951 @samp{rate(num, pmt, amt)} solves the equation
17952 @samp{pv(rate, num, pmt) = amt} for @samp{rate} using @kbd{H a R}
17953 (@code{calc-find-root}), with the interval @samp{[.01% .. 100%]}
17954 for an initial guess. The @code{rateb} function is the same except
17955 that it uses @code{pvb}. Note that @code{ratel} can be solved
17956 directly; its formula is shown in the above list.
17958 Similarly, @samp{irr(pmts)} solves the equation @samp{npv(rate, pmts) = 0}
17961 If you give a fourth argument to @code{nper} or @code{nperb}, Calc
17962 will also use @kbd{H a R} to solve the equation using an initial
17963 guess interval of @samp{[0 .. 100]}.
17965 A fourth argument to @code{fv} simply sums the two components
17966 calculated from the above formulas for @code{fv} and @code{fvl}.
17967 The same is true of @code{fvb}, @code{pv}, and @code{pvb}.
17969 The @kbd{ddb} function is computed iteratively; the ``book'' value
17970 starts out equal to @var{cost}, and decreases according to the above
17971 formula for the specified number of periods. If the book value
17972 would decrease below @var{salvage}, it only decreases to @var{salvage}
17973 and the depreciation is zero for all subsequent periods. The @code{ddb}
17974 function returns the amount the book value decreased in the specified
17977 @node Binary Functions, , Financial Functions, Arithmetic
17978 @section Binary Number Functions
17981 The commands in this chapter all use two-letter sequences beginning with
17982 the @kbd{b} prefix.
17984 @cindex Binary numbers
17985 The ``binary'' operations actually work regardless of the currently
17986 displayed radix, although their results make the most sense in a radix
17987 like 2, 8, or 16 (as obtained by the @kbd{d 2}, @kbd{d 8}, or @w{@kbd{d 6}}
17988 commands, respectively). You may also wish to enable display of leading
17989 zeros with @kbd{d z}. @xref{Radix Modes}.
17991 @cindex Word size for binary operations
17992 The Calculator maintains a current @dfn{word size} @expr{w}, an
17993 arbitrary positive or negative integer. For a positive word size, all
17994 of the binary operations described here operate modulo @expr{2^w}. In
17995 particular, negative arguments are converted to positive integers modulo
17996 @expr{2^w} by all binary functions.
17998 If the word size is negative, binary operations produce twos-complement
18000 @texline @math{-2^{-w-1}}
18001 @infoline @expr{-(2^(-w-1))}
18003 @texline @math{2^{-w-1}-1}
18004 @infoline @expr{2^(-w-1)-1}
18005 inclusive. Either mode accepts inputs in any range; the sign of
18006 @expr{w} affects only the results produced.
18011 The @kbd{b c} (@code{calc-clip})
18012 [@code{clip}] command can be used to clip a number by reducing it modulo
18013 @expr{2^w}. The commands described in this chapter automatically clip
18014 their results to the current word size. Note that other operations like
18015 addition do not use the current word size, since integer addition
18016 generally is not ``binary.'' (However, @pxref{Simplification Modes},
18017 @code{calc-bin-simplify-mode}.) For example, with a word size of 8
18018 bits @kbd{b c} converts a number to the range 0 to 255; with a word
18019 size of @mathit{-8} @kbd{b c} converts to the range @mathit{-128} to 127.
18022 @pindex calc-word-size
18023 The default word size is 32 bits. All operations except the shifts and
18024 rotates allow you to specify a different word size for that one
18025 operation by giving a numeric prefix argument: @kbd{C-u 8 b c} clips the
18026 top of stack to the range 0 to 255 regardless of the current word size.
18027 To set the word size permanently, use @kbd{b w} (@code{calc-word-size}).
18028 This command displays a prompt with the current word size; press @key{RET}
18029 immediately to keep this word size, or type a new word size at the prompt.
18031 When the binary operations are written in symbolic form, they take an
18032 optional second (or third) word-size parameter. When a formula like
18033 @samp{and(a,b)} is finally evaluated, the word size current at that time
18034 will be used, but when @samp{and(a,b,-8)} is evaluated, a word size of
18035 @mathit{-8} will always be used. A symbolic binary function will be left
18036 in symbolic form unless the all of its argument(s) are integers or
18037 integer-valued floats.
18039 If either or both arguments are modulo forms for which @expr{M} is a
18040 power of two, that power of two is taken as the word size unless a
18041 numeric prefix argument overrides it. The current word size is never
18042 consulted when modulo-power-of-two forms are involved.
18047 The @kbd{b a} (@code{calc-and}) [@code{and}] command computes the bitwise
18048 AND of the two numbers on the top of the stack. In other words, for each
18049 of the @expr{w} binary digits of the two numbers (pairwise), the corresponding
18050 bit of the result is 1 if and only if both input bits are 1:
18051 @samp{and(2#1100, 2#1010) = 2#1000}.
18056 The @kbd{b o} (@code{calc-or}) [@code{or}] command computes the bitwise
18057 inclusive OR of two numbers. A bit is 1 if either of the input bits, or
18058 both, are 1: @samp{or(2#1100, 2#1010) = 2#1110}.
18063 The @kbd{b x} (@code{calc-xor}) [@code{xor}] command computes the bitwise
18064 exclusive OR of two numbers. A bit is 1 if exactly one of the input bits
18065 is 1: @samp{xor(2#1100, 2#1010) = 2#0110}.
18070 The @kbd{b d} (@code{calc-diff}) [@code{diff}] command computes the bitwise
18071 difference of two numbers; this is defined by @samp{diff(a,b) = and(a,not(b))},
18072 so that @samp{diff(2#1100, 2#1010) = 2#0100}.
18077 The @kbd{b n} (@code{calc-not}) [@code{not}] command computes the bitwise
18078 NOT of a number. A bit is 1 if the input bit is 0 and vice-versa.
18081 @pindex calc-lshift-binary
18083 The @kbd{b l} (@code{calc-lshift-binary}) [@code{lsh}] command shifts a
18084 number left by one bit, or by the number of bits specified in the numeric
18085 prefix argument. A negative prefix argument performs a logical right shift,
18086 in which zeros are shifted in on the left. In symbolic form, @samp{lsh(a)}
18087 is short for @samp{lsh(a,1)}, which in turn is short for @samp{lsh(a,n,w)}.
18088 Bits shifted ``off the end,'' according to the current word size, are lost.
18104 The @kbd{H b l} command also does a left shift, but it takes two arguments
18105 from the stack (the value to shift, and, at top-of-stack, the number of
18106 bits to shift). This version interprets the prefix argument just like
18107 the regular binary operations, i.e., as a word size. The Hyperbolic flag
18108 has a similar effect on the rest of the binary shift and rotate commands.
18111 @pindex calc-rshift-binary
18113 The @kbd{b r} (@code{calc-rshift-binary}) [@code{rsh}] command shifts a
18114 number right by one bit, or by the number of bits specified in the numeric
18115 prefix argument: @samp{rsh(a,n) = lsh(a,-n)}.
18118 @pindex calc-lshift-arith
18120 The @kbd{b L} (@code{calc-lshift-arith}) [@code{ash}] command shifts a
18121 number left. It is analogous to @code{lsh}, except that if the shift
18122 is rightward (the prefix argument is negative), an arithmetic shift
18123 is performed as described below.
18126 @pindex calc-rshift-arith
18128 The @kbd{b R} (@code{calc-rshift-arith}) [@code{rash}] command performs
18129 an ``arithmetic'' shift to the right, in which the leftmost bit (according
18130 to the current word size) is duplicated rather than shifting in zeros.
18131 This corresponds to dividing by a power of two where the input is interpreted
18132 as a signed, twos-complement number. (The distinction between the @samp{rsh}
18133 and @samp{rash} operations is totally independent from whether the word
18134 size is positive or negative.) With a negative prefix argument, this
18135 performs a standard left shift.
18138 @pindex calc-rotate-binary
18140 The @kbd{b t} (@code{calc-rotate-binary}) [@code{rot}] command rotates a
18141 number one bit to the left. The leftmost bit (according to the current
18142 word size) is dropped off the left and shifted in on the right. With a
18143 numeric prefix argument, the number is rotated that many bits to the left
18146 @xref{Set Operations}, for the @kbd{b p} and @kbd{b u} commands that
18147 pack and unpack binary integers into sets. (For example, @kbd{b u}
18148 unpacks the number @samp{2#11001} to the set of bit-numbers
18149 @samp{[0, 3, 4]}.) Type @kbd{b u V #} to count the number of ``1''
18150 bits in a binary integer.
18152 Another interesting use of the set representation of binary integers
18153 is to reverse the bits in, say, a 32-bit integer. Type @kbd{b u} to
18154 unpack; type @kbd{31 @key{TAB} -} to replace each bit-number in the set
18155 with 31 minus that bit-number; type @kbd{b p} to pack the set back
18156 into a binary integer.
18158 @node Scientific Functions, Matrix Functions, Arithmetic, Top
18159 @chapter Scientific Functions
18162 The functions described here perform trigonometric and other transcendental
18163 calculations. They generally produce floating-point answers correct to the
18164 full current precision. The @kbd{H} (Hyperbolic) and @kbd{I} (Inverse)
18165 flag keys must be used to get some of these functions from the keyboard.
18169 @cindex @code{pi} variable
18172 @cindex @code{e} variable
18175 @cindex @code{gamma} variable
18177 @cindex Gamma constant, Euler's
18178 @cindex Euler's gamma constant
18180 @cindex @code{phi} variable
18181 @cindex Phi, golden ratio
18182 @cindex Golden ratio
18183 One miscellaneous command is shift-@kbd{P} (@code{calc-pi}), which pushes
18184 the value of @cpi{} (at the current precision) onto the stack. With the
18185 Hyperbolic flag, it pushes the value @expr{e}, the base of natural logarithms.
18186 With the Inverse flag, it pushes Euler's constant
18187 @texline @math{\gamma}
18188 @infoline @expr{gamma}
18189 (about 0.5772). With both Inverse and Hyperbolic, it
18190 pushes the ``golden ratio''
18191 @texline @math{\phi}
18192 @infoline @expr{phi}
18193 (about 1.618). (At present, Euler's constant is not available
18194 to unlimited precision; Calc knows only the first 100 digits.)
18195 In Symbolic mode, these commands push the
18196 actual variables @samp{pi}, @samp{e}, @samp{gamma}, and @samp{phi},
18197 respectively, instead of their values; @pxref{Symbolic Mode}.
18207 The @kbd{Q} (@code{calc-sqrt}) [@code{sqrt}] function is described elsewhere;
18208 @pxref{Basic Arithmetic}. With the Inverse flag [@code{sqr}], this command
18209 computes the square of the argument.
18211 @xref{Prefix Arguments}, for a discussion of the effect of numeric
18212 prefix arguments on commands in this chapter which do not otherwise
18213 interpret a prefix argument.
18216 * Logarithmic Functions::
18217 * Trigonometric and Hyperbolic Functions::
18218 * Advanced Math Functions::
18221 * Combinatorial Functions::
18222 * Probability Distribution Functions::
18225 @node Logarithmic Functions, Trigonometric and Hyperbolic Functions, Scientific Functions, Scientific Functions
18226 @section Logarithmic Functions
18236 The shift-@kbd{L} (@code{calc-ln}) [@code{ln}] command computes the natural
18237 logarithm of the real or complex number on the top of the stack. With
18238 the Inverse flag it computes the exponential function instead, although
18239 this is redundant with the @kbd{E} command.
18248 The shift-@kbd{E} (@code{calc-exp}) [@code{exp}] command computes the
18249 exponential, i.e., @expr{e} raised to the power of the number on the stack.
18250 The meanings of the Inverse and Hyperbolic flags follow from those for
18251 the @code{calc-ln} command.
18266 The @kbd{H L} (@code{calc-log10}) [@code{log10}] command computes the common
18267 (base-10) logarithm of a number. (With the Inverse flag [@code{exp10}],
18268 it raises ten to a given power.) Note that the common logarithm of a
18269 complex number is computed by taking the natural logarithm and dividing
18271 @texline @math{\ln10}.
18272 @infoline @expr{ln(10)}.
18279 The @kbd{B} (@code{calc-log}) [@code{log}] command computes a logarithm
18280 to any base. For example, @kbd{1024 @key{RET} 2 B} produces 10, since
18281 @texline @math{2^{10} = 1024}.
18282 @infoline @expr{2^10 = 1024}.
18283 In certain cases like @samp{log(3,9)}, the result
18284 will be either @expr{1:2} or @expr{0.5} depending on the current Fraction
18285 mode setting. With the Inverse flag [@code{alog}], this command is
18286 similar to @kbd{^} except that the order of the arguments is reversed.
18291 The @kbd{f I} (@code{calc-ilog}) [@code{ilog}] command computes the
18292 integer logarithm of a number to any base. The number and the base must
18293 themselves be positive integers. This is the true logarithm, rounded
18294 down to an integer. Thus @kbd{ilog(x,10)} is 3 for all @expr{x} in the
18295 range from 1000 to 9999. If both arguments are positive integers, exact
18296 integer arithmetic is used; otherwise, this is equivalent to
18297 @samp{floor(log(x,b))}.
18302 The @kbd{f E} (@code{calc-expm1}) [@code{expm1}] command computes
18303 @texline @math{e^x - 1},
18304 @infoline @expr{exp(x)-1},
18305 but using an algorithm that produces a more accurate
18306 answer when the result is close to zero, i.e., when
18307 @texline @math{e^x}
18308 @infoline @expr{exp(x)}
18314 The @kbd{f L} (@code{calc-lnp1}) [@code{lnp1}] command computes
18315 @texline @math{\ln(x+1)},
18316 @infoline @expr{ln(x+1)},
18317 producing a more accurate answer when @expr{x} is close to zero.
18319 @node Trigonometric and Hyperbolic Functions, Advanced Math Functions, Logarithmic Functions, Scientific Functions
18320 @section Trigonometric/Hyperbolic Functions
18326 The shift-@kbd{S} (@code{calc-sin}) [@code{sin}] command computes the sine
18327 of an angle or complex number. If the input is an HMS form, it is interpreted
18328 as degrees-minutes-seconds; otherwise, the input is interpreted according
18329 to the current angular mode. It is best to use Radians mode when operating
18330 on complex numbers.
18332 Calc's ``units'' mechanism includes angular units like @code{deg},
18333 @code{rad}, and @code{grad}. While @samp{sin(45 deg)} is not evaluated
18334 all the time, the @kbd{u s} (@code{calc-simplify-units}) command will
18335 simplify @samp{sin(45 deg)} by taking the sine of 45 degrees, regardless
18336 of the current angular mode. @xref{Basic Operations on Units}.
18338 Also, the symbolic variable @code{pi} is not ordinarily recognized in
18339 arguments to trigonometric functions, as in @samp{sin(3 pi / 4)}, but
18340 the @kbd{a s} (@code{calc-simplify}) command recognizes many such
18341 formulas when the current angular mode is Radians @emph{and} Symbolic
18342 mode is enabled; this example would be replaced by @samp{sqrt(2) / 2}.
18343 @xref{Symbolic Mode}. Beware, this simplification occurs even if you
18344 have stored a different value in the variable @samp{pi}; this is one
18345 reason why changing built-in variables is a bad idea. Arguments of
18346 the form @expr{x} plus a multiple of @cpiover{2} are also simplified.
18347 Calc includes similar formulas for @code{cos} and @code{tan}.
18349 The @kbd{a s} command knows all angles which are integer multiples of
18350 @cpiover{12}, @cpiover{10}, or @cpiover{8} radians. In Degrees mode,
18351 analogous simplifications occur for integer multiples of 15 or 18
18352 degrees, and for arguments plus multiples of 90 degrees.
18355 @pindex calc-arcsin
18357 With the Inverse flag, @code{calc-sin} computes an arcsine. This is also
18358 available as the @code{calc-arcsin} command or @code{arcsin} algebraic
18359 function. The returned argument is converted to degrees, radians, or HMS
18360 notation depending on the current angular mode.
18366 @pindex calc-arcsinh
18368 With the Hyperbolic flag, @code{calc-sin} computes the hyperbolic
18369 sine, also available as @code{calc-sinh} [@code{sinh}]. With the
18370 Hyperbolic and Inverse flags, it computes the hyperbolic arcsine
18371 (@code{calc-arcsinh}) [@code{arcsinh}].
18380 @pindex calc-arccos
18398 @pindex calc-arccosh
18416 @pindex calc-arctan
18434 @pindex calc-arctanh
18439 The shift-@kbd{C} (@code{calc-cos}) [@code{cos}] command computes the cosine
18440 of an angle or complex number, and shift-@kbd{T} (@code{calc-tan}) [@code{tan}]
18441 computes the tangent, along with all the various inverse and hyperbolic
18442 variants of these functions.
18445 @pindex calc-arctan2
18447 The @kbd{f T} (@code{calc-arctan2}) [@code{arctan2}] command takes two
18448 numbers from the stack and computes the arc tangent of their ratio. The
18449 result is in the full range from @mathit{-180} (exclusive) to @mathit{+180}
18450 (inclusive) degrees, or the analogous range in radians. A similar
18451 result would be obtained with @kbd{/} followed by @kbd{I T}, but the
18452 value would only be in the range from @mathit{-90} to @mathit{+90} degrees
18453 since the division loses information about the signs of the two
18454 components, and an error might result from an explicit division by zero
18455 which @code{arctan2} would avoid. By (arbitrary) definition,
18456 @samp{arctan2(0,0)=0}.
18458 @pindex calc-sincos
18470 The @code{calc-sincos} [@code{sincos}] command computes the sine and
18471 cosine of a number, returning them as a vector of the form
18472 @samp{[@var{cos}, @var{sin}]}.
18473 With the Inverse flag [@code{arcsincos}], this command takes a two-element
18474 vector as an argument and computes @code{arctan2} of the elements.
18475 (This command does not accept the Hyperbolic flag.)
18489 The remaining trigonometric functions, @code{calc-sec} [@code{sec}],
18490 @code{calc-csc} [@code{csc}] and @code{calc-cot} [@code{cot}], are also
18491 available. With the Hyperbolic flag, these compute their hyperbolic
18492 counterparts, which are also available separately as @code{calc-sech}
18493 [@code{sech}], @code{calc-csch} [@code{csch}] and @code{calc-coth}
18494 [@code{coth}]. (These commands do not accept the Inverse flag.)
18496 @node Advanced Math Functions, Branch Cuts, Trigonometric and Hyperbolic Functions, Scientific Functions
18497 @section Advanced Mathematical Functions
18500 Calc can compute a variety of less common functions that arise in
18501 various branches of mathematics. All of the functions described in
18502 this section allow arbitrary complex arguments and, except as noted,
18503 will work to arbitrarily large precisions. They can not at present
18504 handle error forms or intervals as arguments.
18506 NOTE: These functions are still experimental. In particular, their
18507 accuracy is not guaranteed in all domains. It is advisable to set the
18508 current precision comfortably higher than you actually need when
18509 using these functions. Also, these functions may be impractically
18510 slow for some values of the arguments.
18515 The @kbd{f g} (@code{calc-gamma}) [@code{gamma}] command computes the Euler
18516 gamma function. For positive integer arguments, this is related to the
18517 factorial function: @samp{gamma(n+1) = fact(n)}. For general complex
18518 arguments the gamma function can be defined by the following definite
18520 @texline @math{\Gamma(a) = \int_0^\infty t^{a-1} e^t dt}.
18521 @infoline @expr{gamma(a) = integ(t^(a-1) exp(t), t, 0, inf)}.
18522 (The actual implementation uses far more efficient computational methods.)
18538 @pindex calc-inc-gamma
18551 The @kbd{f G} (@code{calc-inc-gamma}) [@code{gammaP}] command computes
18552 the incomplete gamma function, denoted @samp{P(a,x)}. This is defined by
18554 @texline @math{P(a,x) = \left( \int_0^x t^{a-1} e^t dt \right) / \Gamma(a)}.
18555 @infoline @expr{gammaP(a,x) = integ(t^(a-1) exp(t), t, 0, x) / gamma(a)}.
18556 This implies that @samp{gammaP(a,inf) = 1} for any @expr{a} (see the
18557 definition of the normal gamma function).
18559 Several other varieties of incomplete gamma function are defined.
18560 The complement of @expr{P(a,x)}, called @expr{Q(a,x) = 1-P(a,x)} by
18561 some authors, is computed by the @kbd{I f G} [@code{gammaQ}] command.
18562 You can think of this as taking the other half of the integral, from
18563 @expr{x} to infinity.
18566 The functions corresponding to the integrals that define @expr{P(a,x)}
18567 and @expr{Q(a,x)} but without the normalizing @expr{1/gamma(a)}
18568 factor are called @expr{g(a,x)} and @expr{G(a,x)}, respectively
18569 (where @expr{g} and @expr{G} represent the lower- and upper-case Greek
18570 letter gamma). You can obtain these using the @kbd{H f G} [@code{gammag}]
18571 and @kbd{H I f G} [@code{gammaG}] commands.
18574 The functions corresponding to the integrals that define $P(a,x)$
18575 and $Q(a,x)$ but without the normalizing $1/\Gamma(a)$
18576 factor are called $\gamma(a,x)$ and $\Gamma(a,x)$, respectively.
18577 You can obtain these using the \kbd{H f G} [\code{gammag}] and
18578 \kbd{I H f G} [\code{gammaG}] commands.
18584 The @kbd{f b} (@code{calc-beta}) [@code{beta}] command computes the
18585 Euler beta function, which is defined in terms of the gamma function as
18586 @texline @math{B(a,b) = \Gamma(a) \Gamma(b) / \Gamma(a+b)},
18587 @infoline @expr{beta(a,b) = gamma(a) gamma(b) / gamma(a+b)},
18589 @texline @math{B(a,b) = \int_0^1 t^{a-1} (1-t)^{b-1} dt}.
18590 @infoline @expr{beta(a,b) = integ(t^(a-1) (1-t)^(b-1), t, 0, 1)}.
18594 @pindex calc-inc-beta
18597 The @kbd{f B} (@code{calc-inc-beta}) [@code{betaI}] command computes
18598 the incomplete beta function @expr{I(x,a,b)}. It is defined by
18599 @texline @math{I(x,a,b) = \left( \int_0^x t^{a-1} (1-t)^{b-1} dt \right) / B(a,b)}.
18600 @infoline @expr{betaI(x,a,b) = integ(t^(a-1) (1-t)^(b-1), t, 0, x) / beta(a,b)}.
18601 Once again, the @kbd{H} (hyperbolic) prefix gives the corresponding
18602 un-normalized version [@code{betaB}].
18609 The @kbd{f e} (@code{calc-erf}) [@code{erf}] command computes the
18611 @texline @math{\hbox{erf}(x) = {2 \over \sqrt{\pi}} \int_0^x e^{-t^2} dt}.
18612 @infoline @expr{erf(x) = 2 integ(exp(-(t^2)), t, 0, x) / sqrt(pi)}.
18613 The complementary error function @kbd{I f e} (@code{calc-erfc}) [@code{erfc}]
18614 is the corresponding integral from @samp{x} to infinity; the sum
18615 @texline @math{\hbox{erf}(x) + \hbox{erfc}(x) = 1}.
18616 @infoline @expr{erf(x) + erfc(x) = 1}.
18620 @pindex calc-bessel-J
18621 @pindex calc-bessel-Y
18624 The @kbd{f j} (@code{calc-bessel-J}) [@code{besJ}] and @kbd{f y}
18625 (@code{calc-bessel-Y}) [@code{besY}] commands compute the Bessel
18626 functions of the first and second kinds, respectively.
18627 In @samp{besJ(n,x)} and @samp{besY(n,x)} the ``order'' parameter
18628 @expr{n} is often an integer, but is not required to be one.
18629 Calc's implementation of the Bessel functions currently limits the
18630 precision to 8 digits, and may not be exact even to that precision.
18633 @node Branch Cuts, Random Numbers, Advanced Math Functions, Scientific Functions
18634 @section Branch Cuts and Principal Values
18637 @cindex Branch cuts
18638 @cindex Principal values
18639 All of the logarithmic, trigonometric, and other scientific functions are
18640 defined for complex numbers as well as for reals.
18641 This section describes the values
18642 returned in cases where the general result is a family of possible values.
18643 Calc follows section 12.5.3 of Steele's @dfn{Common Lisp, the Language},
18644 second edition, in these matters. This section will describe each
18645 function briefly; for a more detailed discussion (including some nifty
18646 diagrams), consult Steele's book.
18648 Note that the branch cuts for @code{arctan} and @code{arctanh} were
18649 changed between the first and second editions of Steele. Recent
18650 versions of Calc follow the second edition.
18652 The new branch cuts exactly match those of the HP-28/48 calculators.
18653 They also match those of Mathematica 1.2, except that Mathematica's
18654 @code{arctan} cut is always in the right half of the complex plane,
18655 and its @code{arctanh} cut is always in the top half of the plane.
18656 Calc's cuts are continuous with quadrants I and III for @code{arctan},
18657 or II and IV for @code{arctanh}.
18659 Note: The current implementations of these functions with complex arguments
18660 are designed with proper behavior around the branch cuts in mind, @emph{not}
18661 efficiency or accuracy. You may need to increase the floating precision
18662 and wait a while to get suitable answers from them.
18664 For @samp{sqrt(a+bi)}: When @expr{a<0} and @expr{b} is small but positive
18665 or zero, the result is close to the @expr{+i} axis. For @expr{b} small and
18666 negative, the result is close to the @expr{-i} axis. The result always lies
18667 in the right half of the complex plane.
18669 For @samp{ln(a+bi)}: The real part is defined as @samp{ln(abs(a+bi))}.
18670 The imaginary part is defined as @samp{arg(a+bi) = arctan2(b,a)}.
18671 Thus the branch cuts for @code{sqrt} and @code{ln} both lie on the
18672 negative real axis.
18674 The following table describes these branch cuts in another way.
18675 If the real and imaginary parts of @expr{z} are as shown, then
18676 the real and imaginary parts of @expr{f(z)} will be as shown.
18677 Here @code{eps} stands for a small positive value; each
18678 occurrence of @code{eps} may stand for a different small value.
18682 ----------------------------------------
18685 -, +eps +eps, + +eps, +
18686 -, -eps +eps, - +eps, -
18689 For @samp{z1^z2}: This is defined by @samp{exp(ln(z1)*z2)}.
18690 One interesting consequence of this is that @samp{(-8)^1:3} does
18691 not evaluate to @mathit{-2} as you might expect, but to the complex
18692 number @expr{(1., 1.732)}. Both of these are valid cube roots
18693 of @mathit{-8} (as is @expr{(1., -1.732)}); Calc chooses a perhaps
18694 less-obvious root for the sake of mathematical consistency.
18696 For @samp{arcsin(z)}: This is defined by @samp{-i*ln(i*z + sqrt(1-z^2))}.
18697 The branch cuts are on the real axis, less than @mathit{-1} and greater than 1.
18699 For @samp{arccos(z)}: This is defined by @samp{-i*ln(z + i*sqrt(1-z^2))},
18700 or equivalently by @samp{pi/2 - arcsin(z)}. The branch cuts are on
18701 the real axis, less than @mathit{-1} and greater than 1.
18703 For @samp{arctan(z)}: This is defined by
18704 @samp{(ln(1+i*z) - ln(1-i*z)) / (2*i)}. The branch cuts are on the
18705 imaginary axis, below @expr{-i} and above @expr{i}.
18707 For @samp{arcsinh(z)}: This is defined by @samp{ln(z + sqrt(1+z^2))}.
18708 The branch cuts are on the imaginary axis, below @expr{-i} and
18711 For @samp{arccosh(z)}: This is defined by
18712 @samp{ln(z + (z+1)*sqrt((z-1)/(z+1)))}. The branch cut is on the
18713 real axis less than 1.
18715 For @samp{arctanh(z)}: This is defined by @samp{(ln(1+z) - ln(1-z)) / 2}.
18716 The branch cuts are on the real axis, less than @mathit{-1} and greater than 1.
18718 The following tables for @code{arcsin}, @code{arccos}, and
18719 @code{arctan} assume the current angular mode is Radians. The
18720 hyperbolic functions operate independently of the angular mode.
18723 z arcsin(z) arccos(z)
18724 -------------------------------------------------------
18725 (-1..1), 0 (-pi/2..pi/2), 0 (0..pi), 0
18726 (-1..1), +eps (-pi/2..pi/2), +eps (0..pi), -eps
18727 (-1..1), -eps (-pi/2..pi/2), -eps (0..pi), +eps
18728 <-1, 0 -pi/2, + pi, -
18729 <-1, +eps -pi/2 + eps, + pi - eps, -
18730 <-1, -eps -pi/2 + eps, - pi - eps, +
18732 >1, +eps pi/2 - eps, + +eps, -
18733 >1, -eps pi/2 - eps, - +eps, +
18737 z arccosh(z) arctanh(z)
18738 -----------------------------------------------------
18739 (-1..1), 0 0, (0..pi) any, 0
18740 (-1..1), +eps +eps, (0..pi) any, +eps
18741 (-1..1), -eps +eps, (-pi..0) any, -eps
18742 <-1, 0 +, pi -, pi/2
18743 <-1, +eps +, pi - eps -, pi/2 - eps
18744 <-1, -eps +, -pi + eps -, -pi/2 + eps
18745 >1, 0 +, 0 +, -pi/2
18746 >1, +eps +, +eps +, pi/2 - eps
18747 >1, -eps +, -eps +, -pi/2 + eps
18751 z arcsinh(z) arctan(z)
18752 -----------------------------------------------------
18753 0, (-1..1) 0, (-pi/2..pi/2) 0, any
18754 0, <-1 -, -pi/2 -pi/2, -
18755 +eps, <-1 +, -pi/2 + eps pi/2 - eps, -
18756 -eps, <-1 -, -pi/2 + eps -pi/2 + eps, -
18757 0, >1 +, pi/2 pi/2, +
18758 +eps, >1 +, pi/2 - eps pi/2 - eps, +
18759 -eps, >1 -, pi/2 - eps -pi/2 + eps, +
18762 Finally, the following identities help to illustrate the relationship
18763 between the complex trigonometric and hyperbolic functions. They
18764 are valid everywhere, including on the branch cuts.
18767 sin(i*z) = i*sinh(z) arcsin(i*z) = i*arcsinh(z)
18768 cos(i*z) = cosh(z) arcsinh(i*z) = i*arcsin(z)
18769 tan(i*z) = i*tanh(z) arctan(i*z) = i*arctanh(z)
18770 sinh(i*z) = i*sin(z) cosh(i*z) = cos(z)
18773 The ``advanced math'' functions (gamma, Bessel, etc.@:) are also defined
18774 for general complex arguments, but their branch cuts and principal values
18775 are not rigorously specified at present.
18777 @node Random Numbers, Combinatorial Functions, Branch Cuts, Scientific Functions
18778 @section Random Numbers
18782 @pindex calc-random
18784 The @kbd{k r} (@code{calc-random}) [@code{random}] command produces
18785 random numbers of various sorts.
18787 Given a positive numeric prefix argument @expr{M}, it produces a random
18788 integer @expr{N} in the range
18789 @texline @math{0 \le N < M}.
18790 @infoline @expr{0 <= N < M}.
18791 Each possible value @expr{N} appears with equal probability.
18793 With no numeric prefix argument, the @kbd{k r} command takes its argument
18794 from the stack instead. Once again, if this is a positive integer @expr{M}
18795 the result is a random integer less than @expr{M}. However, note that
18796 while numeric prefix arguments are limited to six digits or so, an @expr{M}
18797 taken from the stack can be arbitrarily large. If @expr{M} is negative,
18798 the result is a random integer in the range
18799 @texline @math{M < N \le 0}.
18800 @infoline @expr{M < N <= 0}.
18802 If the value on the stack is a floating-point number @expr{M}, the result
18803 is a random floating-point number @expr{N} in the range
18804 @texline @math{0 \le N < M}
18805 @infoline @expr{0 <= N < M}
18807 @texline @math{M < N \le 0},
18808 @infoline @expr{M < N <= 0},
18809 according to the sign of @expr{M}.
18811 If @expr{M} is zero, the result is a Gaussian-distributed random real
18812 number; the distribution has a mean of zero and a standard deviation
18813 of one. The algorithm used generates random numbers in pairs; thus,
18814 every other call to this function will be especially fast.
18816 If @expr{M} is an error form
18817 @texline @math{m} @code{+/-} @math{\sigma}
18818 @infoline @samp{m +/- s}
18820 @texline @math{\sigma}
18822 are both real numbers, the result uses a Gaussian distribution with mean
18823 @var{m} and standard deviation
18824 @texline @math{\sigma}.
18827 If @expr{M} is an interval form, the lower and upper bounds specify the
18828 acceptable limits of the random numbers. If both bounds are integers,
18829 the result is a random integer in the specified range. If either bound
18830 is floating-point, the result is a random real number in the specified
18831 range. If the interval is open at either end, the result will be sure
18832 not to equal that end value. (This makes a big difference for integer
18833 intervals, but for floating-point intervals it's relatively minor:
18834 with a precision of 6, @samp{random([1.0..2.0))} will return any of one
18835 million numbers from 1.00000 to 1.99999; @samp{random([1.0..2.0])} may
18836 additionally return 2.00000, but the probability of this happening is
18839 If @expr{M} is a vector, the result is one element taken at random from
18840 the vector. All elements of the vector are given equal probabilities.
18843 The sequence of numbers produced by @kbd{k r} is completely random by
18844 default, i.e., the sequence is seeded each time you start Calc using
18845 the current time and other information. You can get a reproducible
18846 sequence by storing a particular ``seed value'' in the Calc variable
18847 @code{RandSeed}. Any integer will do for a seed; integers of from 1
18848 to 12 digits are good. If you later store a different integer into
18849 @code{RandSeed}, Calc will switch to a different pseudo-random
18850 sequence. If you ``unstore'' @code{RandSeed}, Calc will re-seed itself
18851 from the current time. If you store the same integer that you used
18852 before back into @code{RandSeed}, you will get the exact same sequence
18853 of random numbers as before.
18855 @pindex calc-rrandom
18856 The @code{calc-rrandom} command (not on any key) produces a random real
18857 number between zero and one. It is equivalent to @samp{random(1.0)}.
18860 @pindex calc-random-again
18861 The @kbd{k a} (@code{calc-random-again}) command produces another random
18862 number, re-using the most recent value of @expr{M}. With a numeric
18863 prefix argument @var{n}, it produces @var{n} more random numbers using
18864 that value of @expr{M}.
18867 @pindex calc-shuffle
18869 The @kbd{k h} (@code{calc-shuffle}) command produces a vector of several
18870 random values with no duplicates. The value on the top of the stack
18871 specifies the set from which the random values are drawn, and may be any
18872 of the @expr{M} formats described above. The numeric prefix argument
18873 gives the length of the desired list. (If you do not provide a numeric
18874 prefix argument, the length of the list is taken from the top of the
18875 stack, and @expr{M} from second-to-top.)
18877 If @expr{M} is a floating-point number, zero, or an error form (so
18878 that the random values are being drawn from the set of real numbers)
18879 there is little practical difference between using @kbd{k h} and using
18880 @kbd{k r} several times. But if the set of possible values consists
18881 of just a few integers, or the elements of a vector, then there is
18882 a very real chance that multiple @kbd{k r}'s will produce the same
18883 number more than once. The @kbd{k h} command produces a vector whose
18884 elements are always distinct. (Actually, there is a slight exception:
18885 If @expr{M} is a vector, no given vector element will be drawn more
18886 than once, but if several elements of @expr{M} are equal, they may
18887 each make it into the result vector.)
18889 One use of @kbd{k h} is to rearrange a list at random. This happens
18890 if the prefix argument is equal to the number of values in the list:
18891 @kbd{[1, 1.5, 2, 2.5, 3] 5 k h} might produce the permuted list
18892 @samp{[2.5, 1, 1.5, 3, 2]}. As a convenient feature, if the argument
18893 @var{n} is negative it is replaced by the size of the set represented
18894 by @expr{M}. Naturally, this is allowed only when @expr{M} specifies
18895 a small discrete set of possibilities.
18897 To do the equivalent of @kbd{k h} but with duplications allowed,
18898 given @expr{M} on the stack and with @var{n} just entered as a numeric
18899 prefix, use @kbd{v b} to build a vector of copies of @expr{M}, then use
18900 @kbd{V M k r} to ``map'' the normal @kbd{k r} function over the
18901 elements of this vector. @xref{Matrix Functions}.
18904 * Random Number Generator:: (Complete description of Calc's algorithm)
18907 @node Random Number Generator, , Random Numbers, Random Numbers
18908 @subsection Random Number Generator
18910 Calc's random number generator uses several methods to ensure that
18911 the numbers it produces are highly random. Knuth's @emph{Art of
18912 Computer Programming}, Volume II, contains a thorough description
18913 of the theory of random number generators and their measurement and
18916 If @code{RandSeed} has no stored value, Calc calls Emacs' built-in
18917 @code{random} function to get a stream of random numbers, which it
18918 then treats in various ways to avoid problems inherent in the simple
18919 random number generators that many systems use to implement @code{random}.
18921 When Calc's random number generator is first invoked, it ``seeds''
18922 the low-level random sequence using the time of day, so that the
18923 random number sequence will be different every time you use Calc.
18925 Since Emacs Lisp doesn't specify the range of values that will be
18926 returned by its @code{random} function, Calc exercises the function
18927 several times to estimate the range. When Calc subsequently uses
18928 the @code{random} function, it takes only 10 bits of the result
18929 near the most-significant end. (It avoids at least the bottom
18930 four bits, preferably more, and also tries to avoid the top two
18931 bits.) This strategy works well with the linear congruential
18932 generators that are typically used to implement @code{random}.
18934 If @code{RandSeed} contains an integer, Calc uses this integer to
18935 seed an ``additive congruential'' method (Knuth's algorithm 3.2.2A,
18937 @texline @math{X_{n-55} - X_{n-24}}.
18938 @infoline @expr{X_n-55 - X_n-24}).
18939 This method expands the seed
18940 value into a large table which is maintained internally; the variable
18941 @code{RandSeed} is changed from, e.g., 42 to the vector @expr{[42]}
18942 to indicate that the seed has been absorbed into this table. When
18943 @code{RandSeed} contains a vector, @kbd{k r} and related commands
18944 continue to use the same internal table as last time. There is no
18945 way to extract the complete state of the random number generator
18946 so that you can restart it from any point; you can only restart it
18947 from the same initial seed value. A simple way to restart from the
18948 same seed is to type @kbd{s r RandSeed} to get the seed vector,
18949 @kbd{v u} to unpack it back into a number, then @kbd{s t RandSeed}
18950 to reseed the generator with that number.
18952 Calc uses a ``shuffling'' method as described in algorithm 3.2.2B
18953 of Knuth. It fills a table with 13 random 10-bit numbers. Then,
18954 to generate a new random number, it uses the previous number to
18955 index into the table, picks the value it finds there as the new
18956 random number, then replaces that table entry with a new value
18957 obtained from a call to the base random number generator (either
18958 the additive congruential generator or the @code{random} function
18959 supplied by the system). If there are any flaws in the base
18960 generator, shuffling will tend to even them out. But if the system
18961 provides an excellent @code{random} function, shuffling will not
18962 damage its randomness.
18964 To create a random integer of a certain number of digits, Calc
18965 builds the integer three decimal digits at a time. For each group
18966 of three digits, Calc calls its 10-bit shuffling random number generator
18967 (which returns a value from 0 to 1023); if the random value is 1000
18968 or more, Calc throws it out and tries again until it gets a suitable
18971 To create a random floating-point number with precision @var{p}, Calc
18972 simply creates a random @var{p}-digit integer and multiplies by
18973 @texline @math{10^{-p}}.
18974 @infoline @expr{10^-p}.
18975 The resulting random numbers should be very clean, but note
18976 that relatively small numbers will have few significant random digits.
18977 In other words, with a precision of 12, you will occasionally get
18978 numbers on the order of
18979 @texline @math{10^{-9}}
18980 @infoline @expr{10^-9}
18982 @texline @math{10^{-10}},
18983 @infoline @expr{10^-10},
18984 but those numbers will only have two or three random digits since they
18985 correspond to small integers times
18986 @texline @math{10^{-12}}.
18987 @infoline @expr{10^-12}.
18989 To create a random integer in the interval @samp{[0 .. @var{m})}, Calc
18990 counts the digits in @var{m}, creates a random integer with three
18991 additional digits, then reduces modulo @var{m}. Unless @var{m} is a
18992 power of ten the resulting values will be very slightly biased toward
18993 the lower numbers, but this bias will be less than 0.1%. (For example,
18994 if @var{m} is 42, Calc will reduce a random integer less than 100000
18995 modulo 42 to get a result less than 42. It is easy to show that the
18996 numbers 40 and 41 will be only 2380/2381 as likely to result from this
18997 modulo operation as numbers 39 and below.) If @var{m} is a power of
18998 ten, however, the numbers should be completely unbiased.
19000 The Gaussian random numbers generated by @samp{random(0.0)} use the
19001 ``polar'' method described in Knuth section 3.4.1C. This method
19002 generates a pair of Gaussian random numbers at a time, so only every
19003 other call to @samp{random(0.0)} will require significant calculations.
19005 @node Combinatorial Functions, Probability Distribution Functions, Random Numbers, Scientific Functions
19006 @section Combinatorial Functions
19009 Commands relating to combinatorics and number theory begin with the
19010 @kbd{k} key prefix.
19015 The @kbd{k g} (@code{calc-gcd}) [@code{gcd}] command computes the
19016 Greatest Common Divisor of two integers. It also accepts fractions;
19017 the GCD of two fractions is defined by taking the GCD of the
19018 numerators, and the LCM of the denominators. This definition is
19019 consistent with the idea that @samp{a / gcd(a,x)} should yield an
19020 integer for any @samp{a} and @samp{x}. For other types of arguments,
19021 the operation is left in symbolic form.
19026 The @kbd{k l} (@code{calc-lcm}) [@code{lcm}] command computes the
19027 Least Common Multiple of two integers or fractions. The product of
19028 the LCM and GCD of two numbers is equal to the product of the
19032 @pindex calc-extended-gcd
19034 The @kbd{k E} (@code{calc-extended-gcd}) [@code{egcd}] command computes
19035 the GCD of two integers @expr{x} and @expr{y} and returns a vector
19036 @expr{[g, a, b]} where
19037 @texline @math{g = \gcd(x,y) = a x + b y}.
19038 @infoline @expr{g = gcd(x,y) = a x + b y}.
19041 @pindex calc-factorial
19047 The @kbd{!} (@code{calc-factorial}) [@code{fact}] command computes the
19048 factorial of the number at the top of the stack. If the number is an
19049 integer, the result is an exact integer. If the number is an
19050 integer-valued float, the result is a floating-point approximation. If
19051 the number is a non-integral real number, the generalized factorial is used,
19052 as defined by the Euler Gamma function. Please note that computation of
19053 large factorials can be slow; using floating-point format will help
19054 since fewer digits must be maintained. The same is true of many of
19055 the commands in this section.
19058 @pindex calc-double-factorial
19064 The @kbd{k d} (@code{calc-double-factorial}) [@code{dfact}] command
19065 computes the ``double factorial'' of an integer. For an even integer,
19066 this is the product of even integers from 2 to @expr{N}. For an odd
19067 integer, this is the product of odd integers from 3 to @expr{N}. If
19068 the argument is an integer-valued float, the result is a floating-point
19069 approximation. This function is undefined for negative even integers.
19070 The notation @expr{N!!} is also recognized for double factorials.
19073 @pindex calc-choose
19075 The @kbd{k c} (@code{calc-choose}) [@code{choose}] command computes the
19076 binomial coefficient @expr{N}-choose-@expr{M}, where @expr{M} is the number
19077 on the top of the stack and @expr{N} is second-to-top. If both arguments
19078 are integers, the result is an exact integer. Otherwise, the result is a
19079 floating-point approximation. The binomial coefficient is defined for all
19081 @texline @math{N! \over M! (N-M)!\,}.
19082 @infoline @expr{N! / M! (N-M)!}.
19088 The @kbd{H k c} (@code{calc-perm}) [@code{perm}] command computes the
19089 number-of-permutations function @expr{N! / (N-M)!}.
19092 The \kbd{H k c} (\code{calc-perm}) [\code{perm}] command computes the
19093 number-of-perm\-utations function $N! \over (N-M)!\,$.
19098 @pindex calc-bernoulli-number
19100 The @kbd{k b} (@code{calc-bernoulli-number}) [@code{bern}] command
19101 computes a given Bernoulli number. The value at the top of the stack
19102 is a nonnegative integer @expr{n} that specifies which Bernoulli number
19103 is desired. The @kbd{H k b} command computes a Bernoulli polynomial,
19104 taking @expr{n} from the second-to-top position and @expr{x} from the
19105 top of the stack. If @expr{x} is a variable or formula the result is
19106 a polynomial in @expr{x}; if @expr{x} is a number the result is a number.
19110 @pindex calc-euler-number
19112 The @kbd{k e} (@code{calc-euler-number}) [@code{euler}] command similarly
19113 computes an Euler number, and @w{@kbd{H k e}} computes an Euler polynomial.
19114 Bernoulli and Euler numbers occur in the Taylor expansions of several
19119 @pindex calc-stirling-number
19122 The @kbd{k s} (@code{calc-stirling-number}) [@code{stir1}] command
19123 computes a Stirling number of the first
19124 @texline kind@tie{}@math{n \brack m},
19126 given two integers @expr{n} and @expr{m} on the stack. The @kbd{H k s}
19127 [@code{stir2}] command computes a Stirling number of the second
19128 @texline kind@tie{}@math{n \brace m}.
19130 These are the number of @expr{m}-cycle permutations of @expr{n} objects,
19131 and the number of ways to partition @expr{n} objects into @expr{m}
19132 non-empty sets, respectively.
19135 @pindex calc-prime-test
19137 The @kbd{k p} (@code{calc-prime-test}) command checks if the integer on
19138 the top of the stack is prime. For integers less than eight million, the
19139 answer is always exact and reasonably fast. For larger integers, a
19140 probabilistic method is used (see Knuth vol. II, section 4.5.4, algorithm P).
19141 The number is first checked against small prime factors (up to 13). Then,
19142 any number of iterations of the algorithm are performed. Each step either
19143 discovers that the number is non-prime, or substantially increases the
19144 certainty that the number is prime. After a few steps, the chance that
19145 a number was mistakenly described as prime will be less than one percent.
19146 (Indeed, this is a worst-case estimate of the probability; in practice
19147 even a single iteration is quite reliable.) After the @kbd{k p} command,
19148 the number will be reported as definitely prime or non-prime if possible,
19149 or otherwise ``probably'' prime with a certain probability of error.
19155 The normal @kbd{k p} command performs one iteration of the primality
19156 test. Pressing @kbd{k p} repeatedly for the same integer will perform
19157 additional iterations. Also, @kbd{k p} with a numeric prefix performs
19158 the specified number of iterations. There is also an algebraic function
19159 @samp{prime(n)} or @samp{prime(n,iters)} which returns 1 if @expr{n}
19160 is (probably) prime and 0 if not.
19163 @pindex calc-prime-factors
19165 The @kbd{k f} (@code{calc-prime-factors}) [@code{prfac}] command
19166 attempts to decompose an integer into its prime factors. For numbers up
19167 to 25 million, the answer is exact although it may take some time. The
19168 result is a vector of the prime factors in increasing order. For larger
19169 inputs, prime factors above 5000 may not be found, in which case the
19170 last number in the vector will be an unfactored integer greater than 25
19171 million (with a warning message). For negative integers, the first
19172 element of the list will be @mathit{-1}. For inputs @mathit{-1}, @mathit{0}, and
19173 @mathit{1}, the result is a list of the same number.
19176 @pindex calc-next-prime
19178 @mindex nextpr@idots
19181 The @kbd{k n} (@code{calc-next-prime}) [@code{nextprime}] command finds
19182 the next prime above a given number. Essentially, it searches by calling
19183 @code{calc-prime-test} on successive integers until it finds one that
19184 passes the test. This is quite fast for integers less than eight million,
19185 but once the probabilistic test comes into play the search may be rather
19186 slow. Ordinarily this command stops for any prime that passes one iteration
19187 of the primality test. With a numeric prefix argument, a number must pass
19188 the specified number of iterations before the search stops. (This only
19189 matters when searching above eight million.) You can always use additional
19190 @kbd{k p} commands to increase your certainty that the number is indeed
19194 @pindex calc-prev-prime
19196 @mindex prevpr@idots
19199 The @kbd{I k n} (@code{calc-prev-prime}) [@code{prevprime}] command
19200 analogously finds the next prime less than a given number.
19203 @pindex calc-totient
19205 The @kbd{k t} (@code{calc-totient}) [@code{totient}] command computes the
19207 @texline function@tie{}@math{\phi(n)},
19208 @infoline function,
19209 the number of integers less than @expr{n} which
19210 are relatively prime to @expr{n}.
19213 @pindex calc-moebius
19215 The @kbd{k m} (@code{calc-moebius}) [@code{moebius}] command computes the
19216 @texline M@"obius @math{\mu}
19217 @infoline Moebius ``mu''
19218 function. If the input number is a product of @expr{k}
19219 distinct factors, this is @expr{(-1)^k}. If the input number has any
19220 duplicate factors (i.e., can be divided by the same prime more than once),
19221 the result is zero.
19223 @node Probability Distribution Functions, , Combinatorial Functions, Scientific Functions
19224 @section Probability Distribution Functions
19227 The functions in this section compute various probability distributions.
19228 For continuous distributions, this is the integral of the probability
19229 density function from @expr{x} to infinity. (These are the ``upper
19230 tail'' distribution functions; there are also corresponding ``lower
19231 tail'' functions which integrate from minus infinity to @expr{x}.)
19232 For discrete distributions, the upper tail function gives the sum
19233 from @expr{x} to infinity; the lower tail function gives the sum
19234 from minus infinity up to, but not including,@w{ }@expr{x}.
19236 To integrate from @expr{x} to @expr{y}, just use the distribution
19237 function twice and subtract. For example, the probability that a
19238 Gaussian random variable with mean 2 and standard deviation 1 will
19239 lie in the range from 2.5 to 2.8 is @samp{utpn(2.5,2,1) - utpn(2.8,2,1)}
19240 (``the probability that it is greater than 2.5, but not greater than 2.8''),
19241 or equivalently @samp{ltpn(2.8,2,1) - ltpn(2.5,2,1)}.
19248 The @kbd{k B} (@code{calc-utpb}) [@code{utpb}] function uses the
19249 binomial distribution. Push the parameters @var{n}, @var{p}, and
19250 then @var{x} onto the stack; the result (@samp{utpb(x,n,p)}) is the
19251 probability that an event will occur @var{x} or more times out
19252 of @var{n} trials, if its probability of occurring in any given
19253 trial is @var{p}. The @kbd{I k B} [@code{ltpb}] function is
19254 the probability that the event will occur fewer than @var{x} times.
19256 The other probability distribution functions similarly take the
19257 form @kbd{k @var{X}} (@code{calc-utp@var{x}}) [@code{utp@var{x}}]
19258 and @kbd{I k @var{X}} [@code{ltp@var{x}}], for various letters
19259 @var{x}. The arguments to the algebraic functions are the value of
19260 the random variable first, then whatever other parameters define the
19261 distribution. Note these are among the few Calc functions where the
19262 order of the arguments in algebraic form differs from the order of
19263 arguments as found on the stack. (The random variable comes last on
19264 the stack, so that you can type, e.g., @kbd{2 @key{RET} 1 @key{RET} 2.5
19265 k N M-@key{RET} @key{DEL} 2.8 k N -}, using @kbd{M-@key{RET} @key{DEL}} to
19266 recover the original arguments but substitute a new value for @expr{x}.)
19279 The @samp{utpc(x,v)} function uses the chi-square distribution with
19280 @texline @math{\nu}
19282 degrees of freedom. It is the probability that a model is
19283 correct if its chi-square statistic is @expr{x}.
19296 The @samp{utpf(F,v1,v2)} function uses the F distribution, used in
19297 various statistical tests. The parameters
19298 @texline @math{\nu_1}
19299 @infoline @expr{v1}
19301 @texline @math{\nu_2}
19302 @infoline @expr{v2}
19303 are the degrees of freedom in the numerator and denominator,
19304 respectively, used in computing the statistic @expr{F}.
19317 The @samp{utpn(x,m,s)} function uses a normal (Gaussian) distribution
19318 with mean @expr{m} and standard deviation
19319 @texline @math{\sigma}.
19320 @infoline @expr{s}.
19321 It is the probability that such a normal-distributed random variable
19322 would exceed @expr{x}.
19335 The @samp{utpp(n,x)} function uses a Poisson distribution with
19336 mean @expr{x}. It is the probability that @expr{n} or more such
19337 Poisson random events will occur.
19350 The @samp{utpt(t,v)} function uses the Student's ``t'' distribution
19352 @texline @math{\nu}
19354 degrees of freedom. It is the probability that a
19355 t-distributed random variable will be greater than @expr{t}.
19356 (Note: This computes the distribution function
19357 @texline @math{A(t|\nu)}
19358 @infoline @expr{A(t|v)}
19360 @texline @math{A(0|\nu) = 1}
19361 @infoline @expr{A(0|v) = 1}
19363 @texline @math{A(\infty|\nu) \to 0}.
19364 @infoline @expr{A(inf|v) -> 0}.
19365 The @code{UTPT} operation on the HP-48 uses a different definition which
19366 returns half of Calc's value: @samp{UTPT(t,v) = .5*utpt(t,v)}.)
19368 While Calc does not provide inverses of the probability distribution
19369 functions, the @kbd{a R} command can be used to solve for the inverse.
19370 Since the distribution functions are monotonic, @kbd{a R} is guaranteed
19371 to be able to find a solution given any initial guess.
19372 @xref{Numerical Solutions}.
19374 @node Matrix Functions, Algebra, Scientific Functions, Top
19375 @chapter Vector/Matrix Functions
19378 Many of the commands described here begin with the @kbd{v} prefix.
19379 (For convenience, the shift-@kbd{V} prefix is equivalent to @kbd{v}.)
19380 The commands usually apply to both plain vectors and matrices; some
19381 apply only to matrices or only to square matrices. If the argument
19382 has the wrong dimensions the operation is left in symbolic form.
19384 Vectors are entered and displayed using @samp{[a,b,c]} notation.
19385 Matrices are vectors of which all elements are vectors of equal length.
19386 (Though none of the standard Calc commands use this concept, a
19387 three-dimensional matrix or rank-3 tensor could be defined as a
19388 vector of matrices, and so on.)
19391 * Packing and Unpacking::
19392 * Building Vectors::
19393 * Extracting Elements::
19394 * Manipulating Vectors::
19395 * Vector and Matrix Arithmetic::
19397 * Statistical Operations::
19398 * Reducing and Mapping::
19399 * Vector and Matrix Formats::
19402 @node Packing and Unpacking, Building Vectors, Matrix Functions, Matrix Functions
19403 @section Packing and Unpacking
19406 Calc's ``pack'' and ``unpack'' commands collect stack entries to build
19407 composite objects such as vectors and complex numbers. They are
19408 described in this chapter because they are most often used to build
19414 The @kbd{v p} (@code{calc-pack}) [@code{pack}] command collects several
19415 elements from the stack into a matrix, complex number, HMS form, error
19416 form, etc. It uses a numeric prefix argument to specify the kind of
19417 object to be built; this argument is referred to as the ``packing mode.''
19418 If the packing mode is a nonnegative integer, a vector of that
19419 length is created. For example, @kbd{C-u 5 v p} will pop the top
19420 five stack elements and push back a single vector of those five
19421 elements. (@kbd{C-u 0 v p} simply creates an empty vector.)
19423 The same effect can be had by pressing @kbd{[} to push an incomplete
19424 vector on the stack, using @key{TAB} (@code{calc-roll-down}) to sneak
19425 the incomplete object up past a certain number of elements, and
19426 then pressing @kbd{]} to complete the vector.
19428 Negative packing modes create other kinds of composite objects:
19432 Two values are collected to build a complex number. For example,
19433 @kbd{5 @key{RET} 7 C-u -1 v p} creates the complex number
19434 @expr{(5, 7)}. The result is always a rectangular complex
19435 number. The two input values must both be real numbers,
19436 i.e., integers, fractions, or floats. If they are not, Calc
19437 will instead build a formula like @samp{a + (0, 1) b}. (The
19438 other packing modes also create a symbolic answer if the
19439 components are not suitable.)
19442 Two values are collected to build a polar complex number.
19443 The first is the magnitude; the second is the phase expressed
19444 in either degrees or radians according to the current angular
19448 Three values are collected into an HMS form. The first
19449 two values (hours and minutes) must be integers or
19450 integer-valued floats. The third value may be any real
19454 Two values are collected into an error form. The inputs
19455 may be real numbers or formulas.
19458 Two values are collected into a modulo form. The inputs
19459 must be real numbers.
19462 Two values are collected into the interval @samp{[a .. b]}.
19463 The inputs may be real numbers, HMS or date forms, or formulas.
19466 Two values are collected into the interval @samp{[a .. b)}.
19469 Two values are collected into the interval @samp{(a .. b]}.
19472 Two values are collected into the interval @samp{(a .. b)}.
19475 Two integer values are collected into a fraction.
19478 Two values are collected into a floating-point number.
19479 The first is the mantissa; the second, which must be an
19480 integer, is the exponent. The result is the mantissa
19481 times ten to the power of the exponent.
19484 This is treated the same as @mathit{-11} by the @kbd{v p} command.
19485 When unpacking, @mathit{-12} specifies that a floating-point mantissa
19489 A real number is converted into a date form.
19492 Three numbers (year, month, day) are packed into a pure date form.
19495 Six numbers are packed into a date/time form.
19498 With any of the two-input negative packing modes, either or both
19499 of the inputs may be vectors. If both are vectors of the same
19500 length, the result is another vector made by packing corresponding
19501 elements of the input vectors. If one input is a vector and the
19502 other is a plain number, the number is packed along with each vector
19503 element to produce a new vector. For example, @kbd{C-u -4 v p}
19504 could be used to convert a vector of numbers and a vector of errors
19505 into a single vector of error forms; @kbd{C-u -5 v p} could convert
19506 a vector of numbers and a single number @var{M} into a vector of
19507 numbers modulo @var{M}.
19509 If you don't give a prefix argument to @kbd{v p}, it takes
19510 the packing mode from the top of the stack. The elements to
19511 be packed then begin at stack level 2. Thus
19512 @kbd{1 @key{RET} 2 @key{RET} 4 n v p} is another way to
19513 enter the error form @samp{1 +/- 2}.
19515 If the packing mode taken from the stack is a vector, the result is a
19516 matrix with the dimensions specified by the elements of the vector,
19517 which must each be integers. For example, if the packing mode is
19518 @samp{[2, 3]}, then six numbers will be taken from the stack and
19519 returned in the form @samp{[@w{[a, b, c]}, [d, e, f]]}.
19521 If any elements of the vector are negative, other kinds of
19522 packing are done at that level as described above. For
19523 example, @samp{[2, 3, -4]} takes 12 objects and creates a
19524 @texline @math{2\times3}
19526 matrix of error forms: @samp{[[a +/- b, c +/- d ... ]]}.
19527 Also, @samp{[-4, -10]} will convert four integers into an
19528 error form consisting of two fractions: @samp{a:b +/- c:d}.
19534 There is an equivalent algebraic function,
19535 @samp{pack(@var{mode}, @var{items})} where @var{mode} is a
19536 packing mode (an integer or a vector of integers) and @var{items}
19537 is a vector of objects to be packed (re-packed, really) according
19538 to that mode. For example, @samp{pack([3, -4], [a,b,c,d,e,f])}
19539 yields @samp{[a +/- b, @w{c +/- d}, e +/- f]}. The function is
19540 left in symbolic form if the packing mode is invalid, or if the
19541 number of data items does not match the number of items required
19546 @pindex calc-unpack
19547 The @kbd{v u} (@code{calc-unpack}) command takes the vector, complex
19548 number, HMS form, or other composite object on the top of the stack and
19549 ``unpacks'' it, pushing each of its elements onto the stack as separate
19550 objects. Thus, it is the ``inverse'' of @kbd{v p}. If the value
19551 at the top of the stack is a formula, @kbd{v u} unpacks it by pushing
19552 each of the arguments of the top-level operator onto the stack.
19554 You can optionally give a numeric prefix argument to @kbd{v u}
19555 to specify an explicit (un)packing mode. If the packing mode is
19556 negative and the input is actually a vector or matrix, the result
19557 will be two or more similar vectors or matrices of the elements.
19558 For example, given the vector @samp{[@w{a +/- b}, c^2, d +/- 7]},
19559 the result of @kbd{C-u -4 v u} will be the two vectors
19560 @samp{[a, c^2, d]} and @w{@samp{[b, 0, 7]}}.
19562 Note that the prefix argument can have an effect even when the input is
19563 not a vector. For example, if the input is the number @mathit{-5}, then
19564 @kbd{c-u -1 v u} yields @mathit{-5} and 0 (the components of @mathit{-5}
19565 when viewed as a rectangular complex number); @kbd{C-u -2 v u} yields 5
19566 and 180 (assuming Degrees mode); and @kbd{C-u -10 v u} yields @mathit{-5}
19567 and 1 (the numerator and denominator of @mathit{-5}, viewed as a rational
19568 number). Plain @kbd{v u} with this input would complain that the input
19569 is not a composite object.
19571 Unpacking mode @mathit{-11} converts a float into an integer mantissa and
19572 an integer exponent, where the mantissa is not divisible by 10
19573 (except that 0.0 is represented by a mantissa and exponent of 0).
19574 Unpacking mode @mathit{-12} converts a float into a floating-point mantissa
19575 and integer exponent, where the mantissa (for non-zero numbers)
19576 is guaranteed to lie in the range [1 .. 10). In both cases,
19577 the mantissa is shifted left or right (and the exponent adjusted
19578 to compensate) in order to satisfy these constraints.
19580 Positive unpacking modes are treated differently than for @kbd{v p}.
19581 A mode of 1 is much like plain @kbd{v u} with no prefix argument,
19582 except that in addition to the components of the input object,
19583 a suitable packing mode to re-pack the object is also pushed.
19584 Thus, @kbd{C-u 1 v u} followed by @kbd{v p} will re-build the
19587 A mode of 2 unpacks two levels of the object; the resulting
19588 re-packing mode will be a vector of length 2. This might be used
19589 to unpack a matrix, say, or a vector of error forms. Higher
19590 unpacking modes unpack the input even more deeply.
19596 There are two algebraic functions analogous to @kbd{v u}.
19597 The @samp{unpack(@var{mode}, @var{item})} function unpacks the
19598 @var{item} using the given @var{mode}, returning the result as
19599 a vector of components. Here the @var{mode} must be an
19600 integer, not a vector. For example, @samp{unpack(-4, a +/- b)}
19601 returns @samp{[a, b]}, as does @samp{unpack(1, a +/- b)}.
19607 The @code{unpackt} function is like @code{unpack} but instead
19608 of returning a simple vector of items, it returns a vector of
19609 two things: The mode, and the vector of items. For example,
19610 @samp{unpackt(1, 2:3 +/- 1:4)} returns @samp{[-4, [2:3, 1:4]]},
19611 and @samp{unpackt(2, 2:3 +/- 1:4)} returns @samp{[[-4, -10], [2, 3, 1, 4]]}.
19612 The identity for re-building the original object is
19613 @samp{apply(pack, unpackt(@var{n}, @var{x})) = @var{x}}. (The
19614 @code{apply} function builds a function call given the function
19615 name and a vector of arguments.)
19617 @cindex Numerator of a fraction, extracting
19618 Subscript notation is a useful way to extract a particular part
19619 of an object. For example, to get the numerator of a rational
19620 number, you can use @samp{unpack(-10, @var{x})_1}.
19622 @node Building Vectors, Extracting Elements, Packing and Unpacking, Matrix Functions
19623 @section Building Vectors
19626 Vectors and matrices can be added,
19627 subtracted, multiplied, and divided; @pxref{Basic Arithmetic}.
19630 @pindex calc-concat
19635 The @kbd{|} (@code{calc-concat}) [@code{vconcat}] command ``concatenates'' two vectors
19636 into one. For example, after @kbd{@w{[ 1 , 2 ]} [ 3 , 4 ] |}, the stack
19637 will contain the single vector @samp{[1, 2, 3, 4]}. If the arguments
19638 are matrices, the rows of the first matrix are concatenated with the
19639 rows of the second. (In other words, two matrices are just two vectors
19640 of row-vectors as far as @kbd{|} is concerned.)
19642 If either argument to @kbd{|} is a scalar (a non-vector), it is treated
19643 like a one-element vector for purposes of concatenation: @kbd{1 [ 2 , 3 ] |}
19644 produces the vector @samp{[1, 2, 3]}. Likewise, if one argument is a
19645 matrix and the other is a plain vector, the vector is treated as a
19650 The @kbd{H |} (@code{calc-append}) [@code{append}] command concatenates
19651 two vectors without any special cases. Both inputs must be vectors.
19652 Whether or not they are matrices is not taken into account. If either
19653 argument is a scalar, the @code{append} function is left in symbolic form.
19654 See also @code{cons} and @code{rcons} below.
19658 The @kbd{I |} and @kbd{H I |} commands are similar, but they use their
19659 two stack arguments in the opposite order. Thus @kbd{I |} is equivalent
19660 to @kbd{@key{TAB} |}, but possibly more convenient and also a bit faster.
19666 The @kbd{v d} (@code{calc-diag}) [@code{diag}] function builds a diagonal
19667 square matrix. The optional numeric prefix gives the number of rows
19668 and columns in the matrix. If the value at the top of the stack is a
19669 vector, the elements of the vector are used as the diagonal elements; the
19670 prefix, if specified, must match the size of the vector. If the value on
19671 the stack is a scalar, it is used for each element on the diagonal, and
19672 the prefix argument is required.
19674 To build a constant square matrix, e.g., a
19675 @texline @math{3\times3}
19677 matrix filled with ones, use @kbd{0 M-3 v d 1 +}, i.e., build a zero
19678 matrix first and then add a constant value to that matrix. (Another
19679 alternative would be to use @kbd{v b} and @kbd{v a}; see below.)
19685 The @kbd{v i} (@code{calc-ident}) [@code{idn}] function builds an identity
19686 matrix of the specified size. It is a convenient form of @kbd{v d}
19687 where the diagonal element is always one. If no prefix argument is given,
19688 this command prompts for one.
19690 In algebraic notation, @samp{idn(a,n)} acts much like @samp{diag(a,n)},
19691 except that @expr{a} is required to be a scalar (non-vector) quantity.
19692 If @expr{n} is omitted, @samp{idn(a)} represents @expr{a} times an
19693 identity matrix of unknown size. Calc can operate algebraically on
19694 such generic identity matrices, and if one is combined with a matrix
19695 whose size is known, it is converted automatically to an identity
19696 matrix of a suitable matching size. The @kbd{v i} command with an
19697 argument of zero creates a generic identity matrix, @samp{idn(1)}.
19698 Note that in dimensioned Matrix mode (@pxref{Matrix Mode}), generic
19699 identity matrices are immediately expanded to the current default
19706 The @kbd{v x} (@code{calc-index}) [@code{index}] function builds a vector
19707 of consecutive integers from 1 to @var{n}, where @var{n} is the numeric
19708 prefix argument. If you do not provide a prefix argument, you will be
19709 prompted to enter a suitable number. If @var{n} is negative, the result
19710 is a vector of negative integers from @var{n} to @mathit{-1}.
19712 With a prefix argument of just @kbd{C-u}, the @kbd{v x} command takes
19713 three values from the stack: @var{n}, @var{start}, and @var{incr} (with
19714 @var{incr} at top-of-stack). Counting starts at @var{start} and increases
19715 by @var{incr} for successive vector elements. If @var{start} or @var{n}
19716 is in floating-point format, the resulting vector elements will also be
19717 floats. Note that @var{start} and @var{incr} may in fact be any kind
19718 of numbers or formulas.
19720 When @var{start} and @var{incr} are specified, a negative @var{n} has a
19721 different interpretation: It causes a geometric instead of arithmetic
19722 sequence to be generated. For example, @samp{index(-3, a, b)} produces
19723 @samp{[a, a b, a b^2]}. If you omit @var{incr} in the algebraic form,
19724 @samp{index(@var{n}, @var{start})}, the default value for @var{incr}
19725 is one for positive @var{n} or two for negative @var{n}.
19729 @pindex calc-build-vector
19731 The @kbd{v b} (@code{calc-build-vector}) [@code{cvec}] function builds a
19732 vector of @var{n} copies of the value on the top of the stack, where @var{n}
19733 is the numeric prefix argument. In algebraic formulas, @samp{cvec(x,n,m)}
19734 can also be used to build an @var{n}-by-@var{m} matrix of copies of @var{x}.
19735 (Interactively, just use @kbd{v b} twice: once to build a row, then again
19736 to build a matrix of copies of that row.)
19746 The @kbd{v h} (@code{calc-head}) [@code{head}] function returns the first
19747 element of a vector. The @kbd{I v h} (@code{calc-tail}) [@code{tail}]
19748 function returns the vector with its first element removed. In both
19749 cases, the argument must be a non-empty vector.
19755 The @kbd{v k} (@code{calc-cons}) [@code{cons}] function takes a value @var{h}
19756 and a vector @var{t} from the stack, and produces the vector whose head is
19757 @var{h} and whose tail is @var{t}. This is similar to @kbd{|}, except
19758 if @var{h} is itself a vector, @kbd{|} will concatenate the two vectors
19759 whereas @code{cons} will insert @var{h} at the front of the vector @var{t}.
19782 Each of these three functions also accepts the Hyperbolic flag [@code{rhead},
19783 @code{rtail}, @code{rcons}] in which case @var{t} instead represents
19784 the @emph{last} single element of the vector, with @var{h}
19785 representing the remainder of the vector. Thus the vector
19786 @samp{[a, b, c, d] = cons(a, [b, c, d]) = rcons([a, b, c], d)}.
19787 Also, @samp{head([a, b, c, d]) = a}, @samp{tail([a, b, c, d]) = [b, c, d]},
19788 @samp{rhead([a, b, c, d]) = [a, b, c]}, and @samp{rtail([a, b, c, d]) = d}.
19790 @node Extracting Elements, Manipulating Vectors, Building Vectors, Matrix Functions
19791 @section Extracting Vector Elements
19798 The @kbd{v r} (@code{calc-mrow}) [@code{mrow}] command extracts one row of
19799 the matrix on the top of the stack, or one element of the plain vector on
19800 the top of the stack. The row or element is specified by the numeric
19801 prefix argument; the default is to prompt for the row or element number.
19802 The matrix or vector is replaced by the specified row or element in the
19803 form of a vector or scalar, respectively.
19805 @cindex Permutations, applying
19806 With a prefix argument of @kbd{C-u} only, @kbd{v r} takes the index of
19807 the element or row from the top of the stack, and the vector or matrix
19808 from the second-to-top position. If the index is itself a vector of
19809 integers, the result is a vector of the corresponding elements of the
19810 input vector, or a matrix of the corresponding rows of the input matrix.
19811 This command can be used to obtain any permutation of a vector.
19813 With @kbd{C-u}, if the index is an interval form with integer components,
19814 it is interpreted as a range of indices and the corresponding subvector or
19815 submatrix is returned.
19817 @cindex Subscript notation
19819 @pindex calc-subscript
19822 Subscript notation in algebraic formulas (@samp{a_b}) stands for the
19823 Calc function @code{subscr}, which is synonymous with @code{mrow}.
19824 Thus, @samp{[x, y, z]_k} produces @expr{x}, @expr{y}, or @expr{z} if
19825 @expr{k} is one, two, or three, respectively. A double subscript
19826 (@samp{M_i_j}, equivalent to @samp{subscr(subscr(M, i), j)}) will
19827 access the element at row @expr{i}, column @expr{j} of a matrix.
19828 The @kbd{a _} (@code{calc-subscript}) command creates a subscript
19829 formula @samp{a_b} out of two stack entries. (It is on the @kbd{a}
19830 ``algebra'' prefix because subscripted variables are often used
19831 purely as an algebraic notation.)
19834 Given a negative prefix argument, @kbd{v r} instead deletes one row or
19835 element from the matrix or vector on the top of the stack. Thus
19836 @kbd{C-u 2 v r} replaces a matrix with its second row, but @kbd{C-u -2 v r}
19837 replaces the matrix with the same matrix with its second row removed.
19838 In algebraic form this function is called @code{mrrow}.
19841 Given a prefix argument of zero, @kbd{v r} extracts the diagonal elements
19842 of a square matrix in the form of a vector. In algebraic form this
19843 function is called @code{getdiag}.
19850 The @kbd{v c} (@code{calc-mcol}) [@code{mcol} or @code{mrcol}] command is
19851 the analogous operation on columns of a matrix. Given a plain vector
19852 it extracts (or removes) one element, just like @kbd{v r}. If the
19853 index in @kbd{C-u v c} is an interval or vector and the argument is a
19854 matrix, the result is a submatrix with only the specified columns
19855 retained (and possibly permuted in the case of a vector index).
19857 To extract a matrix element at a given row and column, use @kbd{v r} to
19858 extract the row as a vector, then @kbd{v c} to extract the column element
19859 from that vector. In algebraic formulas, it is often more convenient to
19860 use subscript notation: @samp{m_i_j} gives row @expr{i}, column @expr{j}
19861 of matrix @expr{m}.
19865 @pindex calc-subvector
19867 The @kbd{v s} (@code{calc-subvector}) [@code{subvec}] command extracts
19868 a subvector of a vector. The arguments are the vector, the starting
19869 index, and the ending index, with the ending index in the top-of-stack
19870 position. The starting index indicates the first element of the vector
19871 to take. The ending index indicates the first element @emph{past} the
19872 range to be taken. Thus, @samp{subvec([a, b, c, d, e], 2, 4)} produces
19873 the subvector @samp{[b, c]}. You could get the same result using
19874 @samp{mrow([a, b, c, d, e], @w{[2 .. 4)})}.
19876 If either the start or the end index is zero or negative, it is
19877 interpreted as relative to the end of the vector. Thus
19878 @samp{subvec([a, b, c, d, e], 2, -2)} also produces @samp{[b, c]}. In
19879 the algebraic form, the end index can be omitted in which case it
19880 is taken as zero, i.e., elements from the starting element to the
19881 end of the vector are used. The infinity symbol, @code{inf}, also
19882 has this effect when used as the ending index.
19887 With the Inverse flag, @kbd{I v s} [@code{rsubvec}] removes a subvector
19888 from a vector. The arguments are interpreted the same as for the
19889 normal @kbd{v s} command. Thus, @samp{rsubvec([a, b, c, d, e], 2, 4)}
19890 produces @samp{[a, d, e]}. It is always true that @code{subvec} and
19891 @code{rsubvec} return complementary parts of the input vector.
19893 @xref{Selecting Subformulas}, for an alternative way to operate on
19894 vectors one element at a time.
19896 @node Manipulating Vectors, Vector and Matrix Arithmetic, Extracting Elements, Matrix Functions
19897 @section Manipulating Vectors
19902 @pindex calc-vlength
19904 The @kbd{v l} (@code{calc-vlength}) [@code{vlen}] command computes the
19905 length of a vector. The length of a non-vector is considered to be zero.
19906 Note that matrices are just vectors of vectors for the purposes of this
19912 With the Hyperbolic flag, @kbd{H v l} [@code{mdims}] computes a vector
19913 of the dimensions of a vector, matrix, or higher-order object. For
19914 example, @samp{mdims([[a,b,c],[d,e,f]])} returns @samp{[2, 3]} since
19916 @texline @math{2\times3}
19922 @pindex calc-vector-find
19924 The @kbd{v f} (@code{calc-vector-find}) [@code{find}] command searches
19925 along a vector for the first element equal to a given target. The target
19926 is on the top of the stack; the vector is in the second-to-top position.
19927 If a match is found, the result is the index of the matching element.
19928 Otherwise, the result is zero. The numeric prefix argument, if given,
19929 allows you to select any starting index for the search.
19933 @pindex calc-arrange-vector
19935 @cindex Arranging a matrix
19936 @cindex Reshaping a matrix
19937 @cindex Flattening a matrix
19938 The @kbd{v a} (@code{calc-arrange-vector}) [@code{arrange}] command
19939 rearranges a vector to have a certain number of columns and rows. The
19940 numeric prefix argument specifies the number of columns; if you do not
19941 provide an argument, you will be prompted for the number of columns.
19942 The vector or matrix on the top of the stack is @dfn{flattened} into a
19943 plain vector. If the number of columns is nonzero, this vector is
19944 then formed into a matrix by taking successive groups of @var{n} elements.
19945 If the number of columns does not evenly divide the number of elements
19946 in the vector, the last row will be short and the result will not be
19947 suitable for use as a matrix. For example, with the matrix
19948 @samp{[[1, 2], @w{[3, 4]}]} on the stack, @kbd{v a 4} produces
19949 @samp{[[1, 2, 3, 4]]} (a
19950 @texline @math{1\times4}
19952 matrix), @kbd{v a 1} produces @samp{[[1], [2], [3], [4]]} (a
19953 @texline @math{4\times1}
19955 matrix), @kbd{v a 2} produces @samp{[[1, 2], [3, 4]]} (the original
19956 @texline @math{2\times2}
19958 matrix), @w{@kbd{v a 3}} produces @samp{[[1, 2, 3], [4]]} (not a
19959 matrix), and @kbd{v a 0} produces the flattened list
19960 @samp{[1, 2, @w{3, 4}]}.
19962 @cindex Sorting data
19970 The @kbd{V S} (@code{calc-sort}) [@code{sort}] command sorts the elements of
19971 a vector into increasing order. Real numbers, real infinities, and
19972 constant interval forms come first in this ordering; next come other
19973 kinds of numbers, then variables (in alphabetical order), then finally
19974 come formulas and other kinds of objects; these are sorted according
19975 to a kind of lexicographic ordering with the useful property that
19976 one vector is less or greater than another if the first corresponding
19977 unequal elements are less or greater, respectively. Since quoted strings
19978 are stored by Calc internally as vectors of ASCII character codes
19979 (@pxref{Strings}), this means vectors of strings are also sorted into
19980 alphabetical order by this command.
19982 The @kbd{I V S} [@code{rsort}] command sorts a vector into decreasing order.
19984 @cindex Permutation, inverse of
19985 @cindex Inverse of permutation
19986 @cindex Index tables
19987 @cindex Rank tables
19995 The @kbd{V G} (@code{calc-grade}) [@code{grade}, @code{rgrade}] command
19996 produces an index table or permutation vector which, if applied to the
19997 input vector (as the index of @kbd{C-u v r}, say), would sort the vector.
19998 A permutation vector is just a vector of integers from 1 to @var{n}, where
19999 each integer occurs exactly once. One application of this is to sort a
20000 matrix of data rows using one column as the sort key; extract that column,
20001 grade it with @kbd{V G}, then use the result to reorder the original matrix
20002 with @kbd{C-u v r}. Another interesting property of the @code{V G} command
20003 is that, if the input is itself a permutation vector, the result will
20004 be the inverse of the permutation. The inverse of an index table is
20005 a rank table, whose @var{k}th element says where the @var{k}th original
20006 vector element will rest when the vector is sorted. To get a rank
20007 table, just use @kbd{V G V G}.
20009 With the Inverse flag, @kbd{I V G} produces an index table that would
20010 sort the input into decreasing order. Note that @kbd{V S} and @kbd{V G}
20011 use a ``stable'' sorting algorithm, i.e., any two elements which are equal
20012 will not be moved out of their original order. Generally there is no way
20013 to tell with @kbd{V S}, since two elements which are equal look the same,
20014 but with @kbd{V G} this can be an important issue. In the matrix-of-rows
20015 example, suppose you have names and telephone numbers as two columns and
20016 you wish to sort by phone number primarily, and by name when the numbers
20017 are equal. You can sort the data matrix by names first, and then again
20018 by phone numbers. Because the sort is stable, any two rows with equal
20019 phone numbers will remain sorted by name even after the second sort.
20024 @pindex calc-histogram
20026 @mindex histo@idots
20029 The @kbd{V H} (@code{calc-histogram}) [@code{histogram}] command builds a
20030 histogram of a vector of numbers. Vector elements are assumed to be
20031 integers or real numbers in the range [0..@var{n}) for some ``number of
20032 bins'' @var{n}, which is the numeric prefix argument given to the
20033 command. The result is a vector of @var{n} counts of how many times
20034 each value appeared in the original vector. Non-integers in the input
20035 are rounded down to integers. Any vector elements outside the specified
20036 range are ignored. (You can tell if elements have been ignored by noting
20037 that the counts in the result vector don't add up to the length of the
20040 If no prefix is given, then you will be prompted for a vector which
20041 will be used to determine the bins. (If a positive integer is given at
20042 this prompt, it will be still treated as if it were given as a
20043 prefix.) Each bin will consist of the interval of numbers closest to
20044 the corresponding number of this new vector; if the vector
20045 @expr{[a, b, c, ...]} is entered at the prompt, the bins will be
20046 @expr{(-inf, (a+b)/2]}, @expr{((a+b)/2, (b+c)/2]}, etc. The result of
20047 this command will be a vector counting how many elements of the
20048 original vector are in each bin.
20050 The result will then be a vector with the same length as this new vector;
20051 each element of the new vector will be replaced by the number of
20052 elements of the original vector which are closest to it.
20056 With the Hyperbolic flag, @kbd{H V H} pulls two vectors from the stack.
20057 The second-to-top vector is the list of numbers as before. The top
20058 vector is an equal-sized list of ``weights'' to attach to the elements
20059 of the data vector. For example, if the first data element is 4.2 and
20060 the first weight is 10, then 10 will be added to bin 4 of the result
20061 vector. Without the hyperbolic flag, every element has a weight of one.
20065 @pindex calc-transpose
20067 The @kbd{v t} (@code{calc-transpose}) [@code{trn}] command computes
20068 the transpose of the matrix at the top of the stack. If the argument
20069 is a plain vector, it is treated as a row vector and transposed into
20070 a one-column matrix.
20074 @pindex calc-reverse-vector
20076 The @kbd{v v} (@code{calc-reverse-vector}) [@code{rev}] command reverses
20077 a vector end-for-end. Given a matrix, it reverses the order of the rows.
20078 (To reverse the columns instead, just use @kbd{v t v v v t}. The same
20079 principle can be used to apply other vector commands to the columns of
20084 @pindex calc-mask-vector
20086 The @kbd{v m} (@code{calc-mask-vector}) [@code{vmask}] command uses
20087 one vector as a mask to extract elements of another vector. The mask
20088 is in the second-to-top position; the target vector is on the top of
20089 the stack. These vectors must have the same length. The result is
20090 the same as the target vector, but with all elements which correspond
20091 to zeros in the mask vector deleted. Thus, for example,
20092 @samp{vmask([1, 0, 1, 0, 1], [a, b, c, d, e])} produces @samp{[a, c, e]}.
20093 @xref{Logical Operations}.
20097 @pindex calc-expand-vector
20099 The @kbd{v e} (@code{calc-expand-vector}) [@code{vexp}] command
20100 expands a vector according to another mask vector. The result is a
20101 vector the same length as the mask, but with nonzero elements replaced
20102 by successive elements from the target vector. The length of the target
20103 vector is normally the number of nonzero elements in the mask. If the
20104 target vector is longer, its last few elements are lost. If the target
20105 vector is shorter, the last few nonzero mask elements are left
20106 unreplaced in the result. Thus @samp{vexp([2, 0, 3, 0, 7], [a, b])}
20107 produces @samp{[a, 0, b, 0, 7]}.
20111 With the Hyperbolic flag, @kbd{H v e} takes a filler value from the
20112 top of the stack; the mask and target vectors come from the third and
20113 second elements of the stack. This filler is used where the mask is
20114 zero: @samp{vexp([2, 0, 3, 0, 7], [a, b], z)} produces
20115 @samp{[a, z, c, z, 7]}. If the filler value is itself a vector,
20116 then successive values are taken from it, so that the effect is to
20117 interleave two vectors according to the mask:
20118 @samp{vexp([2, 0, 3, 7, 0, 0], [a, b], [x, y])} produces
20119 @samp{[a, x, b, 7, y, 0]}.
20121 Another variation on the masking idea is to combine @samp{[a, b, c, d, e]}
20122 with the mask @samp{[1, 0, 1, 0, 1]} to produce @samp{[a, 0, c, 0, e]}.
20123 You can accomplish this with @kbd{V M a &}, mapping the logical ``and''
20124 operation across the two vectors. @xref{Logical Operations}. Note that
20125 the @code{? :} operation also discussed there allows other types of
20126 masking using vectors.
20128 @node Vector and Matrix Arithmetic, Set Operations, Manipulating Vectors, Matrix Functions
20129 @section Vector and Matrix Arithmetic
20132 Basic arithmetic operations like addition and multiplication are defined
20133 for vectors and matrices as well as for numbers. Division of matrices, in
20134 the sense of multiplying by the inverse, is supported. (Division by a
20135 matrix actually uses LU-decomposition for greater accuracy and speed.)
20136 @xref{Basic Arithmetic}.
20138 The following functions are applied element-wise if their arguments are
20139 vectors or matrices: @code{change-sign}, @code{conj}, @code{arg},
20140 @code{re}, @code{im}, @code{polar}, @code{rect}, @code{clean},
20141 @code{float}, @code{frac}. @xref{Function Index}.
20145 @pindex calc-conj-transpose
20147 The @kbd{V J} (@code{calc-conj-transpose}) [@code{ctrn}] command computes
20148 the conjugate transpose of its argument, i.e., @samp{conj(trn(x))}.
20153 @kindex A (vectors)
20154 @pindex calc-abs (vectors)
20158 @tindex abs (vectors)
20159 The @kbd{A} (@code{calc-abs}) [@code{abs}] command computes the
20160 Frobenius norm of a vector or matrix argument. This is the square
20161 root of the sum of the squares of the absolute values of the
20162 elements of the vector or matrix. If the vector is interpreted as
20163 a point in two- or three-dimensional space, this is the distance
20164 from that point to the origin.
20170 The @kbd{v n} (@code{calc-rnorm}) [@code{rnorm}] command computes the
20171 infinity-norm of a vector, or the row norm of a matrix. For a plain
20172 vector, this is the maximum of the absolute values of the elements. For
20173 a matrix, this is the maximum of the row-absolute-value-sums, i.e., of
20174 the sums of the absolute values of the elements along the various rows.
20180 The @kbd{V N} (@code{calc-cnorm}) [@code{cnorm}] command computes
20181 the one-norm of a vector, or column norm of a matrix. For a plain
20182 vector, this is the sum of the absolute values of the elements.
20183 For a matrix, this is the maximum of the column-absolute-value-sums.
20184 General @expr{k}-norms for @expr{k} other than one or infinity are
20185 not provided. However, the 2-norm (or Frobenius norm) is provided for
20186 vectors by the @kbd{A} (@code{calc-abs}) command.
20192 The @kbd{V C} (@code{calc-cross}) [@code{cross}] command computes the
20193 right-handed cross product of two vectors, each of which must have
20194 exactly three elements.
20199 @kindex & (matrices)
20200 @pindex calc-inv (matrices)
20204 @tindex inv (matrices)
20205 The @kbd{&} (@code{calc-inv}) [@code{inv}] command computes the
20206 inverse of a square matrix. If the matrix is singular, the inverse
20207 operation is left in symbolic form. Matrix inverses are recorded so
20208 that once an inverse (or determinant) of a particular matrix has been
20209 computed, the inverse and determinant of the matrix can be recomputed
20210 quickly in the future.
20212 If the argument to @kbd{&} is a plain number @expr{x}, this
20213 command simply computes @expr{1/x}. This is okay, because the
20214 @samp{/} operator also does a matrix inversion when dividing one
20221 The @kbd{V D} (@code{calc-mdet}) [@code{det}] command computes the
20222 determinant of a square matrix.
20228 The @kbd{V L} (@code{calc-mlud}) [@code{lud}] command computes the
20229 LU decomposition of a matrix. The result is a list of three matrices
20230 which, when multiplied together left-to-right, form the original matrix.
20231 The first is a permutation matrix that arises from pivoting in the
20232 algorithm, the second is lower-triangular with ones on the diagonal,
20233 and the third is upper-triangular.
20237 @pindex calc-mtrace
20239 The @kbd{V T} (@code{calc-mtrace}) [@code{tr}] command computes the
20240 trace of a square matrix. This is defined as the sum of the diagonal
20241 elements of the matrix.
20247 The @kbd{V K} (@code{calc-kron}) [@code{kron}] command computes
20248 the Kronecker product of two matrices.
20250 @node Set Operations, Statistical Operations, Vector and Matrix Arithmetic, Matrix Functions
20251 @section Set Operations using Vectors
20254 @cindex Sets, as vectors
20255 Calc includes several commands which interpret vectors as @dfn{sets} of
20256 objects. A set is a collection of objects; any given object can appear
20257 only once in the set. Calc stores sets as vectors of objects in
20258 sorted order. Objects in a Calc set can be any of the usual things,
20259 such as numbers, variables, or formulas. Two set elements are considered
20260 equal if they are identical, except that numerically equal numbers like
20261 the integer 4 and the float 4.0 are considered equal even though they
20262 are not ``identical.'' Variables are treated like plain symbols without
20263 attached values by the set operations; subtracting the set @samp{[b]}
20264 from @samp{[a, b]} always yields the set @samp{[a]} even though if
20265 the variables @samp{a} and @samp{b} both equaled 17, you might
20266 expect the answer @samp{[]}.
20268 If a set contains interval forms, then it is assumed to be a set of
20269 real numbers. In this case, all set operations require the elements
20270 of the set to be only things that are allowed in intervals: Real
20271 numbers, plus and minus infinity, HMS forms, and date forms. If
20272 there are variables or other non-real objects present in a real set,
20273 all set operations on it will be left in unevaluated form.
20275 If the input to a set operation is a plain number or interval form
20276 @var{a}, it is treated like the one-element vector @samp{[@var{a}]}.
20277 The result is always a vector, except that if the set consists of a
20278 single interval, the interval itself is returned instead.
20280 @xref{Logical Operations}, for the @code{in} function which tests if
20281 a certain value is a member of a given set. To test if the set @expr{A}
20282 is a subset of the set @expr{B}, use @samp{vdiff(A, B) = []}.
20286 @pindex calc-remove-duplicates
20288 The @kbd{V +} (@code{calc-remove-duplicates}) [@code{rdup}] command
20289 converts an arbitrary vector into set notation. It works by sorting
20290 the vector as if by @kbd{V S}, then removing duplicates. (For example,
20291 @kbd{[a, 5, 4, a, 4.0]} is sorted to @samp{[4, 4.0, 5, a, a]} and then
20292 reduced to @samp{[4, 5, a]}). Overlapping intervals are merged as
20293 necessary. You rarely need to use @kbd{V +} explicitly, since all the
20294 other set-based commands apply @kbd{V +} to their inputs before using
20299 @pindex calc-set-union
20301 The @kbd{V V} (@code{calc-set-union}) [@code{vunion}] command computes
20302 the union of two sets. An object is in the union of two sets if and
20303 only if it is in either (or both) of the input sets. (You could
20304 accomplish the same thing by concatenating the sets with @kbd{|},
20305 then using @kbd{V +}.)
20309 @pindex calc-set-intersect
20311 The @kbd{V ^} (@code{calc-set-intersect}) [@code{vint}] command computes
20312 the intersection of two sets. An object is in the intersection if
20313 and only if it is in both of the input sets. Thus if the input
20314 sets are disjoint, i.e., if they share no common elements, the result
20315 will be the empty vector @samp{[]}. Note that the characters @kbd{V}
20316 and @kbd{^} were chosen to be close to the conventional mathematical
20318 @texline union@tie{}(@math{A \cup B})
20321 @texline intersection@tie{}(@math{A \cap B}).
20322 @infoline intersection.
20326 @pindex calc-set-difference
20328 The @kbd{V -} (@code{calc-set-difference}) [@code{vdiff}] command computes
20329 the difference between two sets. An object is in the difference
20330 @expr{A - B} if and only if it is in @expr{A} but not in @expr{B}.
20331 Thus subtracting @samp{[y,z]} from a set will remove the elements
20332 @samp{y} and @samp{z} if they are present. You can also think of this
20333 as a general @dfn{set complement} operator; if @expr{A} is the set of
20334 all possible values, then @expr{A - B} is the ``complement'' of @expr{B}.
20335 Obviously this is only practical if the set of all possible values in
20336 your problem is small enough to list in a Calc vector (or simple
20337 enough to express in a few intervals).
20341 @pindex calc-set-xor
20343 The @kbd{V X} (@code{calc-set-xor}) [@code{vxor}] command computes
20344 the ``exclusive-or,'' or ``symmetric difference'' of two sets.
20345 An object is in the symmetric difference of two sets if and only
20346 if it is in one, but @emph{not} both, of the sets. Objects that
20347 occur in both sets ``cancel out.''
20351 @pindex calc-set-complement
20353 The @kbd{V ~} (@code{calc-set-complement}) [@code{vcompl}] command
20354 computes the complement of a set with respect to the real numbers.
20355 Thus @samp{vcompl(x)} is equivalent to @samp{vdiff([-inf .. inf], x)}.
20356 For example, @samp{vcompl([2, (3 .. 4]])} evaluates to
20357 @samp{[[-inf .. 2), (2 .. 3], (4 .. inf]]}.
20361 @pindex calc-set-floor
20363 The @kbd{V F} (@code{calc-set-floor}) [@code{vfloor}] command
20364 reinterprets a set as a set of integers. Any non-integer values,
20365 and intervals that do not enclose any integers, are removed. Open
20366 intervals are converted to equivalent closed intervals. Successive
20367 integers are converted into intervals of integers. For example, the
20368 complement of the set @samp{[2, 6, 7, 8]} is messy, but if you wanted
20369 the complement with respect to the set of integers you could type
20370 @kbd{V ~ V F} to get @samp{[[-inf .. 1], [3 .. 5], [9 .. inf]]}.
20374 @pindex calc-set-enumerate
20376 The @kbd{V E} (@code{calc-set-enumerate}) [@code{venum}] command
20377 converts a set of integers into an explicit vector. Intervals in
20378 the set are expanded out to lists of all integers encompassed by
20379 the intervals. This only works for finite sets (i.e., sets which
20380 do not involve @samp{-inf} or @samp{inf}).
20384 @pindex calc-set-span
20386 The @kbd{V :} (@code{calc-set-span}) [@code{vspan}] command converts any
20387 set of reals into an interval form that encompasses all its elements.
20388 The lower limit will be the smallest element in the set; the upper
20389 limit will be the largest element. For an empty set, @samp{vspan([])}
20390 returns the empty interval @w{@samp{[0 .. 0)}}.
20394 @pindex calc-set-cardinality
20396 The @kbd{V #} (@code{calc-set-cardinality}) [@code{vcard}] command counts
20397 the number of integers in a set. The result is the length of the vector
20398 that would be produced by @kbd{V E}, although the computation is much
20399 more efficient than actually producing that vector.
20401 @cindex Sets, as binary numbers
20402 Another representation for sets that may be more appropriate in some
20403 cases is binary numbers. If you are dealing with sets of integers
20404 in the range 0 to 49, you can use a 50-bit binary number where a
20405 particular bit is 1 if the corresponding element is in the set.
20406 @xref{Binary Functions}, for a list of commands that operate on
20407 binary numbers. Note that many of the above set operations have
20408 direct equivalents in binary arithmetic: @kbd{b o} (@code{calc-or}),
20409 @kbd{b a} (@code{calc-and}), @kbd{b d} (@code{calc-diff}),
20410 @kbd{b x} (@code{calc-xor}), and @kbd{b n} (@code{calc-not}),
20411 respectively. You can use whatever representation for sets is most
20416 @pindex calc-pack-bits
20417 @pindex calc-unpack-bits
20420 The @kbd{b u} (@code{calc-unpack-bits}) [@code{vunpack}] command
20421 converts an integer that represents a set in binary into a set
20422 in vector/interval notation. For example, @samp{vunpack(67)}
20423 returns @samp{[[0 .. 1], 6]}. If the input is negative, the set
20424 it represents is semi-infinite: @samp{vunpack(-4) = [2 .. inf)}.
20425 Use @kbd{V E} afterwards to expand intervals to individual
20426 values if you wish. Note that this command uses the @kbd{b}
20427 (binary) prefix key.
20429 The @kbd{b p} (@code{calc-pack-bits}) [@code{vpack}] command
20430 converts the other way, from a vector or interval representing
20431 a set of nonnegative integers into a binary integer describing
20432 the same set. The set may include positive infinity, but must
20433 not include any negative numbers. The input is interpreted as a
20434 set of integers in the sense of @kbd{V F} (@code{vfloor}). Beware
20435 that a simple input like @samp{[100]} can result in a huge integer
20437 @texline (@math{2^{100}}, a 31-digit integer, in this case).
20438 @infoline (@expr{2^100}, a 31-digit integer, in this case).
20440 @node Statistical Operations, Reducing and Mapping, Set Operations, Matrix Functions
20441 @section Statistical Operations on Vectors
20444 @cindex Statistical functions
20445 The commands in this section take vectors as arguments and compute
20446 various statistical measures on the data stored in the vectors. The
20447 references used in the definitions of these functions are Bevington's
20448 @emph{Data Reduction and Error Analysis for the Physical Sciences},
20449 and @emph{Numerical Recipes} by Press, Flannery, Teukolsky and
20452 The statistical commands use the @kbd{u} prefix key followed by
20453 a shifted letter or other character.
20455 @xref{Manipulating Vectors}, for a description of @kbd{V H}
20456 (@code{calc-histogram}).
20458 @xref{Curve Fitting}, for the @kbd{a F} command for doing
20459 least-squares fits to statistical data.
20461 @xref{Probability Distribution Functions}, for several common
20462 probability distribution functions.
20465 * Single-Variable Statistics::
20466 * Paired-Sample Statistics::
20469 @node Single-Variable Statistics, Paired-Sample Statistics, Statistical Operations, Statistical Operations
20470 @subsection Single-Variable Statistics
20473 These functions do various statistical computations on single
20474 vectors. Given a numeric prefix argument, they actually pop
20475 @var{n} objects from the stack and combine them into a data
20476 vector. Each object may be either a number or a vector; if a
20477 vector, any sub-vectors inside it are ``flattened'' as if by
20478 @kbd{v a 0}; @pxref{Manipulating Vectors}. By default one object
20479 is popped, which (in order to be useful) is usually a vector.
20481 If an argument is a variable name, and the value stored in that
20482 variable is a vector, then the stored vector is used. This method
20483 has the advantage that if your data vector is large, you can avoid
20484 the slow process of manipulating it directly on the stack.
20486 These functions are left in symbolic form if any of their arguments
20487 are not numbers or vectors, e.g., if an argument is a formula, or
20488 a non-vector variable. However, formulas embedded within vector
20489 arguments are accepted; the result is a symbolic representation
20490 of the computation, based on the assumption that the formula does
20491 not itself represent a vector. All varieties of numbers such as
20492 error forms and interval forms are acceptable.
20494 Some of the functions in this section also accept a single error form
20495 or interval as an argument. They then describe a property of the
20496 normal or uniform (respectively) statistical distribution described
20497 by the argument. The arguments are interpreted in the same way as
20498 the @var{M} argument of the random number function @kbd{k r}. In
20499 particular, an interval with integer limits is considered an integer
20500 distribution, so that @samp{[2 .. 6)} is the same as @samp{[2 .. 5]}.
20501 An interval with at least one floating-point limit is a continuous
20502 distribution: @samp{[2.0 .. 6.0)} is @emph{not} the same as
20503 @samp{[2.0 .. 5.0]}!
20506 @pindex calc-vector-count
20508 The @kbd{u #} (@code{calc-vector-count}) [@code{vcount}] command
20509 computes the number of data values represented by the inputs.
20510 For example, @samp{vcount(1, [2, 3], [[4, 5], [], x, y])} returns 7.
20511 If the argument is a single vector with no sub-vectors, this
20512 simply computes the length of the vector.
20516 @pindex calc-vector-sum
20517 @pindex calc-vector-prod
20520 @cindex Summations (statistical)
20521 The @kbd{u +} (@code{calc-vector-sum}) [@code{vsum}] command
20522 computes the sum of the data values. The @kbd{u *}
20523 (@code{calc-vector-prod}) [@code{vprod}] command computes the
20524 product of the data values. If the input is a single flat vector,
20525 these are the same as @kbd{V R +} and @kbd{V R *}
20526 (@pxref{Reducing and Mapping}).
20530 @pindex calc-vector-max
20531 @pindex calc-vector-min
20534 The @kbd{u X} (@code{calc-vector-max}) [@code{vmax}] command
20535 computes the maximum of the data values, and the @kbd{u N}
20536 (@code{calc-vector-min}) [@code{vmin}] command computes the minimum.
20537 If the argument is an interval, this finds the minimum or maximum
20538 value in the interval. (Note that @samp{vmax([2..6)) = 5} as
20539 described above.) If the argument is an error form, this returns
20540 plus or minus infinity.
20543 @pindex calc-vector-mean
20545 @cindex Mean of data values
20546 The @kbd{u M} (@code{calc-vector-mean}) [@code{vmean}] command
20547 computes the average (arithmetic mean) of the data values.
20548 If the inputs are error forms
20549 @texline @math{x \pm \sigma},
20550 @infoline @samp{x +/- s},
20551 this is the weighted mean of the @expr{x} values with weights
20552 @texline @math{1 /\sigma^2}.
20553 @infoline @expr{1 / s^2}.
20555 $$ \mu = { \displaystyle \sum { x_i \over \sigma_i^2 } \over
20556 \displaystyle \sum { 1 \over \sigma_i^2 } } $$
20558 If the inputs are not error forms, this is simply the sum of the
20559 values divided by the count of the values.
20561 Note that a plain number can be considered an error form with
20563 @texline @math{\sigma = 0}.
20564 @infoline @expr{s = 0}.
20565 If the input to @kbd{u M} is a mixture of
20566 plain numbers and error forms, the result is the mean of the
20567 plain numbers, ignoring all values with non-zero errors. (By the
20568 above definitions it's clear that a plain number effectively
20569 has an infinite weight, next to which an error form with a finite
20570 weight is completely negligible.)
20572 This function also works for distributions (error forms or
20573 intervals). The mean of an error form `@var{a} @tfn{+/-} @var{b}' is simply
20574 @expr{a}. The mean of an interval is the mean of the minimum
20575 and maximum values of the interval.
20578 @pindex calc-vector-mean-error
20580 The @kbd{I u M} (@code{calc-vector-mean-error}) [@code{vmeane}]
20581 command computes the mean of the data points expressed as an
20582 error form. This includes the estimated error associated with
20583 the mean. If the inputs are error forms, the error is the square
20584 root of the reciprocal of the sum of the reciprocals of the squares
20585 of the input errors. (I.e., the variance is the reciprocal of the
20586 sum of the reciprocals of the variances.)
20588 $$ \sigma_\mu^2 = {1 \over \displaystyle \sum {1 \over \sigma_i^2}} $$
20590 If the inputs are plain
20591 numbers, the error is equal to the standard deviation of the values
20592 divided by the square root of the number of values. (This works
20593 out to be equivalent to calculating the standard deviation and
20594 then assuming each value's error is equal to this standard
20597 $$ \sigma_\mu^2 = {\sigma^2 \over N} $$
20601 @pindex calc-vector-median
20603 @cindex Median of data values
20604 The @kbd{H u M} (@code{calc-vector-median}) [@code{vmedian}]
20605 command computes the median of the data values. The values are
20606 first sorted into numerical order; the median is the middle
20607 value after sorting. (If the number of data values is even,
20608 the median is taken to be the average of the two middle values.)
20609 The median function is different from the other functions in
20610 this section in that the arguments must all be real numbers;
20611 variables are not accepted even when nested inside vectors.
20612 (Otherwise it is not possible to sort the data values.) If
20613 any of the input values are error forms, their error parts are
20616 The median function also accepts distributions. For both normal
20617 (error form) and uniform (interval) distributions, the median is
20618 the same as the mean.
20621 @pindex calc-vector-harmonic-mean
20623 @cindex Harmonic mean
20624 The @kbd{H I u M} (@code{calc-vector-harmonic-mean}) [@code{vhmean}]
20625 command computes the harmonic mean of the data values. This is
20626 defined as the reciprocal of the arithmetic mean of the reciprocals
20629 $$ { N \over \displaystyle \sum {1 \over x_i} } $$
20633 @pindex calc-vector-geometric-mean
20635 @cindex Geometric mean
20636 The @kbd{u G} (@code{calc-vector-geometric-mean}) [@code{vgmean}]
20637 command computes the geometric mean of the data values. This
20638 is the @var{n}th root of the product of the values. This is also
20639 equal to the @code{exp} of the arithmetic mean of the logarithms
20640 of the data values.
20642 $$ \exp \left ( \sum { \ln x_i } \right ) =
20643 \left ( \prod { x_i } \right)^{1 / N} $$
20648 The @kbd{H u G} [@code{agmean}] command computes the ``arithmetic-geometric
20649 mean'' of two numbers taken from the stack. This is computed by
20650 replacing the two numbers with their arithmetic mean and geometric
20651 mean, then repeating until the two values converge.
20653 $$ a_{i+1} = { a_i + b_i \over 2 } , \qquad b_{i+1} = \sqrt{a_i b_i} $$
20656 @cindex Root-mean-square
20657 Another commonly used mean, the RMS (root-mean-square), can be computed
20658 for a vector of numbers simply by using the @kbd{A} command.
20661 @pindex calc-vector-sdev
20663 @cindex Standard deviation
20664 @cindex Sample statistics
20665 The @kbd{u S} (@code{calc-vector-sdev}) [@code{vsdev}] command
20666 computes the standard
20667 @texline deviation@tie{}@math{\sigma}
20668 @infoline deviation
20669 of the data values. If the values are error forms, the errors are used
20670 as weights just as for @kbd{u M}. This is the @emph{sample} standard
20671 deviation, whose value is the square root of the sum of the squares of
20672 the differences between the values and the mean of the @expr{N} values,
20673 divided by @expr{N-1}.
20675 $$ \sigma^2 = {1 \over N - 1} \sum (x_i - \mu)^2 $$
20678 This function also applies to distributions. The standard deviation
20679 of a single error form is simply the error part. The standard deviation
20680 of a continuous interval happens to equal the difference between the
20682 @texline @math{\sqrt{12}}.
20683 @infoline @expr{sqrt(12)}.
20684 The standard deviation of an integer interval is the same as the
20685 standard deviation of a vector of those integers.
20688 @pindex calc-vector-pop-sdev
20690 @cindex Population statistics
20691 The @kbd{I u S} (@code{calc-vector-pop-sdev}) [@code{vpsdev}]
20692 command computes the @emph{population} standard deviation.
20693 It is defined by the same formula as above but dividing
20694 by @expr{N} instead of by @expr{N-1}. The population standard
20695 deviation is used when the input represents the entire set of
20696 data values in the distribution; the sample standard deviation
20697 is used when the input represents a sample of the set of all
20698 data values, so that the mean computed from the input is itself
20699 only an estimate of the true mean.
20701 $$ \sigma^2 = {1 \over N} \sum (x_i - \mu)^2 $$
20704 For error forms and continuous intervals, @code{vpsdev} works
20705 exactly like @code{vsdev}. For integer intervals, it computes the
20706 population standard deviation of the equivalent vector of integers.
20710 @pindex calc-vector-variance
20711 @pindex calc-vector-pop-variance
20714 @cindex Variance of data values
20715 The @kbd{H u S} (@code{calc-vector-variance}) [@code{vvar}] and
20716 @kbd{H I u S} (@code{calc-vector-pop-variance}) [@code{vpvar}]
20717 commands compute the variance of the data values. The variance
20719 @texline square@tie{}@math{\sigma^2}
20721 of the standard deviation, i.e., the sum of the
20722 squares of the deviations of the data values from the mean.
20723 (This definition also applies when the argument is a distribution.)
20729 The @code{vflat} algebraic function returns a vector of its
20730 arguments, interpreted in the same way as the other functions
20731 in this section. For example, @samp{vflat(1, [2, [3, 4]], 5)}
20732 returns @samp{[1, 2, 3, 4, 5]}.
20734 @node Paired-Sample Statistics, , Single-Variable Statistics, Statistical Operations
20735 @subsection Paired-Sample Statistics
20738 The functions in this section take two arguments, which must be
20739 vectors of equal size. The vectors are each flattened in the same
20740 way as by the single-variable statistical functions. Given a numeric
20741 prefix argument of 1, these functions instead take one object from
20742 the stack, which must be an
20743 @texline @math{N\times2}
20745 matrix of data values. Once again, variable names can be used in place
20746 of actual vectors and matrices.
20749 @pindex calc-vector-covariance
20752 The @kbd{u C} (@code{calc-vector-covariance}) [@code{vcov}] command
20753 computes the sample covariance of two vectors. The covariance
20754 of vectors @var{x} and @var{y} is the sum of the products of the
20755 differences between the elements of @var{x} and the mean of @var{x}
20756 times the differences between the corresponding elements of @var{y}
20757 and the mean of @var{y}, all divided by @expr{N-1}. Note that
20758 the variance of a vector is just the covariance of the vector
20759 with itself. Once again, if the inputs are error forms the
20760 errors are used as weight factors. If both @var{x} and @var{y}
20761 are composed of error forms, the error for a given data point
20762 is taken as the square root of the sum of the squares of the two
20765 $$ \sigma_{x\!y}^2 = {1 \over N-1} \sum (x_i - \mu_x) (y_i - \mu_y) $$
20766 $$ \sigma_{x\!y}^2 =
20767 {\displaystyle {1 \over N-1}
20768 \sum {(x_i - \mu_x) (y_i - \mu_y) \over \sigma_i^2}
20769 \over \displaystyle {1 \over N} \sum {1 \over \sigma_i^2}}
20774 @pindex calc-vector-pop-covariance
20776 The @kbd{I u C} (@code{calc-vector-pop-covariance}) [@code{vpcov}]
20777 command computes the population covariance, which is the same as the
20778 sample covariance computed by @kbd{u C} except dividing by @expr{N}
20779 instead of @expr{N-1}.
20782 @pindex calc-vector-correlation
20784 @cindex Correlation coefficient
20785 @cindex Linear correlation
20786 The @kbd{H u C} (@code{calc-vector-correlation}) [@code{vcorr}]
20787 command computes the linear correlation coefficient of two vectors.
20788 This is defined by the covariance of the vectors divided by the
20789 product of their standard deviations. (There is no difference
20790 between sample or population statistics here.)
20792 $$ r_{x\!y} = { \sigma_{x\!y}^2 \over \sigma_x^2 \sigma_y^2 } $$
20795 @node Reducing and Mapping, Vector and Matrix Formats, Statistical Operations, Matrix Functions
20796 @section Reducing and Mapping Vectors
20799 The commands in this section allow for more general operations on the
20800 elements of vectors.
20806 The simplest of these operations is @kbd{V A} (@code{calc-apply})
20807 [@code{apply}], which applies a given operator to the elements of a vector.
20808 For example, applying the hypothetical function @code{f} to the vector
20809 @w{@samp{[1, 2, 3]}} would produce the function call @samp{f(1, 2, 3)}.
20810 Applying the @code{+} function to the vector @samp{[a, b]} gives
20811 @samp{a + b}. Applying @code{+} to the vector @samp{[a, b, c]} is an
20812 error, since the @code{+} function expects exactly two arguments.
20814 While @kbd{V A} is useful in some cases, you will usually find that either
20815 @kbd{V R} or @kbd{V M}, described below, is closer to what you want.
20818 * Specifying Operators::
20821 * Nesting and Fixed Points::
20822 * Generalized Products::
20825 @node Specifying Operators, Mapping, Reducing and Mapping, Reducing and Mapping
20826 @subsection Specifying Operators
20829 Commands in this section (like @kbd{V A}) prompt you to press the key
20830 corresponding to the desired operator. Press @kbd{?} for a partial
20831 list of the available operators. Generally, an operator is any key or
20832 sequence of keys that would normally take one or more arguments from
20833 the stack and replace them with a result. For example, @kbd{V A H C}
20834 uses the hyperbolic cosine operator, @code{cosh}. (Since @code{cosh}
20835 expects one argument, @kbd{V A H C} requires a vector with a single
20836 element as its argument.)
20838 You can press @kbd{x} at the operator prompt to select any algebraic
20839 function by name to use as the operator. This includes functions you
20840 have defined yourself using the @kbd{Z F} command. (@xref{Algebraic
20841 Definitions}.) If you give a name for which no function has been
20842 defined, the result is left in symbolic form, as in @samp{f(1, 2, 3)}.
20843 Calc will prompt for the number of arguments the function takes if it
20844 can't figure it out on its own (say, because you named a function that
20845 is currently undefined). It is also possible to type a digit key before
20846 the function name to specify the number of arguments, e.g.,
20847 @kbd{V M 3 x f @key{RET}} calls @code{f} with three arguments even if it
20848 looks like it ought to have only two. This technique may be necessary
20849 if the function allows a variable number of arguments. For example,
20850 the @kbd{v e} [@code{vexp}] function accepts two or three arguments;
20851 if you want to map with the three-argument version, you will have to
20852 type @kbd{V M 3 v e}.
20854 It is also possible to apply any formula to a vector by treating that
20855 formula as a function. When prompted for the operator to use, press
20856 @kbd{'} (the apostrophe) and type your formula as an algebraic entry.
20857 You will then be prompted for the argument list, which defaults to a
20858 list of all variables that appear in the formula, sorted into alphabetic
20859 order. For example, suppose you enter the formula @w{@samp{x + 2y^x}}.
20860 The default argument list would be @samp{(x y)}, which means that if
20861 this function is applied to the arguments @samp{[3, 10]} the result will
20862 be @samp{3 + 2*10^3}. (If you plan to use a certain formula in this
20863 way often, you might consider defining it as a function with @kbd{Z F}.)
20865 Another way to specify the arguments to the formula you enter is with
20866 @kbd{$}, @kbd{$$}, and so on. For example, @kbd{V A ' $$ + 2$^$$}
20867 has the same effect as the previous example. The argument list is
20868 automatically taken to be @samp{($$ $)}. (The order of the arguments
20869 may seem backwards, but it is analogous to the way normal algebraic
20870 entry interacts with the stack.)
20872 If you press @kbd{$} at the operator prompt, the effect is similar to
20873 the apostrophe except that the relevant formula is taken from top-of-stack
20874 instead. The actual vector arguments of the @kbd{V A $} or related command
20875 then start at the second-to-top stack position. You will still be
20876 prompted for an argument list.
20878 @cindex Nameless functions
20879 @cindex Generic functions
20880 A function can be written without a name using the notation @samp{<#1 - #2>},
20881 which means ``a function of two arguments that computes the first
20882 argument minus the second argument.'' The symbols @samp{#1} and @samp{#2}
20883 are placeholders for the arguments. You can use any names for these
20884 placeholders if you wish, by including an argument list followed by a
20885 colon: @samp{<x, y : x - y>}. When you type @kbd{V A ' $$ + 2$^$$ @key{RET}},
20886 Calc builds the nameless function @samp{<#1 + 2 #2^#1>} as the function
20887 to map across the vectors. When you type @kbd{V A ' x + 2y^x @key{RET} @key{RET}},
20888 Calc builds the nameless function @w{@samp{<x, y : x + 2 y^x>}}. In both
20889 cases, Calc also writes the nameless function to the Trail so that you
20890 can get it back later if you wish.
20892 If there is only one argument, you can write @samp{#} in place of @samp{#1}.
20893 (Note that @samp{< >} notation is also used for date forms. Calc tells
20894 that @samp{<@var{stuff}>} is a nameless function by the presence of
20895 @samp{#} signs inside @var{stuff}, or by the fact that @var{stuff}
20896 begins with a list of variables followed by a colon.)
20898 You can type a nameless function directly to @kbd{V A '}, or put one on
20899 the stack and use it with @w{@kbd{V A $}}. Calc will not prompt for an
20900 argument list in this case, since the nameless function specifies the
20901 argument list as well as the function itself. In @kbd{V A '}, you can
20902 omit the @samp{< >} marks if you use @samp{#} notation for the arguments,
20903 so that @kbd{V A ' #1+#2 @key{RET}} is the same as @kbd{V A ' <#1+#2> @key{RET}},
20904 which in turn is the same as @kbd{V A ' $$+$ @key{RET}}.
20906 @cindex Lambda expressions
20911 The internal format for @samp{<x, y : x + y>} is @samp{lambda(x, y, x + y)}.
20912 (The word @code{lambda} derives from Lisp notation and the theory of
20913 functions.) The internal format for @samp{<#1 + #2>} is @samp{lambda(ArgA,
20914 ArgB, ArgA + ArgB)}. Note that there is no actual Calc function called
20915 @code{lambda}; the whole point is that the @code{lambda} expression is
20916 used in its symbolic form, not evaluated for an answer until it is applied
20917 to specific arguments by a command like @kbd{V A} or @kbd{V M}.
20919 (Actually, @code{lambda} does have one special property: Its arguments
20920 are never evaluated; for example, putting @samp{<(2/3) #>} on the stack
20921 will not simplify the @samp{2/3} until the nameless function is actually
20950 As usual, commands like @kbd{V A} have algebraic function name equivalents.
20951 For example, @kbd{V A k g} with an argument of @samp{v} is equivalent to
20952 @samp{apply(gcd, v)}. The first argument specifies the operator name,
20953 and is either a variable whose name is the same as the function name,
20954 or a nameless function like @samp{<#^3+1>}. Operators that are normally
20955 written as algebraic symbols have the names @code{add}, @code{sub},
20956 @code{mul}, @code{div}, @code{pow}, @code{neg}, @code{mod}, and
20963 The @code{call} function builds a function call out of several arguments:
20964 @samp{call(gcd, x, y)} is the same as @samp{apply(gcd, [x, y])}, which
20965 in turn is the same as @samp{gcd(x, y)}. The first argument of @code{call},
20966 like the other functions described here, may be either a variable naming a
20967 function, or a nameless function (@samp{call(<#1+2#2>, x, y)} is the same
20970 (Experts will notice that it's not quite proper to use a variable to name
20971 a function, since the name @code{gcd} corresponds to the Lisp variable
20972 @code{var-gcd} but to the Lisp function @code{calcFunc-gcd}. Calc
20973 automatically makes this translation, so you don't have to worry
20976 @node Mapping, Reducing, Specifying Operators, Reducing and Mapping
20977 @subsection Mapping
20984 The @kbd{V M} (@code{calc-map}) [@code{map}] command applies a given
20985 operator elementwise to one or more vectors. For example, mapping
20986 @code{A} [@code{abs}] produces a vector of the absolute values of the
20987 elements in the input vector. Mapping @code{+} pops two vectors from
20988 the stack, which must be of equal length, and produces a vector of the
20989 pairwise sums of the elements. If either argument is a non-vector, it
20990 is duplicated for each element of the other vector. For example,
20991 @kbd{[1,2,3] 2 V M ^} squares the elements of the specified vector.
20992 With the 2 listed first, it would have computed a vector of powers of
20993 two. Mapping a user-defined function pops as many arguments from the
20994 stack as the function requires. If you give an undefined name, you will
20995 be prompted for the number of arguments to use.
20997 If any argument to @kbd{V M} is a matrix, the operator is normally mapped
20998 across all elements of the matrix. For example, given the matrix
20999 @expr{[[1, -2, 3], [-4, 5, -6]]}, @kbd{V M A} takes six absolute values to
21001 @texline @math{3\times2}
21003 matrix, @expr{[[1, 2, 3], [4, 5, 6]]}.
21006 The command @kbd{V M _} [@code{mapr}] (i.e., type an underscore at the
21007 operator prompt) maps by rows instead. For example, @kbd{V M _ A} views
21008 the above matrix as a vector of two 3-element row vectors. It produces
21009 a new vector which contains the absolute values of those row vectors,
21010 namely @expr{[3.74, 8.77]}. (Recall, the absolute value of a vector is
21011 defined as the square root of the sum of the squares of the elements.)
21012 Some operators accept vectors and return new vectors; for example,
21013 @kbd{v v} reverses a vector, so @kbd{V M _ v v} would reverse each row
21014 of the matrix to get a new matrix, @expr{[[3, -2, 1], [-6, 5, -4]]}.
21016 Sometimes a vector of vectors (representing, say, strings, sets, or lists)
21017 happens to look like a matrix. If so, remember to use @kbd{V M _} if you
21018 want to map a function across the whole strings or sets rather than across
21019 their individual elements.
21022 The command @kbd{V M :} [@code{mapc}] maps by columns. Basically, it
21023 transposes the input matrix, maps by rows, and then, if the result is a
21024 matrix, transposes again. For example, @kbd{V M : A} takes the absolute
21025 values of the three columns of the matrix, treating each as a 2-vector,
21026 and @kbd{V M : v v} reverses the columns to get the matrix
21027 @expr{[[-4, 5, -6], [1, -2, 3]]}.
21029 (The symbols @kbd{_} and @kbd{:} were chosen because they had row-like
21030 and column-like appearances, and were not already taken by useful
21031 operators. Also, they appear shifted on most keyboards so they are easy
21032 to type after @kbd{V M}.)
21034 The @kbd{_} and @kbd{:} modifiers have no effect on arguments that are
21035 not matrices (so if none of the arguments are matrices, they have no
21036 effect at all). If some of the arguments are matrices and others are
21037 plain numbers, the plain numbers are held constant for all rows of the
21038 matrix (so that @kbd{2 V M _ ^} squares every row of a matrix; squaring
21039 a vector takes a dot product of the vector with itself).
21041 If some of the arguments are vectors with the same lengths as the
21042 rows (for @kbd{V M _}) or columns (for @kbd{V M :}) of the matrix
21043 arguments, those vectors are also held constant for every row or
21046 Sometimes it is useful to specify another mapping command as the operator
21047 to use with @kbd{V M}. For example, @kbd{V M _ V A +} applies @kbd{V A +}
21048 to each row of the input matrix, which in turn adds the two values on that
21049 row. If you give another vector-operator command as the operator for
21050 @kbd{V M}, it automatically uses map-by-rows mode if you don't specify
21051 otherwise; thus @kbd{V M V A +} is equivalent to @kbd{V M _ V A +}. (If
21052 you really want to map-by-elements another mapping command, you can use
21053 a triple-nested mapping command: @kbd{V M V M V A +} means to map
21054 @kbd{V M V A +} over the rows of the matrix; in turn, @kbd{V A +} is
21055 mapped over the elements of each row.)
21059 Previous versions of Calc had ``map across'' and ``map down'' modes
21060 that are now considered obsolete; the old ``map across'' is now simply
21061 @kbd{V M V A}, and ``map down'' is now @kbd{V M : V A}. The algebraic
21062 functions @code{mapa} and @code{mapd} are still supported, though.
21063 Note also that, while the old mapping modes were persistent (once you
21064 set the mode, it would apply to later mapping commands until you reset
21065 it), the new @kbd{:} and @kbd{_} modifiers apply only to the current
21066 mapping command. The default @kbd{V M} always means map-by-elements.
21068 @xref{Algebraic Manipulation}, for the @kbd{a M} command, which is like
21069 @kbd{V M} but for equations and inequalities instead of vectors.
21070 @xref{Storing Variables}, for the @kbd{s m} command which modifies a
21071 variable's stored value using a @kbd{V M}-like operator.
21073 @node Reducing, Nesting and Fixed Points, Mapping, Reducing and Mapping
21074 @subsection Reducing
21079 @pindex calc-reduce
21081 The @kbd{V R} (@code{calc-reduce}) [@code{reduce}] command applies a given
21082 binary operator across all the elements of a vector. A binary operator is
21083 a function such as @code{+} or @code{max} which takes two arguments. For
21084 example, reducing @code{+} over a vector computes the sum of the elements
21085 of the vector. Reducing @code{-} computes the first element minus each of
21086 the remaining elements. Reducing @code{max} computes the maximum element
21087 and so on. In general, reducing @code{f} over the vector @samp{[a, b, c, d]}
21088 produces @samp{f(f(f(a, b), c), d)}.
21093 The @kbd{I V R} [@code{rreduce}] command is similar to @kbd{V R} except
21094 that works from right to left through the vector. For example, plain
21095 @kbd{V R -} on the vector @samp{[a, b, c, d]} produces @samp{a - b - c - d}
21096 but @kbd{I V R -} on the same vector produces @samp{a - (b - (c - d))},
21097 or @samp{a - b + c - d}. This ``alternating sum'' occurs frequently
21098 in power series expansions.
21103 The @kbd{V U} (@code{calc-accumulate}) [@code{accum}] command does an
21104 accumulation operation. Here Calc does the corresponding reduction
21105 operation, but instead of producing only the final result, it produces
21106 a vector of all the intermediate results. Accumulating @code{+} over
21107 the vector @samp{[a, b, c, d]} produces the vector
21108 @samp{[a, a + b, a + b + c, a + b + c + d]}.
21113 The @kbd{I V U} [@code{raccum}] command does a right-to-left accumulation.
21114 For example, @kbd{I V U -} on the vector @samp{[a, b, c, d]} produces the
21115 vector @samp{[a - b + c - d, b - c + d, c - d, d]}.
21121 As for @kbd{V M}, @kbd{V R} normally reduces a matrix elementwise. For
21122 example, given the matrix @expr{[[a, b, c], [d, e, f]]}, @kbd{V R +} will
21123 compute @expr{a + b + c + d + e + f}. You can type @kbd{V R _} or
21124 @kbd{V R :} to modify this behavior. The @kbd{V R _} [@code{reducea}]
21125 command reduces ``across'' the matrix; it reduces each row of the matrix
21126 as a vector, then collects the results. Thus @kbd{V R _ +} of this
21127 matrix would produce @expr{[a + b + c, d + e + f]}. Similarly, @kbd{V R :}
21128 [@code{reduced}] reduces down; @kbd{V R : +} would produce @expr{[a + d,
21133 There is a third ``by rows'' mode for reduction that is occasionally
21134 useful; @kbd{V R =} [@code{reducer}] simply reduces the operator over
21135 the rows of the matrix themselves. Thus @kbd{V R = +} on the above
21136 matrix would get the same result as @kbd{V R : +}, since adding two
21137 row vectors is equivalent to adding their elements. But @kbd{V R = *}
21138 would multiply the two rows (to get a single number, their dot product),
21139 while @kbd{V R : *} would produce a vector of the products of the columns.
21141 These three matrix reduction modes work with @kbd{V R} and @kbd{I V R},
21142 but they are not currently supported with @kbd{V U} or @kbd{I V U}.
21146 The obsolete reduce-by-columns function, @code{reducec}, is still
21147 supported but there is no way to get it through the @kbd{V R} command.
21149 The commands @kbd{C-x * :} and @kbd{C-x * _} are equivalent to typing
21150 @kbd{C-x * r} to grab a rectangle of data into Calc, and then typing
21151 @kbd{V R : +} or @kbd{V R _ +}, respectively, to sum the columns or
21152 rows of the matrix. @xref{Grabbing From Buffers}.
21154 @node Nesting and Fixed Points, Generalized Products, Reducing, Reducing and Mapping
21155 @subsection Nesting and Fixed Points
21161 The @kbd{H V R} [@code{nest}] command applies a function to a given
21162 argument repeatedly. It takes two values, @samp{a} and @samp{n}, from
21163 the stack, where @samp{n} must be an integer. It then applies the
21164 function nested @samp{n} times; if the function is @samp{f} and @samp{n}
21165 is 3, the result is @samp{f(f(f(a)))}. The number @samp{n} may be
21166 negative if Calc knows an inverse for the function @samp{f}; for
21167 example, @samp{nest(sin, a, -2)} returns @samp{arcsin(arcsin(a))}.
21172 The @kbd{H V U} [@code{anest}] command is an accumulating version of
21173 @code{nest}: It returns a vector of @samp{n+1} values, e.g.,
21174 @samp{[a, f(a), f(f(a)), f(f(f(a)))]}. If @samp{n} is negative and
21175 @samp{F} is the inverse of @samp{f}, then the result is of the
21176 form @samp{[a, F(a), F(F(a)), F(F(F(a)))]}.
21181 @cindex Fixed points
21182 The @kbd{H I V R} [@code{fixp}] command is like @kbd{H V R}, except
21183 that it takes only an @samp{a} value from the stack; the function is
21184 applied until it reaches a ``fixed point,'' i.e., until the result
21190 The @kbd{H I V U} [@code{afixp}] command is an accumulating @code{fixp}.
21191 The first element of the return vector will be the initial value @samp{a};
21192 the last element will be the final result that would have been returned
21195 For example, 0.739085 is a fixed point of the cosine function (in radians):
21196 @samp{cos(0.739085) = 0.739085}. You can find this value by putting, say,
21197 1.0 on the stack and typing @kbd{H I V U C}. (We use the accumulating
21198 version so we can see the intermediate results: @samp{[1, 0.540302, 0.857553,
21199 0.65329, ...]}. With a precision of six, this command will take 36 steps
21200 to converge to 0.739085.)
21202 Newton's method for finding roots is a classic example of iteration
21203 to a fixed point. To find the square root of five starting with an
21204 initial guess, Newton's method would look for a fixed point of the
21205 function @samp{(x + 5/x) / 2}. Putting a guess of 1 on the stack
21206 and typing @kbd{H I V R ' ($ + 5/$)/2 @key{RET}} quickly yields the result
21207 2.23607. This is equivalent to using the @kbd{a R} (@code{calc-find-root})
21208 command to find a root of the equation @samp{x^2 = 5}.
21210 These examples used numbers for @samp{a} values. Calc keeps applying
21211 the function until two successive results are equal to within the
21212 current precision. For complex numbers, both the real parts and the
21213 imaginary parts must be equal to within the current precision. If
21214 @samp{a} is a formula (say, a variable name), then the function is
21215 applied until two successive results are exactly the same formula.
21216 It is up to you to ensure that the function will eventually converge;
21217 if it doesn't, you may have to press @kbd{C-g} to stop the Calculator.
21219 The algebraic @code{fixp} function takes two optional arguments, @samp{n}
21220 and @samp{tol}. The first is the maximum number of steps to be allowed,
21221 and must be either an integer or the symbol @samp{inf} (infinity, the
21222 default). The second is a convergence tolerance. If a tolerance is
21223 specified, all results during the calculation must be numbers, not
21224 formulas, and the iteration stops when the magnitude of the difference
21225 between two successive results is less than or equal to the tolerance.
21226 (This implies that a tolerance of zero iterates until the results are
21229 Putting it all together, @samp{fixp(<(# + A/#)/2>, B, 20, 1e-10)}
21230 computes the square root of @samp{A} given the initial guess @samp{B},
21231 stopping when the result is correct within the specified tolerance, or
21232 when 20 steps have been taken, whichever is sooner.
21234 @node Generalized Products, , Nesting and Fixed Points, Reducing and Mapping
21235 @subsection Generalized Products
21239 @pindex calc-outer-product
21241 The @kbd{V O} (@code{calc-outer-product}) [@code{outer}] command applies
21242 a given binary operator to all possible pairs of elements from two
21243 vectors, to produce a matrix. For example, @kbd{V O *} with @samp{[a, b]}
21244 and @samp{[x, y, z]} on the stack produces a multiplication table:
21245 @samp{[[a x, a y, a z], [b x, b y, b z]]}. Element @var{r},@var{c} of
21246 the result matrix is obtained by applying the operator to element @var{r}
21247 of the lefthand vector and element @var{c} of the righthand vector.
21251 @pindex calc-inner-product
21253 The @kbd{V I} (@code{calc-inner-product}) [@code{inner}] command computes
21254 the generalized inner product of two vectors or matrices, given a
21255 ``multiplicative'' operator and an ``additive'' operator. These can each
21256 actually be any binary operators; if they are @samp{*} and @samp{+},
21257 respectively, the result is a standard matrix multiplication. Element
21258 @var{r},@var{c} of the result matrix is obtained by mapping the
21259 multiplicative operator across row @var{r} of the lefthand matrix and
21260 column @var{c} of the righthand matrix, and then reducing with the additive
21261 operator. Just as for the standard @kbd{*} command, this can also do a
21262 vector-matrix or matrix-vector inner product, or a vector-vector
21263 generalized dot product.
21265 Since @kbd{V I} requires two operators, it prompts twice. In each case,
21266 you can use any of the usual methods for entering the operator. If you
21267 use @kbd{$} twice to take both operator formulas from the stack, the
21268 first (multiplicative) operator is taken from the top of the stack
21269 and the second (additive) operator is taken from second-to-top.
21271 @node Vector and Matrix Formats, , Reducing and Mapping, Matrix Functions
21272 @section Vector and Matrix Display Formats
21275 Commands for controlling vector and matrix display use the @kbd{v} prefix
21276 instead of the usual @kbd{d} prefix. But they are display modes; in
21277 particular, they are influenced by the @kbd{I} and @kbd{H} prefix keys
21278 in the same way (@pxref{Display Modes}). Matrix display is also
21279 influenced by the @kbd{d O} (@code{calc-flat-language}) mode;
21280 @pxref{Normal Language Modes}.
21284 @pindex calc-matrix-left-justify
21287 @pindex calc-matrix-center-justify
21290 @pindex calc-matrix-right-justify
21291 The commands @kbd{v <} (@code{calc-matrix-left-justify}), @kbd{v >}
21292 (@code{calc-matrix-right-justify}), and @w{@kbd{v =}}
21293 (@code{calc-matrix-center-justify}) control whether matrix elements
21294 are justified to the left, right, or center of their columns.
21298 @pindex calc-vector-brackets
21301 @pindex calc-vector-braces
21304 @pindex calc-vector-parens
21305 The @kbd{v [} (@code{calc-vector-brackets}) command turns the square
21306 brackets that surround vectors and matrices displayed in the stack on
21307 and off. The @kbd{v @{} (@code{calc-vector-braces}) and @kbd{v (}
21308 (@code{calc-vector-parens}) commands use curly braces or parentheses,
21309 respectively, instead of square brackets. For example, @kbd{v @{} might
21310 be used in preparation for yanking a matrix into a buffer running
21311 Mathematica. (In fact, the Mathematica language mode uses this mode;
21312 @pxref{Mathematica Language Mode}.) Note that, regardless of the
21313 display mode, either brackets or braces may be used to enter vectors,
21314 and parentheses may never be used for this purpose.
21322 @pindex calc-matrix-brackets
21323 The @kbd{v ]} (@code{calc-matrix-brackets}) command controls the
21324 ``big'' style display of matrices, for matrices which have more than
21325 one row. It prompts for a string of code letters; currently
21326 implemented letters are @code{R}, which enables brackets on each row
21327 of the matrix; @code{O}, which enables outer brackets in opposite
21328 corners of the matrix; and @code{C}, which enables commas or
21329 semicolons at the ends of all rows but the last. The default format
21330 is @samp{RO}. (Before Calc 2.00, the format was fixed at @samp{ROC}.)
21331 Here are some example matrices:
21335 [ [ 123, 0, 0 ] [ [ 123, 0, 0 ],
21336 [ 0, 123, 0 ] [ 0, 123, 0 ],
21337 [ 0, 0, 123 ] ] [ 0, 0, 123 ] ]
21346 [ 123, 0, 0 [ 123, 0, 0 ;
21347 0, 123, 0 0, 123, 0 ;
21348 0, 0, 123 ] 0, 0, 123 ]
21357 [ 123, 0, 0 ] 123, 0, 0
21358 [ 0, 123, 0 ] 0, 123, 0
21359 [ 0, 0, 123 ] 0, 0, 123
21366 Note that of the formats shown here, @samp{RO}, @samp{ROC}, and
21367 @samp{OC} are all recognized as matrices during reading, while
21368 the others are useful for display only.
21372 @pindex calc-vector-commas
21373 The @kbd{v ,} (@code{calc-vector-commas}) command turns commas on and
21374 off in vector and matrix display.
21376 In vectors of length one, and in all vectors when commas have been
21377 turned off, Calc adds extra parentheses around formulas that might
21378 otherwise be ambiguous. For example, @samp{[a b]} could be a vector
21379 of the one formula @samp{a b}, or it could be a vector of two
21380 variables with commas turned off. Calc will display the former
21381 case as @samp{[(a b)]}. You can disable these extra parentheses
21382 (to make the output less cluttered at the expense of allowing some
21383 ambiguity) by adding the letter @code{P} to the control string you
21384 give to @kbd{v ]} (as described above).
21388 @pindex calc-full-vectors
21389 The @kbd{v .} (@code{calc-full-vectors}) command turns abbreviated
21390 display of long vectors on and off. In this mode, vectors of six
21391 or more elements, or matrices of six or more rows or columns, will
21392 be displayed in an abbreviated form that displays only the first
21393 three elements and the last element: @samp{[a, b, c, ..., z]}.
21394 When very large vectors are involved this will substantially
21395 improve Calc's display speed.
21398 @pindex calc-full-trail-vectors
21399 The @kbd{t .} (@code{calc-full-trail-vectors}) command controls a
21400 similar mode for recording vectors in the Trail. If you turn on
21401 this mode, vectors of six or more elements and matrices of six or
21402 more rows or columns will be abbreviated when they are put in the
21403 Trail. The @kbd{t y} (@code{calc-trail-yank}) command will be
21404 unable to recover those vectors. If you are working with very
21405 large vectors, this mode will improve the speed of all operations
21406 that involve the trail.
21410 @pindex calc-break-vectors
21411 The @kbd{v /} (@code{calc-break-vectors}) command turns multi-line
21412 vector display on and off. Normally, matrices are displayed with one
21413 row per line but all other types of vectors are displayed in a single
21414 line. This mode causes all vectors, whether matrices or not, to be
21415 displayed with a single element per line. Sub-vectors within the
21416 vectors will still use the normal linear form.
21418 @node Algebra, Units, Matrix Functions, Top
21422 This section covers the Calc features that help you work with
21423 algebraic formulas. First, the general sub-formula selection
21424 mechanism is described; this works in conjunction with any Calc
21425 commands. Then, commands for specific algebraic operations are
21426 described. Finally, the flexible @dfn{rewrite rule} mechanism
21429 The algebraic commands use the @kbd{a} key prefix; selection
21430 commands use the @kbd{j} (for ``just a letter that wasn't used
21431 for anything else'') prefix.
21433 @xref{Editing Stack Entries}, to see how to manipulate formulas
21434 using regular Emacs editing commands.
21436 When doing algebraic work, you may find several of the Calculator's
21437 modes to be helpful, including Algebraic Simplification mode (@kbd{m A})
21438 or No-Simplification mode (@kbd{m O}),
21439 Algebraic entry mode (@kbd{m a}), Fraction mode (@kbd{m f}), and
21440 Symbolic mode (@kbd{m s}). @xref{Mode Settings}, for discussions
21441 of these modes. You may also wish to select Big display mode (@kbd{d B}).
21442 @xref{Normal Language Modes}.
21445 * Selecting Subformulas::
21446 * Algebraic Manipulation::
21447 * Simplifying Formulas::
21450 * Solving Equations::
21451 * Numerical Solutions::
21454 * Logical Operations::
21458 @node Selecting Subformulas, Algebraic Manipulation, Algebra, Algebra
21459 @section Selecting Sub-Formulas
21463 @cindex Sub-formulas
21464 @cindex Parts of formulas
21465 When working with an algebraic formula it is often necessary to
21466 manipulate a portion of the formula rather than the formula as a
21467 whole. Calc allows you to ``select'' a portion of any formula on
21468 the stack. Commands which would normally operate on that stack
21469 entry will now operate only on the sub-formula, leaving the
21470 surrounding part of the stack entry alone.
21472 One common non-algebraic use for selection involves vectors. To work
21473 on one element of a vector in-place, simply select that element as a
21474 ``sub-formula'' of the vector.
21477 * Making Selections::
21478 * Changing Selections::
21479 * Displaying Selections::
21480 * Operating on Selections::
21481 * Rearranging with Selections::
21484 @node Making Selections, Changing Selections, Selecting Subformulas, Selecting Subformulas
21485 @subsection Making Selections
21489 @pindex calc-select-here
21490 To select a sub-formula, move the Emacs cursor to any character in that
21491 sub-formula, and press @w{@kbd{j s}} (@code{calc-select-here}). Calc will
21492 highlight the smallest portion of the formula that contains that
21493 character. By default the sub-formula is highlighted by blanking out
21494 all of the rest of the formula with dots. Selection works in any
21495 display mode but is perhaps easiest in Big mode (@kbd{d B}).
21496 Suppose you enter the following formula:
21508 (by typing @kbd{' ((a+b)^3 + sqrt(c)) / (2x+1)}). If you move the
21509 cursor to the letter @samp{b} and press @w{@kbd{j s}}, the display changes
21522 Every character not part of the sub-formula @samp{b} has been changed
21523 to a dot. (If the customizable variable
21524 @code{calc-highlight-selections-with-faces} is non-nil, then the characters
21525 not part of the sub-formula are de-emphasized by using a less
21526 noticeable face instead of using dots. @pxref{Displaying Selections}.)
21527 The @samp{*} next to the line number is to remind you that
21528 the formula has a portion of it selected. (In this case, it's very
21529 obvious, but it might not always be. If Embedded mode is enabled,
21530 the word @samp{Sel} also appears in the mode line because the stack
21531 may not be visible. @pxref{Embedded Mode}.)
21533 If you had instead placed the cursor on the parenthesis immediately to
21534 the right of the @samp{b}, the selection would have been:
21546 The portion selected is always large enough to be considered a complete
21547 formula all by itself, so selecting the parenthesis selects the whole
21548 formula that it encloses. Putting the cursor on the @samp{+} sign
21549 would have had the same effect.
21551 (Strictly speaking, the Emacs cursor is really the manifestation of
21552 the Emacs ``point,'' which is a position @emph{between} two characters
21553 in the buffer. So purists would say that Calc selects the smallest
21554 sub-formula which contains the character to the right of ``point.'')
21556 If you supply a numeric prefix argument @var{n}, the selection is
21557 expanded to the @var{n}th enclosing sub-formula. Thus, positioning
21558 the cursor on the @samp{b} and typing @kbd{C-u 1 j s} will select
21559 @samp{a + b}; typing @kbd{C-u 2 j s} will select @samp{(a + b)^3},
21562 If the cursor is not on any part of the formula, or if you give a
21563 numeric prefix that is too large, the entire formula is selected.
21565 If the cursor is on the @samp{.} line that marks the top of the stack
21566 (i.e., its normal ``rest position''), this command selects the entire
21567 formula at stack level 1. Most selection commands similarly operate
21568 on the formula at the top of the stack if you haven't positioned the
21569 cursor on any stack entry.
21572 @pindex calc-select-additional
21573 The @kbd{j a} (@code{calc-select-additional}) command enlarges the
21574 current selection to encompass the cursor. To select the smallest
21575 sub-formula defined by two different points, move to the first and
21576 press @kbd{j s}, then move to the other and press @kbd{j a}. This
21577 is roughly analogous to using @kbd{C-@@} (@code{set-mark-command}) to
21578 select the two ends of a region of text during normal Emacs editing.
21581 @pindex calc-select-once
21582 The @kbd{j o} (@code{calc-select-once}) command selects a formula in
21583 exactly the same way as @kbd{j s}, except that the selection will
21584 last only as long as the next command that uses it. For example,
21585 @kbd{j o 1 +} is a handy way to add one to the sub-formula indicated
21588 (A somewhat more precise definition: The @kbd{j o} command sets a flag
21589 such that the next command involving selected stack entries will clear
21590 the selections on those stack entries afterwards. All other selection
21591 commands except @kbd{j a} and @kbd{j O} clear this flag.)
21595 @pindex calc-select-here-maybe
21596 @pindex calc-select-once-maybe
21597 The @kbd{j S} (@code{calc-select-here-maybe}) and @kbd{j O}
21598 (@code{calc-select-once-maybe}) commands are equivalent to @kbd{j s}
21599 and @kbd{j o}, respectively, except that if the formula already
21600 has a selection they have no effect. This is analogous to the
21601 behavior of some commands such as @kbd{j r} (@code{calc-rewrite-selection};
21602 @pxref{Selections with Rewrite Rules}) and is mainly intended to be
21603 used in keyboard macros that implement your own selection-oriented
21606 Selection of sub-formulas normally treats associative terms like
21607 @samp{a + b - c + d} and @samp{x * y * z} as single levels of the formula.
21608 If you place the cursor anywhere inside @samp{a + b - c + d} except
21609 on one of the variable names and use @kbd{j s}, you will select the
21610 entire four-term sum.
21613 @pindex calc-break-selections
21614 The @kbd{j b} (@code{calc-break-selections}) command controls a mode
21615 in which the ``deep structure'' of these associative formulas shows
21616 through. Calc actually stores the above formulas as
21617 @samp{((a + b) - c) + d} and @samp{x * (y * z)}. (Note that for certain
21618 obscure reasons, by default Calc treats multiplication as
21619 right-associative.) Once you have enabled @kbd{j b} mode, selecting
21620 with the cursor on the @samp{-} sign would only select the @samp{a + b -
21621 c} portion, which makes sense when the deep structure of the sum is
21622 considered. There is no way to select the @samp{b - c + d} portion;
21623 although this might initially look like just as legitimate a sub-formula
21624 as @samp{a + b - c}, the deep structure shows that it isn't. The @kbd{d
21625 U} command can be used to view the deep structure of any formula
21626 (@pxref{Normal Language Modes}).
21628 When @kbd{j b} mode has not been enabled, the deep structure is
21629 generally hidden by the selection commands---what you see is what
21633 @pindex calc-unselect
21634 The @kbd{j u} (@code{calc-unselect}) command unselects the formula
21635 that the cursor is on. If there was no selection in the formula,
21636 this command has no effect. With a numeric prefix argument, it
21637 unselects the @var{n}th stack element rather than using the cursor
21641 @pindex calc-clear-selections
21642 The @kbd{j c} (@code{calc-clear-selections}) command unselects all
21645 @node Changing Selections, Displaying Selections, Making Selections, Selecting Subformulas
21646 @subsection Changing Selections
21650 @pindex calc-select-more
21651 Once you have selected a sub-formula, you can expand it using the
21652 @w{@kbd{j m}} (@code{calc-select-more}) command. If @samp{a + b} is
21653 selected, pressing @w{@kbd{j m}} repeatedly works as follows:
21658 (a + b) . . . (a + b) + V c (a + b) + V c
21659 1* ............... 1* ............... 1* ---------------
21660 . . . . . . . . 2 x + 1
21665 In the last example, the entire formula is selected. This is roughly
21666 the same as having no selection at all, but because there are subtle
21667 differences the @samp{*} character is still there on the line number.
21669 With a numeric prefix argument @var{n}, @kbd{j m} expands @var{n}
21670 times (or until the entire formula is selected). Note that @kbd{j s}
21671 with argument @var{n} is equivalent to plain @kbd{j s} followed by
21672 @kbd{j m} with argument @var{n}. If @w{@kbd{j m}} is used when there
21673 is no current selection, it is equivalent to @w{@kbd{j s}}.
21675 Even though @kbd{j m} does not explicitly use the location of the
21676 cursor within the formula, it nevertheless uses the cursor to determine
21677 which stack element to operate on. As usual, @kbd{j m} when the cursor
21678 is not on any stack element operates on the top stack element.
21681 @pindex calc-select-less
21682 The @kbd{j l} (@code{calc-select-less}) command reduces the current
21683 selection around the cursor position. That is, it selects the
21684 immediate sub-formula of the current selection which contains the
21685 cursor, the opposite of @kbd{j m}. If the cursor is not inside the
21686 current selection, the command de-selects the formula.
21689 @pindex calc-select-part
21690 The @kbd{j 1} through @kbd{j 9} (@code{calc-select-part}) commands
21691 select the @var{n}th sub-formula of the current selection. They are
21692 like @kbd{j l} (@code{calc-select-less}) except they use counting
21693 rather than the cursor position to decide which sub-formula to select.
21694 For example, if the current selection is @kbd{a + b + c} or
21695 @kbd{f(a, b, c)} or @kbd{[a, b, c]}, then @kbd{j 1} selects @samp{a},
21696 @kbd{j 2} selects @samp{b}, and @kbd{j 3} selects @samp{c}; in each of
21697 these cases, @kbd{j 4} through @kbd{j 9} would be errors.
21699 If there is no current selection, @kbd{j 1} through @kbd{j 9} select
21700 the @var{n}th top-level sub-formula. (In other words, they act as if
21701 the entire stack entry were selected first.) To select the @var{n}th
21702 sub-formula where @var{n} is greater than nine, you must instead invoke
21703 @w{@kbd{j 1}} with @var{n} as a numeric prefix argument.
21707 @pindex calc-select-next
21708 @pindex calc-select-previous
21709 The @kbd{j n} (@code{calc-select-next}) and @kbd{j p}
21710 (@code{calc-select-previous}) commands change the current selection
21711 to the next or previous sub-formula at the same level. For example,
21712 if @samp{b} is selected in @w{@samp{2 + a*b*c + x}}, then @kbd{j n}
21713 selects @samp{c}. Further @kbd{j n} commands would be in error because,
21714 even though there is something to the right of @samp{c} (namely, @samp{x}),
21715 it is not at the same level; in this case, it is not a term of the
21716 same product as @samp{b} and @samp{c}. However, @kbd{j m} (to select
21717 the whole product @samp{a*b*c} as a term of the sum) followed by
21718 @w{@kbd{j n}} would successfully select the @samp{x}.
21720 Similarly, @kbd{j p} moves the selection from the @samp{b} in this
21721 sample formula to the @samp{a}. Both commands accept numeric prefix
21722 arguments to move several steps at a time.
21724 It is interesting to compare Calc's selection commands with the
21725 Emacs Info system's commands for navigating through hierarchically
21726 organized documentation. Calc's @kbd{j n} command is completely
21727 analogous to Info's @kbd{n} command. Likewise, @kbd{j p} maps to
21728 @kbd{p}, @kbd{j 2} maps to @kbd{2}, and Info's @kbd{u} is like @kbd{j m}.
21729 (Note that @kbd{j u} stands for @code{calc-unselect}, not ``up''.)
21730 The Info @kbd{m} command is somewhat similar to Calc's @kbd{j s} and
21731 @kbd{j l}; in each case, you can jump directly to a sub-component
21732 of the hierarchy simply by pointing to it with the cursor.
21734 @node Displaying Selections, Operating on Selections, Changing Selections, Selecting Subformulas
21735 @subsection Displaying Selections
21739 @pindex calc-show-selections
21740 @vindex calc-highlight-selections-with-faces
21741 @vindex calc-selected-face
21742 @vindex calc-nonselected-face
21743 The @kbd{j d} (@code{calc-show-selections}) command controls how
21744 selected sub-formulas are displayed. One of the alternatives is
21745 illustrated in the above examples; if we press @kbd{j d} we switch
21746 to the other style in which the selected portion itself is obscured
21752 (a + b) . . . ## # ## + V c
21753 1* ............... 1* ---------------
21757 If the customizable variable
21758 @code{calc-highlight-selections-with-faces} is non-nil, then the
21759 non-selected portion of the formula will be de-emphasized by using a
21760 less noticeable face (@code{calc-nonselected-face}) instead of dots
21761 and the selected sub-formula will be highlighted by using a more
21762 noticeable face (@code{calc-selected-face}) instead of @samp{#}
21763 signs. (@pxref{Customizing Calc}.)
21765 @node Operating on Selections, Rearranging with Selections, Displaying Selections, Selecting Subformulas
21766 @subsection Operating on Selections
21769 Once a selection is made, all Calc commands that manipulate items
21770 on the stack will operate on the selected portions of the items
21771 instead. (Note that several stack elements may have selections
21772 at once, though there can be only one selection at a time in any
21773 given stack element.)
21776 @pindex calc-enable-selections
21777 The @kbd{j e} (@code{calc-enable-selections}) command disables the
21778 effect that selections have on Calc commands. The current selections
21779 still exist, but Calc commands operate on whole stack elements anyway.
21780 This mode can be identified by the fact that the @samp{*} markers on
21781 the line numbers are gone, even though selections are visible. To
21782 reactivate the selections, press @kbd{j e} again.
21784 To extract a sub-formula as a new formula, simply select the
21785 sub-formula and press @key{RET}. This normally duplicates the top
21786 stack element; here it duplicates only the selected portion of that
21789 To replace a sub-formula with something different, you can enter the
21790 new value onto the stack and press @key{TAB}. This normally exchanges
21791 the top two stack elements; here it swaps the value you entered into
21792 the selected portion of the formula, returning the old selected
21793 portion to the top of the stack.
21798 (a + b) . . . 17 x y . . . 17 x y + V c
21799 2* ............... 2* ............. 2: -------------
21800 . . . . . . . . 2 x + 1
21803 1: 17 x y 1: (a + b) 1: (a + b)
21807 In this example we select a sub-formula of our original example,
21808 enter a new formula, @key{TAB} it into place, then deselect to see
21809 the complete, edited formula.
21811 If you want to swap whole formulas around even though they contain
21812 selections, just use @kbd{j e} before and after.
21815 @pindex calc-enter-selection
21816 The @kbd{j '} (@code{calc-enter-selection}) command is another way
21817 to replace a selected sub-formula. This command does an algebraic
21818 entry just like the regular @kbd{'} key. When you press @key{RET},
21819 the formula you type replaces the original selection. You can use
21820 the @samp{$} symbol in the formula to refer to the original
21821 selection. If there is no selection in the formula under the cursor,
21822 the cursor is used to make a temporary selection for the purposes of
21823 the command. Thus, to change a term of a formula, all you have to
21824 do is move the Emacs cursor to that term and press @kbd{j '}.
21827 @pindex calc-edit-selection
21828 The @kbd{j `} (@code{calc-edit-selection}) command is a similar
21829 analogue of the @kbd{`} (@code{calc-edit}) command. It edits the
21830 selected sub-formula in a separate buffer. If there is no
21831 selection, it edits the sub-formula indicated by the cursor.
21833 To delete a sub-formula, press @key{DEL}. This generally replaces
21834 the sub-formula with the constant zero, but in a few suitable contexts
21835 it uses the constant one instead. The @key{DEL} key automatically
21836 deselects and re-simplifies the entire formula afterwards. Thus:
21841 17 x y + # # 17 x y 17 # y 17 y
21842 1* ------------- 1: ------- 1* ------- 1: -------
21843 2 x + 1 2 x + 1 2 x + 1 2 x + 1
21847 In this example, we first delete the @samp{sqrt(c)} term; Calc
21848 accomplishes this by replacing @samp{sqrt(c)} with zero and
21849 resimplifying. We then delete the @kbd{x} in the numerator;
21850 since this is part of a product, Calc replaces it with @samp{1}
21853 If you select an element of a vector and press @key{DEL}, that
21854 element is deleted from the vector. If you delete one side of
21855 an equation or inequality, only the opposite side remains.
21857 @kindex j @key{DEL}
21858 @pindex calc-del-selection
21859 The @kbd{j @key{DEL}} (@code{calc-del-selection}) command is like
21860 @key{DEL} but with the auto-selecting behavior of @kbd{j '} and
21861 @kbd{j `}. It deletes the selected portion of the formula
21862 indicated by the cursor, or, in the absence of a selection, it
21863 deletes the sub-formula indicated by the cursor position.
21865 @kindex j @key{RET}
21866 @pindex calc-grab-selection
21867 (There is also an auto-selecting @kbd{j @key{RET}} (@code{calc-copy-selection})
21870 Normal arithmetic operations also apply to sub-formulas. Here we
21871 select the denominator, press @kbd{5 -} to subtract five from the
21872 denominator, press @kbd{n} to negate the denominator, then
21873 press @kbd{Q} to take the square root.
21877 .. . .. . .. . .. .
21878 1* ....... 1* ....... 1* ....... 1* ..........
21879 2 x + 1 2 x - 4 4 - 2 x _________
21884 Certain types of operations on selections are not allowed. For
21885 example, for an arithmetic function like @kbd{-} no more than one of
21886 the arguments may be a selected sub-formula. (As the above example
21887 shows, the result of the subtraction is spliced back into the argument
21888 which had the selection; if there were more than one selection involved,
21889 this would not be well-defined.) If you try to subtract two selections,
21890 the command will abort with an error message.
21892 Operations on sub-formulas sometimes leave the formula as a whole
21893 in an ``un-natural'' state. Consider negating the @samp{2 x} term
21894 of our sample formula by selecting it and pressing @kbd{n}
21895 (@code{calc-change-sign}).
21900 1* .......... 1* ...........
21901 ......... ..........
21902 . . . 2 x . . . -2 x
21906 Unselecting the sub-formula reveals that the minus sign, which would
21907 normally have cancelled out with the subtraction automatically, has
21908 not been able to do so because the subtraction was not part of the
21909 selected portion. Pressing @kbd{=} (@code{calc-evaluate}) or doing
21910 any other mathematical operation on the whole formula will cause it
21916 1: ----------- 1: ----------
21917 __________ _________
21918 V 4 - -2 x V 4 + 2 x
21922 @node Rearranging with Selections, , Operating on Selections, Selecting Subformulas
21923 @subsection Rearranging Formulas using Selections
21927 @pindex calc-commute-right
21928 The @kbd{j R} (@code{calc-commute-right}) command moves the selected
21929 sub-formula to the right in its surrounding formula. Generally the
21930 selection is one term of a sum or product; the sum or product is
21931 rearranged according to the commutative laws of algebra.
21933 As with @kbd{j '} and @kbd{j @key{DEL}}, the term under the cursor is used
21934 if there is no selection in the current formula. All commands described
21935 in this section share this property. In this example, we place the
21936 cursor on the @samp{a} and type @kbd{j R}, then repeat.
21939 1: a + b - c 1: b + a - c 1: b - c + a
21943 Note that in the final step above, the @samp{a} is switched with
21944 the @samp{c} but the signs are adjusted accordingly. When moving
21945 terms of sums and products, @kbd{j R} will never change the
21946 mathematical meaning of the formula.
21948 The selected term may also be an element of a vector or an argument
21949 of a function. The term is exchanged with the one to its right.
21950 In this case, the ``meaning'' of the vector or function may of
21951 course be drastically changed.
21954 1: [a, b, c] 1: [b, a, c] 1: [b, c, a]
21956 1: f(a, b, c) 1: f(b, a, c) 1: f(b, c, a)
21960 @pindex calc-commute-left
21961 The @kbd{j L} (@code{calc-commute-left}) command is like @kbd{j R}
21962 except that it swaps the selected term with the one to its left.
21964 With numeric prefix arguments, these commands move the selected
21965 term several steps at a time. It is an error to try to move a
21966 term left or right past the end of its enclosing formula.
21967 With numeric prefix arguments of zero, these commands move the
21968 selected term as far as possible in the given direction.
21971 @pindex calc-sel-distribute
21972 The @kbd{j D} (@code{calc-sel-distribute}) command mixes the selected
21973 sum or product into the surrounding formula using the distributive
21974 law. For example, in @samp{a * (b - c)} with the @samp{b - c}
21975 selected, the result is @samp{a b - a c}. This also distributes
21976 products or quotients into surrounding powers, and can also do
21977 transformations like @samp{exp(a + b)} to @samp{exp(a) exp(b)},
21978 where @samp{a + b} is the selected term, and @samp{ln(a ^ b)}
21979 to @samp{ln(a) b}, where @samp{a ^ b} is the selected term.
21981 For multiple-term sums or products, @kbd{j D} takes off one term
21982 at a time: @samp{a * (b + c - d)} goes to @samp{a * (c - d) + a b}
21983 with the @samp{c - d} selected so that you can type @kbd{j D}
21984 repeatedly to expand completely. The @kbd{j D} command allows a
21985 numeric prefix argument which specifies the maximum number of
21986 times to expand at once; the default is one time only.
21988 @vindex DistribRules
21989 The @kbd{j D} command is implemented using rewrite rules.
21990 @xref{Selections with Rewrite Rules}. The rules are stored in
21991 the Calc variable @code{DistribRules}. A convenient way to view
21992 these rules is to use @kbd{s e} (@code{calc-edit-variable}) which
21993 displays and edits the stored value of a variable. Press @kbd{C-c C-c}
21994 to return from editing mode; be careful not to make any actual changes
21995 or else you will affect the behavior of future @kbd{j D} commands!
21997 To extend @kbd{j D} to handle new cases, just edit @code{DistribRules}
21998 as described above. You can then use the @kbd{s p} command to save
21999 this variable's value permanently for future Calc sessions.
22000 @xref{Operations on Variables}.
22003 @pindex calc-sel-merge
22005 The @kbd{j M} (@code{calc-sel-merge}) command is the complement
22006 of @kbd{j D}; given @samp{a b - a c} with either @samp{a b} or
22007 @samp{a c} selected, the result is @samp{a * (b - c)}. Once
22008 again, @kbd{j M} can also merge calls to functions like @code{exp}
22009 and @code{ln}; examine the variable @code{MergeRules} to see all
22010 the relevant rules.
22013 @pindex calc-sel-commute
22014 @vindex CommuteRules
22015 The @kbd{j C} (@code{calc-sel-commute}) command swaps the arguments
22016 of the selected sum, product, or equation. It always behaves as
22017 if @kbd{j b} mode were in effect, i.e., the sum @samp{a + b + c} is
22018 treated as the nested sums @samp{(a + b) + c} by this command.
22019 If you put the cursor on the first @samp{+}, the result is
22020 @samp{(b + a) + c}; if you put the cursor on the second @samp{+}, the
22021 result is @samp{c + (a + b)} (which the default simplifications
22022 will rearrange to @samp{(c + a) + b}). The relevant rules are stored
22023 in the variable @code{CommuteRules}.
22025 You may need to turn default simplifications off (with the @kbd{m O}
22026 command) in order to get the full benefit of @kbd{j C}. For example,
22027 commuting @samp{a - b} produces @samp{-b + a}, but the default
22028 simplifications will ``simplify'' this right back to @samp{a - b} if
22029 you don't turn them off. The same is true of some of the other
22030 manipulations described in this section.
22033 @pindex calc-sel-negate
22034 @vindex NegateRules
22035 The @kbd{j N} (@code{calc-sel-negate}) command replaces the selected
22036 term with the negative of that term, then adjusts the surrounding
22037 formula in order to preserve the meaning. For example, given
22038 @samp{exp(a - b)} where @samp{a - b} is selected, the result is
22039 @samp{1 / exp(b - a)}. By contrast, selecting a term and using the
22040 regular @kbd{n} (@code{calc-change-sign}) command negates the
22041 term without adjusting the surroundings, thus changing the meaning
22042 of the formula as a whole. The rules variable is @code{NegateRules}.
22045 @pindex calc-sel-invert
22046 @vindex InvertRules
22047 The @kbd{j &} (@code{calc-sel-invert}) command is similar to @kbd{j N}
22048 except it takes the reciprocal of the selected term. For example,
22049 given @samp{a - ln(b)} with @samp{b} selected, the result is
22050 @samp{a + ln(1/b)}. The rules variable is @code{InvertRules}.
22053 @pindex calc-sel-jump-equals
22055 The @kbd{j E} (@code{calc-sel-jump-equals}) command moves the
22056 selected term from one side of an equation to the other. Given
22057 @samp{a + b = c + d} with @samp{c} selected, the result is
22058 @samp{a + b - c = d}. This command also works if the selected
22059 term is part of a @samp{*}, @samp{/}, or @samp{^} formula. The
22060 relevant rules variable is @code{JumpRules}.
22064 @pindex calc-sel-isolate
22065 The @kbd{j I} (@code{calc-sel-isolate}) command isolates the
22066 selected term on its side of an equation. It uses the @kbd{a S}
22067 (@code{calc-solve-for}) command to solve the equation, and the
22068 Hyperbolic flag affects it in the same way. @xref{Solving Equations}.
22069 When it applies, @kbd{j I} is often easier to use than @kbd{j E}.
22070 It understands more rules of algebra, and works for inequalities
22071 as well as equations.
22075 @pindex calc-sel-mult-both-sides
22076 @pindex calc-sel-div-both-sides
22077 The @kbd{j *} (@code{calc-sel-mult-both-sides}) command prompts for a
22078 formula using algebraic entry, then multiplies both sides of the
22079 selected quotient or equation by that formula. It simplifies each
22080 side with @kbd{a s} (@code{calc-simplify}) before re-forming the
22081 quotient or equation. You can suppress this simplification by
22082 providing a prefix argument: @kbd{C-u j *}. There is also a @kbd{j /}
22083 (@code{calc-sel-div-both-sides}) which is similar to @kbd{j *} but
22084 dividing instead of multiplying by the factor you enter.
22086 If the selection is a quotient with numerator 1, then Calc's default
22087 simplifications would normally cancel the new factors. To prevent
22088 this, when the @kbd{j *} command is used on a selection whose numerator is
22089 1 or -1, the denominator is expanded at the top level using the
22090 distributive law (as if using the @kbd{C-u 1 a x} command). Suppose the
22091 formula on the stack is @samp{1 / (a + 1)} and you wish to multiplying the
22092 top and bottom by @samp{a - 1}. Calc's default simplifications would
22093 normally change the result @samp{(a - 1) /(a + 1) (a - 1)} back
22094 to the original form by cancellation; when @kbd{j *} is used, Calc
22095 expands the denominator to @samp{a (a - 1) + a - 1} to prevent this.
22097 If you wish the @kbd{j *} command to completely expand the denominator
22098 of a quotient you can call it with a zero prefix: @kbd{C-u 0 j *}. For
22099 example, if the formula on the stack is @samp{1 / (sqrt(a) + 1)}, you may
22100 wish to eliminate the square root in the denominator by multiplying
22101 the top and bottom by @samp{sqrt(a) - 1}. If you did this simply by using
22102 a simple @kbd{j *} command, you would get
22103 @samp{(sqrt(a)-1)/ (sqrt(a) (sqrt(a) - 1) + sqrt(a) - 1)}. Instead,
22104 you would probably want to use @kbd{C-u 0 j *}, which would expand the
22105 bottom and give you the desired result @samp{(sqrt(a)-1)/(a-1)}. More
22106 generally, if @kbd{j *} is called with an argument of a positive
22107 integer @var{n}, then the denominator of the expression will be
22108 expanded @var{n} times (as if with the @kbd{C-u @var{n} a x} command).
22110 If the selection is an inequality, @kbd{j *} and @kbd{j /} will
22111 accept any factor, but will warn unless they can prove the factor
22112 is either positive or negative. (In the latter case the direction
22113 of the inequality will be switched appropriately.) @xref{Declarations},
22114 for ways to inform Calc that a given variable is positive or
22115 negative. If Calc can't tell for sure what the sign of the factor
22116 will be, it will assume it is positive and display a warning
22119 For selections that are not quotients, equations, or inequalities,
22120 these commands pull out a multiplicative factor: They divide (or
22121 multiply) by the entered formula, simplify, then multiply (or divide)
22122 back by the formula.
22126 @pindex calc-sel-add-both-sides
22127 @pindex calc-sel-sub-both-sides
22128 The @kbd{j +} (@code{calc-sel-add-both-sides}) and @kbd{j -}
22129 (@code{calc-sel-sub-both-sides}) commands analogously add to or
22130 subtract from both sides of an equation or inequality. For other
22131 types of selections, they extract an additive factor. A numeric
22132 prefix argument suppresses simplification of the intermediate
22136 @pindex calc-sel-unpack
22137 The @kbd{j U} (@code{calc-sel-unpack}) command replaces the
22138 selected function call with its argument. For example, given
22139 @samp{a + sin(x^2)} with @samp{sin(x^2)} selected, the result
22140 is @samp{a + x^2}. (The @samp{x^2} will remain selected; if you
22141 wanted to change the @code{sin} to @code{cos}, just press @kbd{C}
22142 now to take the cosine of the selected part.)
22145 @pindex calc-sel-evaluate
22146 The @kbd{j v} (@code{calc-sel-evaluate}) command performs the
22147 normal default simplifications on the selected sub-formula.
22148 These are the simplifications that are normally done automatically
22149 on all results, but which may have been partially inhibited by
22150 previous selection-related operations, or turned off altogether
22151 by the @kbd{m O} command. This command is just an auto-selecting
22152 version of the @w{@kbd{a v}} command (@pxref{Algebraic Manipulation}).
22154 With a numeric prefix argument of 2, @kbd{C-u 2 j v} applies
22155 the @kbd{a s} (@code{calc-simplify}) command to the selected
22156 sub-formula. With a prefix argument of 3 or more, e.g., @kbd{C-u j v}
22157 applies the @kbd{a e} (@code{calc-simplify-extended}) command.
22158 @xref{Simplifying Formulas}. With a negative prefix argument
22159 it simplifies at the top level only, just as with @kbd{a v}.
22160 Here the ``top'' level refers to the top level of the selected
22164 @pindex calc-sel-expand-formula
22165 The @kbd{j "} (@code{calc-sel-expand-formula}) command is to @kbd{a "}
22166 (@pxref{Algebraic Manipulation}) what @kbd{j v} is to @kbd{a v}.
22168 You can use the @kbd{j r} (@code{calc-rewrite-selection}) command
22169 to define other algebraic operations on sub-formulas. @xref{Rewrite Rules}.
22171 @node Algebraic Manipulation, Simplifying Formulas, Selecting Subformulas, Algebra
22172 @section Algebraic Manipulation
22175 The commands in this section perform general-purpose algebraic
22176 manipulations. They work on the whole formula at the top of the
22177 stack (unless, of course, you have made a selection in that
22180 Many algebra commands prompt for a variable name or formula. If you
22181 answer the prompt with a blank line, the variable or formula is taken
22182 from top-of-stack, and the normal argument for the command is taken
22183 from the second-to-top stack level.
22186 @pindex calc-alg-evaluate
22187 The @kbd{a v} (@code{calc-alg-evaluate}) command performs the normal
22188 default simplifications on a formula; for example, @samp{a - -b} is
22189 changed to @samp{a + b}. These simplifications are normally done
22190 automatically on all Calc results, so this command is useful only if
22191 you have turned default simplifications off with an @kbd{m O}
22192 command. @xref{Simplification Modes}.
22194 It is often more convenient to type @kbd{=}, which is like @kbd{a v}
22195 but which also substitutes stored values for variables in the formula.
22196 Use @kbd{a v} if you want the variables to ignore their stored values.
22198 If you give a numeric prefix argument of 2 to @kbd{a v}, it simplifies
22199 as if in Algebraic Simplification mode. This is equivalent to typing
22200 @kbd{a s}; @pxref{Simplifying Formulas}. If you give a numeric prefix
22201 of 3 or more, it uses Extended Simplification mode (@kbd{a e}).
22203 If you give a negative prefix argument @mathit{-1}, @mathit{-2}, or @mathit{-3},
22204 it simplifies in the corresponding mode but only works on the top-level
22205 function call of the formula. For example, @samp{(2 + 3) * (2 + 3)} will
22206 simplify to @samp{(2 + 3)^2}, without simplifying the sub-formulas
22207 @samp{2 + 3}. As another example, typing @kbd{V R +} to sum the vector
22208 @samp{[1, 2, 3, 4]} produces the formula @samp{reduce(add, [1, 2, 3, 4])}
22209 in No-Simplify mode. Using @kbd{a v} will evaluate this all the way to
22210 10; using @kbd{C-u - a v} will evaluate it only to @samp{1 + 2 + 3 + 4}.
22211 (@xref{Reducing and Mapping}.)
22215 The @kbd{=} command corresponds to the @code{evalv} function, and
22216 the related @kbd{N} command, which is like @kbd{=} but temporarily
22217 disables Symbolic mode (@kbd{m s}) during the evaluation, corresponds
22218 to the @code{evalvn} function. (These commands interpret their prefix
22219 arguments differently than @kbd{a v}; @kbd{=} treats the prefix as
22220 the number of stack elements to evaluate at once, and @kbd{N} treats
22221 it as a temporary different working precision.)
22223 The @code{evalvn} function can take an alternate working precision
22224 as an optional second argument. This argument can be either an
22225 integer, to set the precision absolutely, or a vector containing
22226 a single integer, to adjust the precision relative to the current
22227 precision. Note that @code{evalvn} with a larger than current
22228 precision will do the calculation at this higher precision, but the
22229 result will as usual be rounded back down to the current precision
22230 afterward. For example, @samp{evalvn(pi - 3.1415)} at a precision
22231 of 12 will return @samp{9.265359e-5}; @samp{evalvn(pi - 3.1415, 30)}
22232 will return @samp{9.26535897932e-5} (computing a 25-digit result which
22233 is then rounded down to 12); and @samp{evalvn(pi - 3.1415, [-2])}
22234 will return @samp{9.2654e-5}.
22237 @pindex calc-expand-formula
22238 The @kbd{a "} (@code{calc-expand-formula}) command expands functions
22239 into their defining formulas wherever possible. For example,
22240 @samp{deg(x^2)} is changed to @samp{180 x^2 / pi}. Most functions,
22241 like @code{sin} and @code{gcd}, are not defined by simple formulas
22242 and so are unaffected by this command. One important class of
22243 functions which @emph{can} be expanded is the user-defined functions
22244 created by the @kbd{Z F} command. @xref{Algebraic Definitions}.
22245 Other functions which @kbd{a "} can expand include the probability
22246 distribution functions, most of the financial functions, and the
22247 hyperbolic and inverse hyperbolic functions. A numeric prefix argument
22248 affects @kbd{a "} in the same way as it does @kbd{a v}: A positive
22249 argument expands all functions in the formula and then simplifies in
22250 various ways; a negative argument expands and simplifies only the
22251 top-level function call.
22254 @pindex calc-map-equation
22256 The @kbd{a M} (@code{calc-map-equation}) [@code{mapeq}] command applies
22257 a given function or operator to one or more equations. It is analogous
22258 to @kbd{V M}, which operates on vectors instead of equations.
22259 @pxref{Reducing and Mapping}. For example, @kbd{a M S} changes
22260 @samp{x = y+1} to @samp{sin(x) = sin(y+1)}, and @kbd{a M +} with
22261 @samp{x = y+1} and @expr{6} on the stack produces @samp{x+6 = y+7}.
22262 With two equations on the stack, @kbd{a M +} would add the lefthand
22263 sides together and the righthand sides together to get the two
22264 respective sides of a new equation.
22266 Mapping also works on inequalities. Mapping two similar inequalities
22267 produces another inequality of the same type. Mapping an inequality
22268 with an equation produces an inequality of the same type. Mapping a
22269 @samp{<=} with a @samp{<} or @samp{!=} (not-equal) produces a @samp{<}.
22270 If inequalities with opposite direction (e.g., @samp{<} and @samp{>})
22271 are mapped, the direction of the second inequality is reversed to
22272 match the first: Using @kbd{a M +} on @samp{a < b} and @samp{a > 2}
22273 reverses the latter to get @samp{2 < a}, which then allows the
22274 combination @samp{a + 2 < b + a}, which the @kbd{a s} command can
22275 then simplify to get @samp{2 < b}.
22277 Using @kbd{a M *}, @kbd{a M /}, @kbd{a M n}, or @kbd{a M &} to negate
22278 or invert an inequality will reverse the direction of the inequality.
22279 Other adjustments to inequalities are @emph{not} done automatically;
22280 @kbd{a M S} will change @w{@samp{x < y}} to @samp{sin(x) < sin(y)} even
22281 though this is not true for all values of the variables.
22285 With the Hyperbolic flag, @kbd{H a M} [@code{mapeqp}] does a plain
22286 mapping operation without reversing the direction of any inequalities.
22287 Thus, @kbd{H a M &} would change @kbd{x > 2} to @kbd{1/x > 0.5}.
22288 (This change is mathematically incorrect, but perhaps you were
22289 fixing an inequality which was already incorrect.)
22293 With the Inverse flag, @kbd{I a M} [@code{mapeqr}] always reverses
22294 the direction of the inequality. You might use @kbd{I a M C} to
22295 change @samp{x < y} to @samp{cos(x) > cos(y)} if you know you are
22296 working with small positive angles.
22299 @pindex calc-substitute
22301 The @kbd{a b} (@code{calc-substitute}) [@code{subst}] command substitutes
22303 of some variable or sub-expression of an expression with a new
22304 sub-expression. For example, substituting @samp{sin(x)} with @samp{cos(y)}
22305 in @samp{2 sin(x)^2 + x sin(x) + sin(2 x)} produces
22306 @samp{2 cos(y)^2 + x cos(y) + @w{sin(2 x)}}.
22307 Note that this is a purely structural substitution; the lone @samp{x} and
22308 the @samp{sin(2 x)} stayed the same because they did not look like
22309 @samp{sin(x)}. @xref{Rewrite Rules}, for a more general method for
22310 doing substitutions.
22312 The @kbd{a b} command normally prompts for two formulas, the old
22313 one and the new one. If you enter a blank line for the first
22314 prompt, all three arguments are taken from the stack (new, then old,
22315 then target expression). If you type an old formula but then enter a
22316 blank line for the new one, the new formula is taken from top-of-stack
22317 and the target from second-to-top. If you answer both prompts, the
22318 target is taken from top-of-stack as usual.
22320 Note that @kbd{a b} has no understanding of commutativity or
22321 associativity. The pattern @samp{x+y} will not match the formula
22322 @samp{y+x}. Also, @samp{y+z} will not match inside the formula @samp{x+y+z}
22323 because the @samp{+} operator is left-associative, so the ``deep
22324 structure'' of that formula is @samp{(x+y) + z}. Use @kbd{d U}
22325 (@code{calc-unformatted-language}) mode to see the true structure of
22326 a formula. The rewrite rule mechanism, discussed later, does not have
22329 As an algebraic function, @code{subst} takes three arguments:
22330 Target expression, old, new. Note that @code{subst} is always
22331 evaluated immediately, even if its arguments are variables, so if
22332 you wish to put a call to @code{subst} onto the stack you must
22333 turn the default simplifications off first (with @kbd{m O}).
22335 @node Simplifying Formulas, Polynomials, Algebraic Manipulation, Algebra
22336 @section Simplifying Formulas
22342 @pindex calc-simplify
22344 The @kbd{a s} (@code{calc-simplify}) [@code{simplify}] command applies
22345 various algebraic rules to simplify a formula. This includes rules which
22346 are not part of the default simplifications because they may be too slow
22347 to apply all the time, or may not be desirable all of the time. For
22348 example, non-adjacent terms of sums are combined, as in @samp{a + b + 2 a}
22349 to @samp{b + 3 a}, and some formulas like @samp{sin(arcsin(x))} are
22350 simplified to @samp{x}.
22352 The sections below describe all the various kinds of algebraic
22353 simplifications Calc provides in full detail. None of Calc's
22354 simplification commands are designed to pull rabbits out of hats;
22355 they simply apply certain specific rules to put formulas into
22356 less redundant or more pleasing forms. Serious algebra in Calc
22357 must be done manually, usually with a combination of selections
22358 and rewrite rules. @xref{Rearranging with Selections}.
22359 @xref{Rewrite Rules}.
22361 @xref{Simplification Modes}, for commands to control what level of
22362 simplification occurs automatically. Normally only the ``default
22363 simplifications'' occur.
22365 There are some simplifications that, while sometimes useful, are never
22366 done automatically. For example, the @kbd{I} prefix can be given to
22367 @kbd{a s}; the @kbd{I a s} command will change any trigonometric
22368 function to the appropriate combination of @samp{sin}s and @samp{cos}s
22369 before simplifying. This can be useful in simplifying even mildly
22370 complicated trigonometric expressions. For example, while @kbd{a s}
22371 can reduce @samp{sin(x) csc(x)} to @samp{1}, it will not simplify
22372 @samp{sin(x)^2 csc(x)}. The command @kbd{I a s} can be used to
22373 simplify this latter expression; it will transform @samp{sin(x)^2
22374 csc(x)} into @samp{sin(x)}. However, @kbd{I a s} will also perform
22375 some ``simplifications'' which may not be desired; for example, it
22376 will transform @samp{tan(x)^2} into @samp{sin(x)^2 / cos(x)^2}. The
22377 Hyperbolic prefix @kbd{H} can be used similarly; the @kbd{H a s} will
22378 replace any hyperbolic functions in the formula with the appropriate
22379 combinations of @samp{sinh}s and @samp{cosh}s before simplifying.
22383 * Default Simplifications::
22384 * Algebraic Simplifications::
22385 * Unsafe Simplifications::
22386 * Simplification of Units::
22389 @node Default Simplifications, Algebraic Simplifications, Simplifying Formulas, Simplifying Formulas
22390 @subsection Default Simplifications
22393 @cindex Default simplifications
22394 This section describes the ``default simplifications,'' those which are
22395 normally applied to all results. For example, if you enter the variable
22396 @expr{x} on the stack twice and push @kbd{+}, Calc's default
22397 simplifications automatically change @expr{x + x} to @expr{2 x}.
22399 The @kbd{m O} command turns off the default simplifications, so that
22400 @expr{x + x} will remain in this form unless you give an explicit
22401 ``simplify'' command like @kbd{=} or @kbd{a v}. @xref{Algebraic
22402 Manipulation}. The @kbd{m D} command turns the default simplifications
22405 The most basic default simplification is the evaluation of functions.
22406 For example, @expr{2 + 3} is evaluated to @expr{5}, and @expr{@tfn{sqrt}(9)}
22407 is evaluated to @expr{3}. Evaluation does not occur if the arguments
22408 to a function are somehow of the wrong type @expr{@tfn{tan}([2,3,4])}),
22409 range (@expr{@tfn{tan}(90)}), or number (@expr{@tfn{tan}(3,5)}),
22410 or if the function name is not recognized (@expr{@tfn{f}(5)}), or if
22411 Symbolic mode (@pxref{Symbolic Mode}) prevents evaluation
22412 (@expr{@tfn{sqrt}(2)}).
22414 Calc simplifies (evaluates) the arguments to a function before it
22415 simplifies the function itself. Thus @expr{@tfn{sqrt}(5+4)} is
22416 simplified to @expr{@tfn{sqrt}(9)} before the @code{sqrt} function
22417 itself is applied. There are very few exceptions to this rule:
22418 @code{quote}, @code{lambda}, and @code{condition} (the @code{::}
22419 operator) do not evaluate their arguments, @code{if} (the @code{? :}
22420 operator) does not evaluate all of its arguments, and @code{evalto}
22421 does not evaluate its lefthand argument.
22423 Most commands apply the default simplifications to all arguments they
22424 take from the stack, perform a particular operation, then simplify
22425 the result before pushing it back on the stack. In the common special
22426 case of regular arithmetic commands like @kbd{+} and @kbd{Q} [@code{sqrt}],
22427 the arguments are simply popped from the stack and collected into a
22428 suitable function call, which is then simplified (the arguments being
22429 simplified first as part of the process, as described above).
22431 The default simplifications are too numerous to describe completely
22432 here, but this section will describe the ones that apply to the
22433 major arithmetic operators. This list will be rather technical in
22434 nature, and will probably be interesting to you only if you are
22435 a serious user of Calc's algebra facilities.
22441 As well as the simplifications described here, if you have stored
22442 any rewrite rules in the variable @code{EvalRules} then these rules
22443 will also be applied before any built-in default simplifications.
22444 @xref{Automatic Rewrites}, for details.
22450 And now, on with the default simplifications:
22452 Arithmetic operators like @kbd{+} and @kbd{*} always take two
22453 arguments in Calc's internal form. Sums and products of three or
22454 more terms are arranged by the associative law of algebra into
22455 a left-associative form for sums, @expr{((a + b) + c) + d}, and
22456 (by default) a right-associative form for products,
22457 @expr{a * (b * (c * d))}. Formulas like @expr{(a + b) + (c + d)} are
22458 rearranged to left-associative form, though this rarely matters since
22459 Calc's algebra commands are designed to hide the inner structure of sums
22460 and products as much as possible. Sums and products in their proper
22461 associative form will be written without parentheses in the examples
22464 Sums and products are @emph{not} rearranged according to the
22465 commutative law (@expr{a + b} to @expr{b + a}) except in a few
22466 special cases described below. Some algebra programs always
22467 rearrange terms into a canonical order, which enables them to
22468 see that @expr{a b + b a} can be simplified to @expr{2 a b}.
22469 Calc assumes you have put the terms into the order you want
22470 and generally leaves that order alone, with the consequence
22471 that formulas like the above will only be simplified if you
22472 explicitly give the @kbd{a s} command. @xref{Algebraic
22475 Differences @expr{a - b} are treated like sums @expr{a + (-b)}
22476 for purposes of simplification; one of the default simplifications
22477 is to rewrite @expr{a + (-b)} or @expr{(-b) + a}, where @expr{-b}
22478 represents a ``negative-looking'' term, into @expr{a - b} form.
22479 ``Negative-looking'' means negative numbers, negated formulas like
22480 @expr{-x}, and products or quotients in which either term is
22483 Other simplifications involving negation are @expr{-(-x)} to @expr{x};
22484 @expr{-(a b)} or @expr{-(a/b)} where either @expr{a} or @expr{b} is
22485 negative-looking, simplified by negating that term, or else where
22486 @expr{a} or @expr{b} is any number, by negating that number;
22487 @expr{-(a + b)} to @expr{-a - b}, and @expr{-(b - a)} to @expr{a - b}.
22488 (This, and rewriting @expr{(-b) + a} to @expr{a - b}, are the only
22489 cases where the order of terms in a sum is changed by the default
22492 The distributive law is used to simplify sums in some cases:
22493 @expr{a x + b x} to @expr{(a + b) x}, where @expr{a} represents
22494 a number or an implicit 1 or @mathit{-1} (as in @expr{x} or @expr{-x})
22495 and similarly for @expr{b}. Use the @kbd{a c}, @w{@kbd{a f}}, or
22496 @kbd{j M} commands to merge sums with non-numeric coefficients
22497 using the distributive law.
22499 The distributive law is only used for sums of two terms, or
22500 for adjacent terms in a larger sum. Thus @expr{a + b + b + c}
22501 is simplified to @expr{a + 2 b + c}, but @expr{a + b + c + b}
22502 is not simplified. The reason is that comparing all terms of a
22503 sum with one another would require time proportional to the
22504 square of the number of terms; Calc relegates potentially slow
22505 operations like this to commands that have to be invoked
22506 explicitly, like @kbd{a s}.
22508 Finally, @expr{a + 0} and @expr{0 + a} are simplified to @expr{a}.
22509 A consequence of the above rules is that @expr{0 - a} is simplified
22516 The products @expr{1 a} and @expr{a 1} are simplified to @expr{a};
22517 @expr{(-1) a} and @expr{a (-1)} are simplified to @expr{-a};
22518 @expr{0 a} and @expr{a 0} are simplified to @expr{0}, except that
22519 in Matrix mode where @expr{a} is not provably scalar the result
22520 is the generic zero matrix @samp{idn(0)}, and that if @expr{a} is
22521 infinite the result is @samp{nan}.
22523 Also, @expr{(-a) b} and @expr{a (-b)} are simplified to @expr{-(a b)},
22524 where this occurs for negated formulas but not for regular negative
22527 Products are commuted only to move numbers to the front:
22528 @expr{a b 2} is commuted to @expr{2 a b}.
22530 The product @expr{a (b + c)} is distributed over the sum only if
22531 @expr{a} and at least one of @expr{b} and @expr{c} are numbers:
22532 @expr{2 (x + 3)} goes to @expr{2 x + 6}. The formula
22533 @expr{(-a) (b - c)}, where @expr{-a} is a negative number, is
22534 rewritten to @expr{a (c - b)}.
22536 The distributive law of products and powers is used for adjacent
22537 terms of the product: @expr{x^a x^b} goes to
22538 @texline @math{x^{a+b}}
22539 @infoline @expr{x^(a+b)}
22540 where @expr{a} is a number, or an implicit 1 (as in @expr{x}),
22541 or the implicit one-half of @expr{@tfn{sqrt}(x)}, and similarly for
22542 @expr{b}. The result is written using @samp{sqrt} or @samp{1/sqrt}
22543 if the sum of the powers is @expr{1/2} or @expr{-1/2}, respectively.
22544 If the sum of the powers is zero, the product is simplified to
22545 @expr{1} or to @samp{idn(1)} if Matrix mode is enabled.
22547 The product of a negative power times anything but another negative
22548 power is changed to use division:
22549 @texline @math{x^{-2} y}
22550 @infoline @expr{x^(-2) y}
22551 goes to @expr{y / x^2} unless Matrix mode is
22552 in effect and neither @expr{x} nor @expr{y} are scalar (in which
22553 case it is considered unsafe to rearrange the order of the terms).
22555 Finally, @expr{a (b/c)} is rewritten to @expr{(a b)/c}, and also
22556 @expr{(a/b) c} is changed to @expr{(a c)/b} unless in Matrix mode.
22562 Simplifications for quotients are analogous to those for products.
22563 The quotient @expr{0 / x} is simplified to @expr{0}, with the same
22564 exceptions that were noted for @expr{0 x}. Likewise, @expr{x / 1}
22565 and @expr{x / (-1)} are simplified to @expr{x} and @expr{-x},
22568 The quotient @expr{x / 0} is left unsimplified or changed to an
22569 infinite quantity, as directed by the current infinite mode.
22570 @xref{Infinite Mode}.
22573 @texline @math{a / b^{-c}}
22574 @infoline @expr{a / b^(-c)}
22575 is changed to @expr{a b^c}, where @expr{-c} is any negative-looking
22576 power. Also, @expr{1 / b^c} is changed to
22577 @texline @math{b^{-c}}
22578 @infoline @expr{b^(-c)}
22579 for any power @expr{c}.
22581 Also, @expr{(-a) / b} and @expr{a / (-b)} go to @expr{-(a/b)};
22582 @expr{(a/b) / c} goes to @expr{a / (b c)}; and @expr{a / (b/c)}
22583 goes to @expr{(a c) / b} unless Matrix mode prevents this
22584 rearrangement. Similarly, @expr{a / (b:c)} is simplified to
22585 @expr{(c:b) a} for any fraction @expr{b:c}.
22587 The distributive law is applied to @expr{(a + b) / c} only if
22588 @expr{c} and at least one of @expr{a} and @expr{b} are numbers.
22589 Quotients of powers and square roots are distributed just as
22590 described for multiplication.
22592 Quotients of products cancel only in the leading terms of the
22593 numerator and denominator. In other words, @expr{a x b / a y b}
22594 is cancelled to @expr{x b / y b} but not to @expr{x / y}. Once
22595 again this is because full cancellation can be slow; use @kbd{a s}
22596 to cancel all terms of the quotient.
22598 Quotients of negative-looking values are simplified according
22599 to @expr{(-a) / (-b)} to @expr{a / b}, @expr{(-a) / (b - c)}
22600 to @expr{a / (c - b)}, and @expr{(a - b) / (-c)} to @expr{(b - a) / c}.
22606 The formula @expr{x^0} is simplified to @expr{1}, or to @samp{idn(1)}
22607 in Matrix mode. The formula @expr{0^x} is simplified to @expr{0}
22608 unless @expr{x} is a negative number, complex number or zero.
22609 If @expr{x} is negative, complex or @expr{0.0}, @expr{0^x} is an
22610 infinity or an unsimplified formula according to the current infinite
22611 mode. The expression @expr{0^0} is simplified to @expr{1}.
22613 Powers of products or quotients @expr{(a b)^c}, @expr{(a/b)^c}
22614 are distributed to @expr{a^c b^c}, @expr{a^c / b^c} only if @expr{c}
22615 is an integer, or if either @expr{a} or @expr{b} are nonnegative
22616 real numbers. Powers of powers @expr{(a^b)^c} are simplified to
22617 @texline @math{a^{b c}}
22618 @infoline @expr{a^(b c)}
22619 only when @expr{c} is an integer and @expr{b c} also
22620 evaluates to an integer. Without these restrictions these simplifications
22621 would not be safe because of problems with principal values.
22623 @texline @math{((-3)^{1/2})^2}
22624 @infoline @expr{((-3)^1:2)^2}
22625 is safe to simplify, but
22626 @texline @math{((-3)^2)^{1/2}}
22627 @infoline @expr{((-3)^2)^1:2}
22628 is not.) @xref{Declarations}, for ways to inform Calc that your
22629 variables satisfy these requirements.
22631 As a special case of this rule, @expr{@tfn{sqrt}(x)^n} is simplified to
22632 @texline @math{x^{n/2}}
22633 @infoline @expr{x^(n/2)}
22634 only for even integers @expr{n}.
22636 If @expr{a} is known to be real, @expr{b} is an even integer, and
22637 @expr{c} is a half- or quarter-integer, then @expr{(a^b)^c} is
22638 simplified to @expr{@tfn{abs}(a^(b c))}.
22640 Also, @expr{(-a)^b} is simplified to @expr{a^b} if @expr{b} is an
22641 even integer, or to @expr{-(a^b)} if @expr{b} is an odd integer,
22642 for any negative-looking expression @expr{-a}.
22644 Square roots @expr{@tfn{sqrt}(x)} generally act like one-half powers
22645 @texline @math{x^{1:2}}
22646 @infoline @expr{x^1:2}
22647 for the purposes of the above-listed simplifications.
22650 @texline @math{1 / x^{1:2}}
22651 @infoline @expr{1 / x^1:2}
22653 @texline @math{x^{-1:2}},
22654 @infoline @expr{x^(-1:2)},
22655 but @expr{1 / @tfn{sqrt}(x)} is left alone.
22661 Generic identity matrices (@pxref{Matrix Mode}) are simplified by the
22662 following rules: @expr{@tfn{idn}(a) + b} to @expr{a + b} if @expr{b}
22663 is provably scalar, or expanded out if @expr{b} is a matrix;
22664 @expr{@tfn{idn}(a) + @tfn{idn}(b)} to @expr{@tfn{idn}(a + b)};
22665 @expr{-@tfn{idn}(a)} to @expr{@tfn{idn}(-a)}; @expr{a @tfn{idn}(b)} to
22666 @expr{@tfn{idn}(a b)} if @expr{a} is provably scalar, or to @expr{a b}
22667 if @expr{a} is provably non-scalar; @expr{@tfn{idn}(a) @tfn{idn}(b)} to
22668 @expr{@tfn{idn}(a b)}; analogous simplifications for quotients involving
22669 @code{idn}; and @expr{@tfn{idn}(a)^n} to @expr{@tfn{idn}(a^n)} where
22670 @expr{n} is an integer.
22676 The @code{floor} function and other integer truncation functions
22677 vanish if the argument is provably integer-valued, so that
22678 @expr{@tfn{floor}(@tfn{round}(x))} simplifies to @expr{@tfn{round}(x)}.
22679 Also, combinations of @code{float}, @code{floor} and its friends,
22680 and @code{ffloor} and its friends, are simplified in appropriate
22681 ways. @xref{Integer Truncation}.
22683 The expression @expr{@tfn{abs}(-x)} changes to @expr{@tfn{abs}(x)}.
22684 The expression @expr{@tfn{abs}(@tfn{abs}(x))} changes to
22685 @expr{@tfn{abs}(x)}; in fact, @expr{@tfn{abs}(x)} changes to @expr{x} or
22686 @expr{-x} if @expr{x} is provably nonnegative or nonpositive
22687 (@pxref{Declarations}).
22689 While most functions do not recognize the variable @code{i} as an
22690 imaginary number, the @code{arg} function does handle the two cases
22691 @expr{@tfn{arg}(@tfn{i})} and @expr{@tfn{arg}(-@tfn{i})} just for convenience.
22693 The expression @expr{@tfn{conj}(@tfn{conj}(x))} simplifies to @expr{x}.
22694 Various other expressions involving @code{conj}, @code{re}, and
22695 @code{im} are simplified, especially if some of the arguments are
22696 provably real or involve the constant @code{i}. For example,
22697 @expr{@tfn{conj}(a + b i)} is changed to
22698 @expr{@tfn{conj}(a) - @tfn{conj}(b) i}, or to @expr{a - b i} if @expr{a}
22699 and @expr{b} are known to be real.
22701 Functions like @code{sin} and @code{arctan} generally don't have
22702 any default simplifications beyond simply evaluating the functions
22703 for suitable numeric arguments and infinity. The @kbd{a s} command
22704 described in the next section does provide some simplifications for
22705 these functions, though.
22707 One important simplification that does occur is that
22708 @expr{@tfn{ln}(@tfn{e})} is simplified to 1, and @expr{@tfn{ln}(@tfn{e}^x)} is
22709 simplified to @expr{x} for any @expr{x}. This occurs even if you have
22710 stored a different value in the Calc variable @samp{e}; but this would
22711 be a bad idea in any case if you were also using natural logarithms!
22713 Among the logical functions, @tfn{!(@var{a} <= @var{b})} changes to
22714 @tfn{@var{a} > @var{b}} and so on. Equations and inequalities where both sides
22715 are either negative-looking or zero are simplified by negating both sides
22716 and reversing the inequality. While it might seem reasonable to simplify
22717 @expr{!!x} to @expr{x}, this would not be valid in general because
22718 @expr{!!2} is 1, not 2.
22720 Most other Calc functions have few if any default simplifications
22721 defined, aside of course from evaluation when the arguments are
22724 @node Algebraic Simplifications, Unsafe Simplifications, Default Simplifications, Simplifying Formulas
22725 @subsection Algebraic Simplifications
22728 @cindex Algebraic simplifications
22729 The @kbd{a s} command makes simplifications that may be too slow to
22730 do all the time, or that may not be desirable all of the time.
22731 If you find these simplifications are worthwhile, you can type
22732 @kbd{m A} to have Calc apply them automatically.
22734 This section describes all simplifications that are performed by
22735 the @kbd{a s} command. Note that these occur in addition to the
22736 default simplifications; even if the default simplifications have
22737 been turned off by an @kbd{m O} command, @kbd{a s} will turn them
22738 back on temporarily while it simplifies the formula.
22740 There is a variable, @code{AlgSimpRules}, in which you can put rewrites
22741 to be applied by @kbd{a s}. Its use is analogous to @code{EvalRules},
22742 but without the special restrictions. Basically, the simplifier does
22743 @samp{@w{a r} AlgSimpRules} with an infinite repeat count on the whole
22744 expression being simplified, then it traverses the expression applying
22745 the built-in rules described below. If the result is different from
22746 the original expression, the process repeats with the default
22747 simplifications (including @code{EvalRules}), then @code{AlgSimpRules},
22748 then the built-in simplifications, and so on.
22754 Sums are simplified in two ways. Constant terms are commuted to the
22755 end of the sum, so that @expr{a + 2 + b} changes to @expr{a + b + 2}.
22756 The only exception is that a constant will not be commuted away
22757 from the first position of a difference, i.e., @expr{2 - x} is not
22758 commuted to @expr{-x + 2}.
22760 Also, terms of sums are combined by the distributive law, as in
22761 @expr{x + y + 2 x} to @expr{y + 3 x}. This always occurs for
22762 adjacent terms, but @kbd{a s} compares all pairs of terms including
22769 Products are sorted into a canonical order using the commutative
22770 law. For example, @expr{b c a} is commuted to @expr{a b c}.
22771 This allows easier comparison of products; for example, the default
22772 simplifications will not change @expr{x y + y x} to @expr{2 x y},
22773 but @kbd{a s} will; it first rewrites the sum to @expr{x y + x y},
22774 and then the default simplifications are able to recognize a sum
22775 of identical terms.
22777 The canonical ordering used to sort terms of products has the
22778 property that real-valued numbers, interval forms and infinities
22779 come first, and are sorted into increasing order. The @kbd{V S}
22780 command uses the same ordering when sorting a vector.
22782 Sorting of terms of products is inhibited when Matrix mode is
22783 turned on; in this case, Calc will never exchange the order of
22784 two terms unless it knows at least one of the terms is a scalar.
22786 Products of powers are distributed by comparing all pairs of
22787 terms, using the same method that the default simplifications
22788 use for adjacent terms of products.
22790 Even though sums are not sorted, the commutative law is still
22791 taken into account when terms of a product are being compared.
22792 Thus @expr{(x + y) (y + x)} will be simplified to @expr{(x + y)^2}.
22793 A subtle point is that @expr{(x - y) (y - x)} will @emph{not}
22794 be simplified to @expr{-(x - y)^2}; Calc does not notice that
22795 one term can be written as a constant times the other, even if
22796 that constant is @mathit{-1}.
22798 A fraction times any expression, @expr{(a:b) x}, is changed to
22799 a quotient involving integers: @expr{a x / b}. This is not
22800 done for floating-point numbers like @expr{0.5}, however. This
22801 is one reason why you may find it convenient to turn Fraction mode
22802 on while doing algebra; @pxref{Fraction Mode}.
22808 Quotients are simplified by comparing all terms in the numerator
22809 with all terms in the denominator for possible cancellation using
22810 the distributive law. For example, @expr{a x^2 b / c x^3 d} will
22811 cancel @expr{x^2} from the top and bottom to get @expr{a b / c x d}.
22812 (The terms in the denominator will then be rearranged to @expr{c d x}
22813 as described above.) If there is any common integer or fractional
22814 factor in the numerator and denominator, it is cancelled out;
22815 for example, @expr{(4 x + 6) / 8 x} simplifies to @expr{(2 x + 3) / 4 x}.
22817 Non-constant common factors are not found even by @kbd{a s}. To
22818 cancel the factor @expr{a} in @expr{(a x + a) / a^2} you could first
22819 use @kbd{j M} on the product @expr{a x} to Merge the numerator to
22820 @expr{a (1+x)}, which can then be simplified successfully.
22826 Integer powers of the variable @code{i} are simplified according
22827 to the identity @expr{i^2 = -1}. If you store a new value other
22828 than the complex number @expr{(0,1)} in @code{i}, this simplification
22829 will no longer occur. This is done by @kbd{a s} instead of by default
22830 in case someone (unwisely) uses the name @code{i} for a variable
22831 unrelated to complex numbers; it would be unfortunate if Calc
22832 quietly and automatically changed this formula for reasons the
22833 user might not have been thinking of.
22835 Square roots of integer or rational arguments are simplified in
22836 several ways. (Note that these will be left unevaluated only in
22837 Symbolic mode.) First, square integer or rational factors are
22838 pulled out so that @expr{@tfn{sqrt}(8)} is rewritten as
22839 @texline @math{2\,@tfn{sqrt}(2)}.
22840 @infoline @expr{2 sqrt(2)}.
22841 Conceptually speaking this implies factoring the argument into primes
22842 and moving pairs of primes out of the square root, but for reasons of
22843 efficiency Calc only looks for primes up to 29.
22845 Square roots in the denominator of a quotient are moved to the
22846 numerator: @expr{1 / @tfn{sqrt}(3)} changes to @expr{@tfn{sqrt}(3) / 3}.
22847 The same effect occurs for the square root of a fraction:
22848 @expr{@tfn{sqrt}(2:3)} changes to @expr{@tfn{sqrt}(6) / 3}.
22854 The @code{%} (modulo) operator is simplified in several ways
22855 when the modulus @expr{M} is a positive real number. First, if
22856 the argument is of the form @expr{x + n} for some real number
22857 @expr{n}, then @expr{n} is itself reduced modulo @expr{M}. For
22858 example, @samp{(x - 23) % 10} is simplified to @samp{(x + 7) % 10}.
22860 If the argument is multiplied by a constant, and this constant
22861 has a common integer divisor with the modulus, then this factor is
22862 cancelled out. For example, @samp{12 x % 15} is changed to
22863 @samp{3 (4 x % 5)} by factoring out 3. Also, @samp{(12 x + 1) % 15}
22864 is changed to @samp{3 ((4 x + 1:3) % 5)}. While these forms may
22865 not seem ``simpler,'' they allow Calc to discover useful information
22866 about modulo forms in the presence of declarations.
22868 If the modulus is 1, then Calc can use @code{int} declarations to
22869 evaluate the expression. For example, the idiom @samp{x % 2} is
22870 often used to check whether a number is odd or even. As described
22871 above, @w{@samp{2 n % 2}} and @samp{(2 n + 1) % 2} are simplified to
22872 @samp{2 (n % 1)} and @samp{2 ((n + 1:2) % 1)}, respectively; Calc
22873 can simplify these to 0 and 1 (respectively) if @code{n} has been
22874 declared to be an integer.
22880 Trigonometric functions are simplified in several ways. Whenever a
22881 products of two trigonometric functions can be replaced by a single
22882 function, the replacement is made; for example,
22883 @expr{@tfn{tan}(x) @tfn{cos}(x)} is simplified to @expr{@tfn{sin}(x)}.
22884 Reciprocals of trigonometric functions are replaced by their reciprocal
22885 function; for example, @expr{1/@tfn{sec}(x)} is simplified to
22886 @expr{@tfn{cos}(x)}. The corresponding simplifications for the
22887 hyperbolic functions are also handled.
22889 Trigonometric functions of their inverse functions are
22890 simplified. The expression @expr{@tfn{sin}(@tfn{arcsin}(x))} is
22891 simplified to @expr{x}, and similarly for @code{cos} and @code{tan}.
22892 Trigonometric functions of inverses of different trigonometric
22893 functions can also be simplified, as in @expr{@tfn{sin}(@tfn{arccos}(x))}
22894 to @expr{@tfn{sqrt}(1 - x^2)}.
22896 If the argument to @code{sin} is negative-looking, it is simplified to
22897 @expr{-@tfn{sin}(x)}, and similarly for @code{cos} and @code{tan}.
22898 Finally, certain special values of the argument are recognized;
22899 @pxref{Trigonometric and Hyperbolic Functions}.
22901 Hyperbolic functions of their inverses and of negative-looking
22902 arguments are also handled, as are exponentials of inverse
22903 hyperbolic functions.
22905 No simplifications for inverse trigonometric and hyperbolic
22906 functions are known, except for negative arguments of @code{arcsin},
22907 @code{arctan}, @code{arcsinh}, and @code{arctanh}. Note that
22908 @expr{@tfn{arcsin}(@tfn{sin}(x))} can @emph{not} safely change to
22909 @expr{x}, since this only correct within an integer multiple of
22910 @texline @math{2 \pi}
22911 @infoline @expr{2 pi}
22912 radians or 360 degrees. However, @expr{@tfn{arcsinh}(@tfn{sinh}(x))} is
22913 simplified to @expr{x} if @expr{x} is known to be real.
22915 Several simplifications that apply to logarithms and exponentials
22916 are that @expr{@tfn{exp}(@tfn{ln}(x))},
22917 @texline @tfn{e}@math{^{\ln(x)}},
22918 @infoline @expr{e^@tfn{ln}(x)},
22920 @texline @math{10^{{\rm log10}(x)}}
22921 @infoline @expr{10^@tfn{log10}(x)}
22922 all reduce to @expr{x}. Also, @expr{@tfn{ln}(@tfn{exp}(x))}, etc., can
22923 reduce to @expr{x} if @expr{x} is provably real. The form
22924 @expr{@tfn{exp}(x)^y} is simplified to @expr{@tfn{exp}(x y)}. If @expr{x}
22925 is a suitable multiple of
22926 @texline @math{\pi i}
22927 @infoline @expr{pi i}
22928 (as described above for the trigonometric functions), then
22929 @expr{@tfn{exp}(x)} or @expr{e^x} will be expanded. Finally,
22930 @expr{@tfn{ln}(x)} is simplified to a form involving @code{pi} and
22931 @code{i} where @expr{x} is provably negative, positive imaginary, or
22932 negative imaginary.
22934 The error functions @code{erf} and @code{erfc} are simplified when
22935 their arguments are negative-looking or are calls to the @code{conj}
22942 Equations and inequalities are simplified by cancelling factors
22943 of products, quotients, or sums on both sides. Inequalities
22944 change sign if a negative multiplicative factor is cancelled.
22945 Non-constant multiplicative factors as in @expr{a b = a c} are
22946 cancelled from equations only if they are provably nonzero (generally
22947 because they were declared so; @pxref{Declarations}). Factors
22948 are cancelled from inequalities only if they are nonzero and their
22951 Simplification also replaces an equation or inequality with
22952 1 or 0 (``true'' or ``false'') if it can through the use of
22953 declarations. If @expr{x} is declared to be an integer greater
22954 than 5, then @expr{x < 3}, @expr{x = 3}, and @expr{x = 7.5} are
22955 all simplified to 0, but @expr{x > 3} is simplified to 1.
22956 By a similar analysis, @expr{abs(x) >= 0} is simplified to 1,
22957 as is @expr{x^2 >= 0} if @expr{x} is known to be real.
22959 @node Unsafe Simplifications, Simplification of Units, Algebraic Simplifications, Simplifying Formulas
22960 @subsection ``Unsafe'' Simplifications
22963 @cindex Unsafe simplifications
22964 @cindex Extended simplification
22966 @pindex calc-simplify-extended
22968 @mindex esimpl@idots
22971 The @kbd{a e} (@code{calc-simplify-extended}) [@code{esimplify}] command
22973 except that it applies some additional simplifications which are not
22974 ``safe'' in all cases. Use this only if you know the values in your
22975 formula lie in the restricted ranges for which these simplifications
22976 are valid. The symbolic integrator uses @kbd{a e};
22977 one effect of this is that the integrator's results must be used with
22978 caution. Where an integral table will often attach conditions like
22979 ``for positive @expr{a} only,'' Calc (like most other symbolic
22980 integration programs) will simply produce an unqualified result.
22982 Because @kbd{a e}'s simplifications are unsafe, it is sometimes better
22983 to type @kbd{C-u -3 a v}, which does extended simplification only
22984 on the top level of the formula without affecting the sub-formulas.
22985 In fact, @kbd{C-u -3 j v} allows you to target extended simplification
22986 to any specific part of a formula.
22988 The variable @code{ExtSimpRules} contains rewrites to be applied by
22989 the @kbd{a e} command. These are applied in addition to
22990 @code{EvalRules} and @code{AlgSimpRules}. (The @kbd{a r AlgSimpRules}
22991 step described above is simply followed by an @kbd{a r ExtSimpRules} step.)
22993 Following is a complete list of ``unsafe'' simplifications performed
23000 Inverse trigonometric or hyperbolic functions, called with their
23001 corresponding non-inverse functions as arguments, are simplified
23002 by @kbd{a e}. For example, @expr{@tfn{arcsin}(@tfn{sin}(x))} changes
23003 to @expr{x}. Also, @expr{@tfn{arcsin}(@tfn{cos}(x))} and
23004 @expr{@tfn{arccos}(@tfn{sin}(x))} both change to @expr{@tfn{pi}/2 - x}.
23005 These simplifications are unsafe because they are valid only for
23006 values of @expr{x} in a certain range; outside that range, values
23007 are folded down to the 360-degree range that the inverse trigonometric
23008 functions always produce.
23010 Powers of powers @expr{(x^a)^b} are simplified to
23011 @texline @math{x^{a b}}
23012 @infoline @expr{x^(a b)}
23013 for all @expr{a} and @expr{b}. These results will be valid only
23014 in a restricted range of @expr{x}; for example, in
23015 @texline @math{(x^2)^{1:2}}
23016 @infoline @expr{(x^2)^1:2}
23017 the powers cancel to get @expr{x}, which is valid for positive values
23018 of @expr{x} but not for negative or complex values.
23020 Similarly, @expr{@tfn{sqrt}(x^a)} and @expr{@tfn{sqrt}(x)^a} are both
23021 simplified (possibly unsafely) to
23022 @texline @math{x^{a/2}}.
23023 @infoline @expr{x^(a/2)}.
23025 Forms like @expr{@tfn{sqrt}(1 - sin(x)^2)} are simplified to, e.g.,
23026 @expr{@tfn{cos}(x)}. Calc has identities of this sort for @code{sin},
23027 @code{cos}, @code{tan}, @code{sinh}, and @code{cosh}.
23029 Arguments of square roots are partially factored to look for
23030 squared terms that can be extracted. For example,
23031 @expr{@tfn{sqrt}(a^2 b^3 + a^3 b^2)} simplifies to
23032 @expr{a b @tfn{sqrt}(a+b)}.
23034 The simplifications of @expr{@tfn{ln}(@tfn{exp}(x))},
23035 @expr{@tfn{ln}(@tfn{e}^x)}, and @expr{@tfn{log10}(10^x)} to @expr{x} are also
23036 unsafe because of problems with principal values (although these
23037 simplifications are safe if @expr{x} is known to be real).
23039 Common factors are cancelled from products on both sides of an
23040 equation, even if those factors may be zero: @expr{a x / b x}
23041 to @expr{a / b}. Such factors are never cancelled from
23042 inequalities: Even @kbd{a e} is not bold enough to reduce
23043 @expr{a x < b x} to @expr{a < b} (or @expr{a > b}, depending
23044 on whether you believe @expr{x} is positive or negative).
23045 The @kbd{a M /} command can be used to divide a factor out of
23046 both sides of an inequality.
23048 @node Simplification of Units, , Unsafe Simplifications, Simplifying Formulas
23049 @subsection Simplification of Units
23052 The simplifications described in this section are applied by the
23053 @kbd{u s} (@code{calc-simplify-units}) command. These are in addition
23054 to the regular @kbd{a s} (but not @kbd{a e}) simplifications described
23055 earlier. @xref{Basic Operations on Units}.
23057 The variable @code{UnitSimpRules} contains rewrites to be applied by
23058 the @kbd{u s} command. These are applied in addition to @code{EvalRules}
23059 and @code{AlgSimpRules}.
23061 Scalar mode is automatically put into effect when simplifying units.
23062 @xref{Matrix Mode}.
23064 Sums @expr{a + b} involving units are simplified by extracting the
23065 units of @expr{a} as if by the @kbd{u x} command (call the result
23066 @expr{u_a}), then simplifying the expression @expr{b / u_a}
23067 using @kbd{u b} and @kbd{u s}. If the result has units then the sum
23068 is inconsistent and is left alone. Otherwise, it is rewritten
23069 in terms of the units @expr{u_a}.
23071 If units auto-ranging mode is enabled, products or quotients in
23072 which the first argument is a number which is out of range for the
23073 leading unit are modified accordingly.
23075 When cancelling and combining units in products and quotients,
23076 Calc accounts for unit names that differ only in the prefix letter.
23077 For example, @samp{2 km m} is simplified to @samp{2000 m^2}.
23078 However, compatible but different units like @code{ft} and @code{in}
23079 are not combined in this way.
23081 Quotients @expr{a / b} are simplified in three additional ways. First,
23082 if @expr{b} is a number or a product beginning with a number, Calc
23083 computes the reciprocal of this number and moves it to the numerator.
23085 Second, for each pair of unit names from the numerator and denominator
23086 of a quotient, if the units are compatible (e.g., they are both
23087 units of area) then they are replaced by the ratio between those
23088 units. For example, in @samp{3 s in N / kg cm} the units
23089 @samp{in / cm} will be replaced by @expr{2.54}.
23091 Third, if the units in the quotient exactly cancel out, so that
23092 a @kbd{u b} command on the quotient would produce a dimensionless
23093 number for an answer, then the quotient simplifies to that number.
23095 For powers and square roots, the ``unsafe'' simplifications
23096 @expr{(a b)^c} to @expr{a^c b^c}, @expr{(a/b)^c} to @expr{a^c / b^c},
23097 and @expr{(a^b)^c} to
23098 @texline @math{a^{b c}}
23099 @infoline @expr{a^(b c)}
23100 are done if the powers are real numbers. (These are safe in the context
23101 of units because all numbers involved can reasonably be assumed to be
23104 Also, if a unit name is raised to a fractional power, and the
23105 base units in that unit name all occur to powers which are a
23106 multiple of the denominator of the power, then the unit name
23107 is expanded out into its base units, which can then be simplified
23108 according to the previous paragraph. For example, @samp{acre^1.5}
23109 is simplified by noting that @expr{1.5 = 3:2}, that @samp{acre}
23110 is defined in terms of @samp{m^2}, and that the 2 in the power of
23111 @code{m} is a multiple of 2 in @expr{3:2}. Thus, @code{acre^1.5} is
23112 replaced by approximately
23113 @texline @math{(4046 m^2)^{1.5}}
23114 @infoline @expr{(4046 m^2)^1.5},
23115 which is then changed to
23116 @texline @math{4046^{1.5} \, (m^2)^{1.5}},
23117 @infoline @expr{4046^1.5 (m^2)^1.5},
23118 then to @expr{257440 m^3}.
23120 The functions @code{float}, @code{frac}, @code{clean}, @code{abs},
23121 as well as @code{floor} and the other integer truncation functions,
23122 applied to unit names or products or quotients involving units, are
23123 simplified. For example, @samp{round(1.6 in)} is changed to
23124 @samp{round(1.6) round(in)}; the lefthand term evaluates to 2,
23125 and the righthand term simplifies to @code{in}.
23127 The functions @code{sin}, @code{cos}, and @code{tan} with arguments
23128 that have angular units like @code{rad} or @code{arcmin} are
23129 simplified by converting to base units (radians), then evaluating
23130 with the angular mode temporarily set to radians.
23132 @node Polynomials, Calculus, Simplifying Formulas, Algebra
23133 @section Polynomials
23135 A @dfn{polynomial} is a sum of terms which are coefficients times
23136 various powers of a ``base'' variable. For example, @expr{2 x^2 + 3 x - 4}
23137 is a polynomial in @expr{x}. Some formulas can be considered
23138 polynomials in several different variables: @expr{1 + 2 x + 3 y + 4 x y^2}
23139 is a polynomial in both @expr{x} and @expr{y}. Polynomial coefficients
23140 are often numbers, but they may in general be any formulas not
23141 involving the base variable.
23144 @pindex calc-factor
23146 The @kbd{a f} (@code{calc-factor}) [@code{factor}] command factors a
23147 polynomial into a product of terms. For example, the polynomial
23148 @expr{x^3 + 2 x^2 + x} is factored into @samp{x*(x+1)^2}. As another
23149 example, @expr{a c + b d + b c + a d} is factored into the product
23150 @expr{(a + b) (c + d)}.
23152 Calc currently has three algorithms for factoring. Formulas which are
23153 linear in several variables, such as the second example above, are
23154 merged according to the distributive law. Formulas which are
23155 polynomials in a single variable, with constant integer or fractional
23156 coefficients, are factored into irreducible linear and/or quadratic
23157 terms. The first example above factors into three linear terms
23158 (@expr{x}, @expr{x+1}, and @expr{x+1} again). Finally, formulas
23159 which do not fit the above criteria are handled by the algebraic
23162 Calc's polynomial factorization algorithm works by using the general
23163 root-finding command (@w{@kbd{a P}}) to solve for the roots of the
23164 polynomial. It then looks for roots which are rational numbers
23165 or complex-conjugate pairs, and converts these into linear and
23166 quadratic terms, respectively. Because it uses floating-point
23167 arithmetic, it may be unable to find terms that involve large
23168 integers (whose number of digits approaches the current precision).
23169 Also, irreducible factors of degree higher than quadratic are not
23170 found, and polynomials in more than one variable are not treated.
23171 (A more robust factorization algorithm may be included in a future
23174 @vindex FactorRules
23186 The rewrite-based factorization method uses rules stored in the variable
23187 @code{FactorRules}. @xref{Rewrite Rules}, for a discussion of the
23188 operation of rewrite rules. The default @code{FactorRules} are able
23189 to factor quadratic forms symbolically into two linear terms,
23190 @expr{(a x + b) (c x + d)}. You can edit these rules to include other
23191 cases if you wish. To use the rules, Calc builds the formula
23192 @samp{thecoefs(x, [a, b, c, ...])} where @code{x} is the polynomial
23193 base variable and @code{a}, @code{b}, etc., are polynomial coefficients
23194 (which may be numbers or formulas). The constant term is written first,
23195 i.e., in the @code{a} position. When the rules complete, they should have
23196 changed the formula into the form @samp{thefactors(x, [f1, f2, f3, ...])}
23197 where each @code{fi} should be a factored term, e.g., @samp{x - ai}.
23198 Calc then multiplies these terms together to get the complete
23199 factored form of the polynomial. If the rules do not change the
23200 @code{thecoefs} call to a @code{thefactors} call, @kbd{a f} leaves the
23201 polynomial alone on the assumption that it is unfactorable. (Note that
23202 the function names @code{thecoefs} and @code{thefactors} are used only
23203 as placeholders; there are no actual Calc functions by those names.)
23207 The @kbd{H a f} [@code{factors}] command also factors a polynomial,
23208 but it returns a list of factors instead of an expression which is the
23209 product of the factors. Each factor is represented by a sub-vector
23210 of the factor, and the power with which it appears. For example,
23211 @expr{x^5 + x^4 - 33 x^3 + 63 x^2} factors to @expr{(x + 7) x^2 (x - 3)^2}
23212 in @kbd{a f}, or to @expr{[ [x, 2], [x+7, 1], [x-3, 2] ]} in @kbd{H a f}.
23213 If there is an overall numeric factor, it always comes first in the list.
23214 The functions @code{factor} and @code{factors} allow a second argument
23215 when written in algebraic form; @samp{factor(x,v)} factors @expr{x} with
23216 respect to the specific variable @expr{v}. The default is to factor with
23217 respect to all the variables that appear in @expr{x}.
23220 @pindex calc-collect
23222 The @kbd{a c} (@code{calc-collect}) [@code{collect}] command rearranges a
23224 polynomial in a given variable, ordered in decreasing powers of that
23225 variable. For example, given @expr{1 + 2 x + 3 y + 4 x y^2} on
23226 the stack, @kbd{a c x} would produce @expr{(2 + 4 y^2) x + (1 + 3 y)},
23227 and @kbd{a c y} would produce @expr{(4 x) y^2 + 3 y + (1 + 2 x)}.
23228 The polynomial will be expanded out using the distributive law as
23229 necessary: Collecting @expr{x} in @expr{(x - 1)^3} produces
23230 @expr{x^3 - 3 x^2 + 3 x - 1}. Terms not involving @expr{x} will
23233 The ``variable'' you specify at the prompt can actually be any
23234 expression: @kbd{a c ln(x+1)} will collect together all terms multiplied
23235 by @samp{ln(x+1)} or integer powers thereof. If @samp{x} also appears
23236 in the formula in a context other than @samp{ln(x+1)}, @kbd{a c} will
23237 treat those occurrences as unrelated to @samp{ln(x+1)}, i.e., as constants.
23240 @pindex calc-expand
23242 The @kbd{a x} (@code{calc-expand}) [@code{expand}] command expands an
23243 expression by applying the distributive law everywhere. It applies to
23244 products, quotients, and powers involving sums. By default, it fully
23245 distributes all parts of the expression. With a numeric prefix argument,
23246 the distributive law is applied only the specified number of times, then
23247 the partially expanded expression is left on the stack.
23249 The @kbd{a x} and @kbd{j D} commands are somewhat redundant. Use
23250 @kbd{a x} if you want to expand all products of sums in your formula.
23251 Use @kbd{j D} if you want to expand a particular specified term of
23252 the formula. There is an exactly analogous correspondence between
23253 @kbd{a f} and @kbd{j M}. (The @kbd{j D} and @kbd{j M} commands
23254 also know many other kinds of expansions, such as
23255 @samp{exp(a + b) = exp(a) exp(b)}, which @kbd{a x} and @kbd{a f}
23258 Calc's automatic simplifications will sometimes reverse a partial
23259 expansion. For example, the first step in expanding @expr{(x+1)^3} is
23260 to write @expr{(x+1) (x+1)^2}. If @kbd{a x} stops there and tries
23261 to put this formula onto the stack, though, Calc will automatically
23262 simplify it back to @expr{(x+1)^3} form. The solution is to turn
23263 simplification off first (@pxref{Simplification Modes}), or to run
23264 @kbd{a x} without a numeric prefix argument so that it expands all
23265 the way in one step.
23270 The @kbd{a a} (@code{calc-apart}) [@code{apart}] command expands a
23271 rational function by partial fractions. A rational function is the
23272 quotient of two polynomials; @code{apart} pulls this apart into a
23273 sum of rational functions with simple denominators. In algebraic
23274 notation, the @code{apart} function allows a second argument that
23275 specifies which variable to use as the ``base''; by default, Calc
23276 chooses the base variable automatically.
23279 @pindex calc-normalize-rat
23281 The @kbd{a n} (@code{calc-normalize-rat}) [@code{nrat}] command
23282 attempts to arrange a formula into a quotient of two polynomials.
23283 For example, given @expr{1 + (a + b/c) / d}, the result would be
23284 @expr{(b + a c + c d) / c d}. The quotient is reduced, so that
23285 @kbd{a n} will simplify @expr{(x^2 + 2x + 1) / (x^2 - 1)} by dividing
23286 out the common factor @expr{x + 1}, yielding @expr{(x + 1) / (x - 1)}.
23289 @pindex calc-poly-div
23291 The @kbd{a \} (@code{calc-poly-div}) [@code{pdiv}] command divides
23292 two polynomials @expr{u} and @expr{v}, yielding a new polynomial
23293 @expr{q}. If several variables occur in the inputs, the inputs are
23294 considered multivariate polynomials. (Calc divides by the variable
23295 with the largest power in @expr{u} first, or, in the case of equal
23296 powers, chooses the variables in alphabetical order.) For example,
23297 dividing @expr{x^2 + 3 x + 2} by @expr{x + 2} yields @expr{x + 1}.
23298 The remainder from the division, if any, is reported at the bottom
23299 of the screen and is also placed in the Trail along with the quotient.
23301 Using @code{pdiv} in algebraic notation, you can specify the particular
23302 variable to be used as the base: @code{pdiv(@var{a},@var{b},@var{x})}.
23303 If @code{pdiv} is given only two arguments (as is always the case with
23304 the @kbd{a \} command), then it does a multivariate division as outlined
23308 @pindex calc-poly-rem
23310 The @kbd{a %} (@code{calc-poly-rem}) [@code{prem}] command divides
23311 two polynomials and keeps the remainder @expr{r}. The quotient
23312 @expr{q} is discarded. For any formulas @expr{a} and @expr{b}, the
23313 results of @kbd{a \} and @kbd{a %} satisfy @expr{a = q b + r}.
23314 (This is analogous to plain @kbd{\} and @kbd{%}, which compute the
23315 integer quotient and remainder from dividing two numbers.)
23319 @pindex calc-poly-div-rem
23322 The @kbd{a /} (@code{calc-poly-div-rem}) [@code{pdivrem}] command
23323 divides two polynomials and reports both the quotient and the
23324 remainder as a vector @expr{[q, r]}. The @kbd{H a /} [@code{pdivide}]
23325 command divides two polynomials and constructs the formula
23326 @expr{q + r/b} on the stack. (Naturally if the remainder is zero,
23327 this will immediately simplify to @expr{q}.)
23330 @pindex calc-poly-gcd
23332 The @kbd{a g} (@code{calc-poly-gcd}) [@code{pgcd}] command computes
23333 the greatest common divisor of two polynomials. (The GCD actually
23334 is unique only to within a constant multiplier; Calc attempts to
23335 choose a GCD which will be unsurprising.) For example, the @kbd{a n}
23336 command uses @kbd{a g} to take the GCD of the numerator and denominator
23337 of a quotient, then divides each by the result using @kbd{a \}. (The
23338 definition of GCD ensures that this division can take place without
23339 leaving a remainder.)
23341 While the polynomials used in operations like @kbd{a /} and @kbd{a g}
23342 often have integer coefficients, this is not required. Calc can also
23343 deal with polynomials over the rationals or floating-point reals.
23344 Polynomials with modulo-form coefficients are also useful in many
23345 applications; if you enter @samp{(x^2 + 3 x - 1) mod 5}, Calc
23346 automatically transforms this into a polynomial over the field of
23347 integers mod 5: @samp{(1 mod 5) x^2 + (3 mod 5) x + (4 mod 5)}.
23349 Congratulations and thanks go to Ove Ewerlid
23350 (@code{ewerlid@@mizar.DoCS.UU.SE}), who contributed many of the
23351 polynomial routines used in the above commands.
23353 @xref{Decomposing Polynomials}, for several useful functions for
23354 extracting the individual coefficients of a polynomial.
23356 @node Calculus, Solving Equations, Polynomials, Algebra
23360 The following calculus commands do not automatically simplify their
23361 inputs or outputs using @code{calc-simplify}. You may find it helps
23362 to do this by hand by typing @kbd{a s} or @kbd{a e}. It may also help
23363 to use @kbd{a x} and/or @kbd{a c} to arrange a result in the most
23367 * Differentiation::
23369 * Customizing the Integrator::
23370 * Numerical Integration::
23374 @node Differentiation, Integration, Calculus, Calculus
23375 @subsection Differentiation
23380 @pindex calc-derivative
23383 The @kbd{a d} (@code{calc-derivative}) [@code{deriv}] command computes
23384 the derivative of the expression on the top of the stack with respect to
23385 some variable, which it will prompt you to enter. Normally, variables
23386 in the formula other than the specified differentiation variable are
23387 considered constant, i.e., @samp{deriv(y,x)} is reduced to zero. With
23388 the Hyperbolic flag, the @code{tderiv} (total derivative) operation is used
23389 instead, in which derivatives of variables are not reduced to zero
23390 unless those variables are known to be ``constant,'' i.e., independent
23391 of any other variables. (The built-in special variables like @code{pi}
23392 are considered constant, as are variables that have been declared
23393 @code{const}; @pxref{Declarations}.)
23395 With a numeric prefix argument @var{n}, this command computes the
23396 @var{n}th derivative.
23398 When working with trigonometric functions, it is best to switch to
23399 Radians mode first (with @w{@kbd{m r}}). The derivative of @samp{sin(x)}
23400 in degrees is @samp{(pi/180) cos(x)}, probably not the expected
23403 If you use the @code{deriv} function directly in an algebraic formula,
23404 you can write @samp{deriv(f,x,x0)} which represents the derivative
23405 of @expr{f} with respect to @expr{x}, evaluated at the point
23406 @texline @math{x=x_0}.
23407 @infoline @expr{x=x0}.
23409 If the formula being differentiated contains functions which Calc does
23410 not know, the derivatives of those functions are produced by adding
23411 primes (apostrophe characters). For example, @samp{deriv(f(2x), x)}
23412 produces @samp{2 f'(2 x)}, where the function @code{f'} represents the
23413 derivative of @code{f}.
23415 For functions you have defined with the @kbd{Z F} command, Calc expands
23416 the functions according to their defining formulas unless you have
23417 also defined @code{f'} suitably. For example, suppose we define
23418 @samp{sinc(x) = sin(x)/x} using @kbd{Z F}. If we then differentiate
23419 the formula @samp{sinc(2 x)}, the formula will be expanded to
23420 @samp{sin(2 x) / (2 x)} and differentiated. However, if we also
23421 define @samp{sinc'(x) = dsinc(x)}, say, then Calc will write the
23422 result as @samp{2 dsinc(2 x)}. @xref{Algebraic Definitions}.
23424 For multi-argument functions @samp{f(x,y,z)}, the derivative with respect
23425 to the first argument is written @samp{f'(x,y,z)}; derivatives with
23426 respect to the other arguments are @samp{f'2(x,y,z)} and @samp{f'3(x,y,z)}.
23427 Various higher-order derivatives can be formed in the obvious way, e.g.,
23428 @samp{f'@var{}'(x)} (the second derivative of @code{f}) or
23429 @samp{f'@var{}'2'3(x,y,z)} (@code{f} differentiated with respect to each
23432 @node Integration, Customizing the Integrator, Differentiation, Calculus
23433 @subsection Integration
23437 @pindex calc-integral
23439 The @kbd{a i} (@code{calc-integral}) [@code{integ}] command computes the
23440 indefinite integral of the expression on the top of the stack with
23441 respect to a prompted-for variable. The integrator is not guaranteed to
23442 work for all integrable functions, but it is able to integrate several
23443 large classes of formulas. In particular, any polynomial or rational
23444 function (a polynomial divided by a polynomial) is acceptable.
23445 (Rational functions don't have to be in explicit quotient form, however;
23446 @texline @math{x/(1+x^{-2})}
23447 @infoline @expr{x/(1+x^-2)}
23448 is not strictly a quotient of polynomials, but it is equivalent to
23449 @expr{x^3/(x^2+1)}, which is.) Also, square roots of terms involving
23450 @expr{x} and @expr{x^2} may appear in rational functions being
23451 integrated. Finally, rational functions involving trigonometric or
23452 hyperbolic functions can be integrated.
23454 With an argument (@kbd{C-u a i}), this command will compute the definite
23455 integral of the expression on top of the stack. In this case, the
23456 command will again prompt for an integration variable, then prompt for a
23457 lower limit and an upper limit.
23460 If you use the @code{integ} function directly in an algebraic formula,
23461 you can also write @samp{integ(f,x,v)} which expresses the resulting
23462 indefinite integral in terms of variable @code{v} instead of @code{x}.
23463 With four arguments, @samp{integ(f(x),x,a,b)} represents a definite
23464 integral from @code{a} to @code{b}.
23467 If you use the @code{integ} function directly in an algebraic formula,
23468 you can also write @samp{integ(f,x,v)} which expresses the resulting
23469 indefinite integral in terms of variable @code{v} instead of @code{x}.
23470 With four arguments, @samp{integ(f(x),x,a,b)} represents a definite
23471 integral $\int_a^b f(x) \, dx$.
23474 Please note that the current implementation of Calc's integrator sometimes
23475 produces results that are significantly more complex than they need to
23476 be. For example, the integral Calc finds for
23477 @texline @math{1/(x+\sqrt{x^2+1})}
23478 @infoline @expr{1/(x+sqrt(x^2+1))}
23479 is several times more complicated than the answer Mathematica
23480 returns for the same input, although the two forms are numerically
23481 equivalent. Also, any indefinite integral should be considered to have
23482 an arbitrary constant of integration added to it, although Calc does not
23483 write an explicit constant of integration in its result. For example,
23484 Calc's solution for
23485 @texline @math{1/(1+\tan x)}
23486 @infoline @expr{1/(1+tan(x))}
23487 differs from the solution given in the @emph{CRC Math Tables} by a
23489 @texline @math{\pi i / 2}
23490 @infoline @expr{pi i / 2},
23491 due to a different choice of constant of integration.
23493 The Calculator remembers all the integrals it has done. If conditions
23494 change in a way that would invalidate the old integrals, say, a switch
23495 from Degrees to Radians mode, then they will be thrown out. If you
23496 suspect this is not happening when it should, use the
23497 @code{calc-flush-caches} command; @pxref{Caches}.
23500 Calc normally will pursue integration by substitution or integration by
23501 parts up to 3 nested times before abandoning an approach as fruitless.
23502 If the integrator is taking too long, you can lower this limit by storing
23503 a number (like 2) in the variable @code{IntegLimit}. (The @kbd{s I}
23504 command is a convenient way to edit @code{IntegLimit}.) If this variable
23505 has no stored value or does not contain a nonnegative integer, a limit
23506 of 3 is used. The lower this limit is, the greater the chance that Calc
23507 will be unable to integrate a function it could otherwise handle. Raising
23508 this limit allows the Calculator to solve more integrals, though the time
23509 it takes may grow exponentially. You can monitor the integrator's actions
23510 by creating an Emacs buffer called @code{*Trace*}. If such a buffer
23511 exists, the @kbd{a i} command will write a log of its actions there.
23513 If you want to manipulate integrals in a purely symbolic way, you can
23514 set the integration nesting limit to 0 to prevent all but fast
23515 table-lookup solutions of integrals. You might then wish to define
23516 rewrite rules for integration by parts, various kinds of substitutions,
23517 and so on. @xref{Rewrite Rules}.
23519 @node Customizing the Integrator, Numerical Integration, Integration, Calculus
23520 @subsection Customizing the Integrator
23524 Calc has two built-in rewrite rules called @code{IntegRules} and
23525 @code{IntegAfterRules} which you can edit to define new integration
23526 methods. @xref{Rewrite Rules}. At each step of the integration process,
23527 Calc wraps the current integrand in a call to the fictitious function
23528 @samp{integtry(@var{expr},@var{var})}, where @var{expr} is the
23529 integrand and @var{var} is the integration variable. If your rules
23530 rewrite this to be a plain formula (not a call to @code{integtry}), then
23531 Calc will use this formula as the integral of @var{expr}. For example,
23532 the rule @samp{integtry(mysin(x),x) := -mycos(x)} would define a rule to
23533 integrate a function @code{mysin} that acts like the sine function.
23534 Then, putting @samp{4 mysin(2y+1)} on the stack and typing @kbd{a i y}
23535 will produce the integral @samp{-2 mycos(2y+1)}. Note that Calc has
23536 automatically made various transformations on the integral to allow it
23537 to use your rule; integral tables generally give rules for
23538 @samp{mysin(a x + b)}, but you don't need to use this much generality
23539 in your @code{IntegRules}.
23541 @cindex Exponential integral Ei(x)
23546 As a more serious example, the expression @samp{exp(x)/x} cannot be
23547 integrated in terms of the standard functions, so the ``exponential
23548 integral'' function
23549 @texline @math{{\rm Ei}(x)}
23550 @infoline @expr{Ei(x)}
23551 was invented to describe it.
23552 We can get Calc to do this integral in terms of a made-up @code{Ei}
23553 function by adding the rule @samp{[integtry(exp(x)/x, x) := Ei(x)]}
23554 to @code{IntegRules}. Now entering @samp{exp(2x)/x} on the stack
23555 and typing @kbd{a i x} yields @samp{Ei(2 x)}. This new rule will
23556 work with Calc's various built-in integration methods (such as
23557 integration by substitution) to solve a variety of other problems
23558 involving @code{Ei}: For example, now Calc will also be able to
23559 integrate @samp{exp(exp(x))} and @samp{ln(ln(x))} (to get @samp{Ei(exp(x))}
23560 and @samp{x ln(ln(x)) - Ei(ln(x))}, respectively).
23562 Your rule may do further integration by calling @code{integ}. For
23563 example, @samp{integtry(twice(u),x) := twice(integ(u))} allows Calc
23564 to integrate @samp{twice(sin(x))} to get @samp{twice(-cos(x))}.
23565 Note that @code{integ} was called with only one argument. This notation
23566 is allowed only within @code{IntegRules}; it means ``integrate this
23567 with respect to the same integration variable.'' If Calc is unable
23568 to integrate @code{u}, the integration that invoked @code{IntegRules}
23569 also fails. Thus integrating @samp{twice(f(x))} fails, returning the
23570 unevaluated integral @samp{integ(twice(f(x)), x)}. It is still valid
23571 to call @code{integ} with two or more arguments, however; in this case,
23572 if @code{u} is not integrable, @code{twice} itself will still be
23573 integrated: If the above rule is changed to @samp{... := twice(integ(u,x))},
23574 then integrating @samp{twice(f(x))} will yield @samp{twice(integ(f(x),x))}.
23576 If a rule instead produces the formula @samp{integsubst(@var{sexpr},
23577 @var{svar})}, either replacing the top-level @code{integtry} call or
23578 nested anywhere inside the expression, then Calc will apply the
23579 substitution @samp{@var{u} = @var{sexpr}(@var{svar})} to try to
23580 integrate the original @var{expr}. For example, the rule
23581 @samp{sqrt(a) := integsubst(sqrt(x),x)} says that if Calc ever finds
23582 a square root in the integrand, it should attempt the substitution
23583 @samp{u = sqrt(x)}. (This particular rule is unnecessary because
23584 Calc always tries ``obvious'' substitutions where @var{sexpr} actually
23585 appears in the integrand.) The variable @var{svar} may be the same
23586 as the @var{var} that appeared in the call to @code{integtry}, but
23589 When integrating according to an @code{integsubst}, Calc uses the
23590 equation solver to find the inverse of @var{sexpr} (if the integrand
23591 refers to @var{var} anywhere except in subexpressions that exactly
23592 match @var{sexpr}). It uses the differentiator to find the derivative
23593 of @var{sexpr} and/or its inverse (it has two methods that use one
23594 derivative or the other). You can also specify these items by adding
23595 extra arguments to the @code{integsubst} your rules construct; the
23596 general form is @samp{integsubst(@var{sexpr}, @var{svar}, @var{sinv},
23597 @var{sprime})}, where @var{sinv} is the inverse of @var{sexpr} (still
23598 written as a function of @var{svar}), and @var{sprime} is the
23599 derivative of @var{sexpr} with respect to @var{svar}. If you don't
23600 specify these things, and Calc is not able to work them out on its
23601 own with the information it knows, then your substitution rule will
23602 work only in very specific, simple cases.
23604 Calc applies @code{IntegRules} as if by @kbd{C-u 1 a r IntegRules};
23605 in other words, Calc stops rewriting as soon as any rule in your rule
23606 set succeeds. (If it weren't for this, the @samp{integsubst(sqrt(x),x)}
23607 example above would keep on adding layers of @code{integsubst} calls
23610 @vindex IntegSimpRules
23611 Another set of rules, stored in @code{IntegSimpRules}, are applied
23612 every time the integrator uses @kbd{a s} to simplify an intermediate
23613 result. For example, putting the rule @samp{twice(x) := 2 x} into
23614 @code{IntegSimpRules} would tell Calc to convert the @code{twice}
23615 function into a form it knows whenever integration is attempted.
23617 One more way to influence the integrator is to define a function with
23618 the @kbd{Z F} command (@pxref{Algebraic Definitions}). Calc's
23619 integrator automatically expands such functions according to their
23620 defining formulas, even if you originally asked for the function to
23621 be left unevaluated for symbolic arguments. (Certain other Calc
23622 systems, such as the differentiator and the equation solver, also
23625 @vindex IntegAfterRules
23626 Sometimes Calc is able to find a solution to your integral, but it
23627 expresses the result in a way that is unnecessarily complicated. If
23628 this happens, you can either use @code{integsubst} as described
23629 above to try to hint at a more direct path to the desired result, or
23630 you can use @code{IntegAfterRules}. This is an extra rule set that
23631 runs after the main integrator returns its result; basically, Calc does
23632 an @kbd{a r IntegAfterRules} on the result before showing it to you.
23633 (It also does an @kbd{a s}, without @code{IntegSimpRules}, after that
23634 to further simplify the result.) For example, Calc's integrator
23635 sometimes produces expressions of the form @samp{ln(1+x) - ln(1-x)};
23636 the default @code{IntegAfterRules} rewrite this into the more readable
23637 form @samp{2 arctanh(x)}. Note that, unlike @code{IntegRules},
23638 @code{IntegSimpRules} and @code{IntegAfterRules} are applied any number
23639 of times until no further changes are possible. Rewriting by
23640 @code{IntegAfterRules} occurs only after the main integrator has
23641 finished, not at every step as for @code{IntegRules} and
23642 @code{IntegSimpRules}.
23644 @node Numerical Integration, Taylor Series, Customizing the Integrator, Calculus
23645 @subsection Numerical Integration
23649 @pindex calc-num-integral
23651 If you want a purely numerical answer to an integration problem, you can
23652 use the @kbd{a I} (@code{calc-num-integral}) [@code{ninteg}] command. This
23653 command prompts for an integration variable, a lower limit, and an
23654 upper limit. Except for the integration variable, all other variables
23655 that appear in the integrand formula must have stored values. (A stored
23656 value, if any, for the integration variable itself is ignored.)
23658 Numerical integration works by evaluating your formula at many points in
23659 the specified interval. Calc uses an ``open Romberg'' method; this means
23660 that it does not evaluate the formula actually at the endpoints (so that
23661 it is safe to integrate @samp{sin(x)/x} from zero, for example). Also,
23662 the Romberg method works especially well when the function being
23663 integrated is fairly smooth. If the function is not smooth, Calc will
23664 have to evaluate it at quite a few points before it can accurately
23665 determine the value of the integral.
23667 Integration is much faster when the current precision is small. It is
23668 best to set the precision to the smallest acceptable number of digits
23669 before you use @kbd{a I}. If Calc appears to be taking too long, press
23670 @kbd{C-g} to halt it and try a lower precision. If Calc still appears
23671 to need hundreds of evaluations, check to make sure your function is
23672 well-behaved in the specified interval.
23674 It is possible for the lower integration limit to be @samp{-inf} (minus
23675 infinity). Likewise, the upper limit may be plus infinity. Calc
23676 internally transforms the integral into an equivalent one with finite
23677 limits. However, integration to or across singularities is not supported:
23678 The integral of @samp{1/sqrt(x)} from 0 to 1 exists (it can be found
23679 by Calc's symbolic integrator, for example), but @kbd{a I} will fail
23680 because the integrand goes to infinity at one of the endpoints.
23682 @node Taylor Series, , Numerical Integration, Calculus
23683 @subsection Taylor Series
23687 @pindex calc-taylor
23689 The @kbd{a t} (@code{calc-taylor}) [@code{taylor}] command computes a
23690 power series expansion or Taylor series of a function. You specify the
23691 variable and the desired number of terms. You may give an expression of
23692 the form @samp{@var{var} = @var{a}} or @samp{@var{var} - @var{a}} instead
23693 of just a variable to produce a Taylor expansion about the point @var{a}.
23694 You may specify the number of terms with a numeric prefix argument;
23695 otherwise the command will prompt you for the number of terms. Note that
23696 many series expansions have coefficients of zero for some terms, so you
23697 may appear to get fewer terms than you asked for.
23699 If the @kbd{a i} command is unable to find a symbolic integral for a
23700 function, you can get an approximation by integrating the function's
23703 @node Solving Equations, Numerical Solutions, Calculus, Algebra
23704 @section Solving Equations
23708 @pindex calc-solve-for
23710 @cindex Equations, solving
23711 @cindex Solving equations
23712 The @kbd{a S} (@code{calc-solve-for}) [@code{solve}] command rearranges
23713 an equation to solve for a specific variable. An equation is an
23714 expression of the form @expr{L = R}. For example, the command @kbd{a S x}
23715 will rearrange @expr{y = 3x + 6} to the form, @expr{x = y/3 - 2}. If the
23716 input is not an equation, it is treated like an equation of the
23719 This command also works for inequalities, as in @expr{y < 3x + 6}.
23720 Some inequalities cannot be solved where the analogous equation could
23721 be; for example, solving
23722 @texline @math{a < b \, c}
23723 @infoline @expr{a < b c}
23724 for @expr{b} is impossible
23725 without knowing the sign of @expr{c}. In this case, @kbd{a S} will
23727 @texline @math{b \mathbin{\hbox{\code{!=}}} a/c}
23728 @infoline @expr{b != a/c}
23729 (using the not-equal-to operator) to signify that the direction of the
23730 inequality is now unknown. The inequality
23731 @texline @math{a \le b \, c}
23732 @infoline @expr{a <= b c}
23733 is not even partially solved. @xref{Declarations}, for a way to tell
23734 Calc that the signs of the variables in a formula are in fact known.
23736 Two useful commands for working with the result of @kbd{a S} are
23737 @kbd{a .} (@pxref{Logical Operations}), which converts @expr{x = y/3 - 2}
23738 to @expr{y/3 - 2}, and @kbd{s l} (@pxref{Let Command}) which evaluates
23739 another formula with @expr{x} set equal to @expr{y/3 - 2}.
23742 * Multiple Solutions::
23743 * Solving Systems of Equations::
23744 * Decomposing Polynomials::
23747 @node Multiple Solutions, Solving Systems of Equations, Solving Equations, Solving Equations
23748 @subsection Multiple Solutions
23753 Some equations have more than one solution. The Hyperbolic flag
23754 (@code{H a S}) [@code{fsolve}] tells the solver to report the fully
23755 general family of solutions. It will invent variables @code{n1},
23756 @code{n2}, @dots{}, which represent independent arbitrary integers, and
23757 @code{s1}, @code{s2}, @dots{}, which represent independent arbitrary
23758 signs (either @mathit{+1} or @mathit{-1}). If you don't use the Hyperbolic
23759 flag, Calc will use zero in place of all arbitrary integers, and plus
23760 one in place of all arbitrary signs. Note that variables like @code{n1}
23761 and @code{s1} are not given any special interpretation in Calc except by
23762 the equation solver itself. As usual, you can use the @w{@kbd{s l}}
23763 (@code{calc-let}) command to obtain solutions for various actual values
23764 of these variables.
23766 For example, @kbd{' x^2 = y @key{RET} H a S x @key{RET}} solves to
23767 get @samp{x = s1 sqrt(y)}, indicating that the two solutions to the
23768 equation are @samp{sqrt(y)} and @samp{-sqrt(y)}. Another way to
23769 think about it is that the square-root operation is really a
23770 two-valued function; since every Calc function must return a
23771 single result, @code{sqrt} chooses to return the positive result.
23772 Then @kbd{H a S} doctors this result using @code{s1} to indicate
23773 the full set of possible values of the mathematical square-root.
23775 There is a similar phenomenon going the other direction: Suppose
23776 we solve @samp{sqrt(y) = x} for @code{y}. Calc squares both sides
23777 to get @samp{y = x^2}. This is correct, except that it introduces
23778 some dubious solutions. Consider solving @samp{sqrt(y) = -3}:
23779 Calc will report @expr{y = 9} as a valid solution, which is true
23780 in the mathematical sense of square-root, but false (there is no
23781 solution) for the actual Calc positive-valued @code{sqrt}. This
23782 happens for both @kbd{a S} and @kbd{H a S}.
23784 @cindex @code{GenCount} variable
23794 If you store a positive integer in the Calc variable @code{GenCount},
23795 then Calc will generate formulas of the form @samp{as(@var{n})} for
23796 arbitrary signs, and @samp{an(@var{n})} for arbitrary integers,
23797 where @var{n} represents successive values taken by incrementing
23798 @code{GenCount} by one. While the normal arbitrary sign and
23799 integer symbols start over at @code{s1} and @code{n1} with each
23800 new Calc command, the @code{GenCount} approach will give each
23801 arbitrary value a name that is unique throughout the entire Calc
23802 session. Also, the arbitrary values are function calls instead
23803 of variables, which is advantageous in some cases. For example,
23804 you can make a rewrite rule that recognizes all arbitrary signs
23805 using a pattern like @samp{as(n)}. The @kbd{s l} command only works
23806 on variables, but you can use the @kbd{a b} (@code{calc-substitute})
23807 command to substitute actual values for function calls like @samp{as(3)}.
23809 The @kbd{s G} (@code{calc-edit-GenCount}) command is a convenient
23810 way to create or edit this variable. Press @kbd{C-c C-c} to finish.
23812 If you have not stored a value in @code{GenCount}, or if the value
23813 in that variable is not a positive integer, the regular
23814 @code{s1}/@code{n1} notation is used.
23820 With the Inverse flag, @kbd{I a S} [@code{finv}] treats the expression
23821 on top of the stack as a function of the specified variable and solves
23822 to find the inverse function, written in terms of the same variable.
23823 For example, @kbd{I a S x} inverts @expr{2x + 6} to @expr{x/2 - 3}.
23824 You can use both Inverse and Hyperbolic [@code{ffinv}] to obtain a
23825 fully general inverse, as described above.
23828 @pindex calc-poly-roots
23830 Some equations, specifically polynomials, have a known, finite number
23831 of solutions. The @kbd{a P} (@code{calc-poly-roots}) [@code{roots}]
23832 command uses @kbd{H a S} to solve an equation in general form, then, for
23833 all arbitrary-sign variables like @code{s1}, and all arbitrary-integer
23834 variables like @code{n1} for which @code{n1} only usefully varies over
23835 a finite range, it expands these variables out to all their possible
23836 values. The results are collected into a vector, which is returned.
23837 For example, @samp{roots(x^4 = 1, x)} returns the four solutions
23838 @samp{[1, -1, (0, 1), (0, -1)]}. Generally an @var{n}th degree
23839 polynomial will always have @var{n} roots on the complex plane.
23840 (If you have given a @code{real} declaration for the solution
23841 variable, then only the real-valued solutions, if any, will be
23842 reported; @pxref{Declarations}.)
23844 Note that because @kbd{a P} uses @kbd{H a S}, it is able to deliver
23845 symbolic solutions if the polynomial has symbolic coefficients. Also
23846 note that Calc's solver is not able to get exact symbolic solutions
23847 to all polynomials. Polynomials containing powers up to @expr{x^4}
23848 can always be solved exactly; polynomials of higher degree sometimes
23849 can be: @expr{x^6 + x^3 + 1} is converted to @expr{(x^3)^2 + (x^3) + 1},
23850 which can be solved for @expr{x^3} using the quadratic equation, and then
23851 for @expr{x} by taking cube roots. But in many cases, like
23852 @expr{x^6 + x + 1}, Calc does not know how to rewrite the polynomial
23853 into a form it can solve. The @kbd{a P} command can still deliver a
23854 list of numerical roots, however, provided that Symbolic mode (@kbd{m s})
23855 is not turned on. (If you work with Symbolic mode on, recall that the
23856 @kbd{N} (@code{calc-eval-num}) key is a handy way to reevaluate the
23857 formula on the stack with Symbolic mode temporarily off.) Naturally,
23858 @kbd{a P} can only provide numerical roots if the polynomial coefficients
23859 are all numbers (real or complex).
23861 @node Solving Systems of Equations, Decomposing Polynomials, Multiple Solutions, Solving Equations
23862 @subsection Solving Systems of Equations
23865 @cindex Systems of equations, symbolic
23866 You can also use the commands described above to solve systems of
23867 simultaneous equations. Just create a vector of equations, then
23868 specify a vector of variables for which to solve. (You can omit
23869 the surrounding brackets when entering the vector of variables
23872 For example, putting @samp{[x + y = a, x - y = b]} on the stack
23873 and typing @kbd{a S x,y @key{RET}} produces the vector of solutions
23874 @samp{[x = a - (a-b)/2, y = (a-b)/2]}. The result vector will
23875 have the same length as the variables vector, and the variables
23876 will be listed in the same order there. Note that the solutions
23877 are not always simplified as far as possible; the solution for
23878 @expr{x} here could be improved by an application of the @kbd{a n}
23881 Calc's algorithm works by trying to eliminate one variable at a
23882 time by solving one of the equations for that variable and then
23883 substituting into the other equations. Calc will try all the
23884 possibilities, but you can speed things up by noting that Calc
23885 first tries to eliminate the first variable with the first
23886 equation, then the second variable with the second equation,
23887 and so on. It also helps to put the simpler (e.g., more linear)
23888 equations toward the front of the list. Calc's algorithm will
23889 solve any system of linear equations, and also many kinds of
23896 Normally there will be as many variables as equations. If you
23897 give fewer variables than equations (an ``over-determined'' system
23898 of equations), Calc will find a partial solution. For example,
23899 typing @kbd{a S y @key{RET}} with the above system of equations
23900 would produce @samp{[y = a - x]}. There are now several ways to
23901 express this solution in terms of the original variables; Calc uses
23902 the first one that it finds. You can control the choice by adding
23903 variable specifiers of the form @samp{elim(@var{v})} to the
23904 variables list. This says that @var{v} should be eliminated from
23905 the equations; the variable will not appear at all in the solution.
23906 For example, typing @kbd{a S y,elim(x)} would yield
23907 @samp{[y = a - (b+a)/2]}.
23909 If the variables list contains only @code{elim} specifiers,
23910 Calc simply eliminates those variables from the equations
23911 and then returns the resulting set of equations. For example,
23912 @kbd{a S elim(x)} produces @samp{[a - 2 y = b]}. Every variable
23913 eliminated will reduce the number of equations in the system
23916 Again, @kbd{a S} gives you one solution to the system of
23917 equations. If there are several solutions, you can use @kbd{H a S}
23918 to get a general family of solutions, or, if there is a finite
23919 number of solutions, you can use @kbd{a P} to get a list. (In
23920 the latter case, the result will take the form of a matrix where
23921 the rows are different solutions and the columns correspond to the
23922 variables you requested.)
23924 Another way to deal with certain kinds of overdetermined systems of
23925 equations is the @kbd{a F} command, which does least-squares fitting
23926 to satisfy the equations. @xref{Curve Fitting}.
23928 @node Decomposing Polynomials, , Solving Systems of Equations, Solving Equations
23929 @subsection Decomposing Polynomials
23936 The @code{poly} function takes a polynomial and a variable as
23937 arguments, and returns a vector of polynomial coefficients (constant
23938 coefficient first). For example, @samp{poly(x^3 + 2 x, x)} returns
23939 @expr{[0, 2, 0, 1]}. If the input is not a polynomial in @expr{x},
23940 the call to @code{poly} is left in symbolic form. If the input does
23941 not involve the variable @expr{x}, the input is returned in a list
23942 of length one, representing a polynomial with only a constant
23943 coefficient. The call @samp{poly(x, x)} returns the vector @expr{[0, 1]}.
23944 The last element of the returned vector is guaranteed to be nonzero;
23945 note that @samp{poly(0, x)} returns the empty vector @expr{[]}.
23946 Note also that @expr{x} may actually be any formula; for example,
23947 @samp{poly(sin(x)^2 - sin(x) + 3, sin(x))} returns @expr{[3, -1, 1]}.
23949 @cindex Coefficients of polynomial
23950 @cindex Degree of polynomial
23951 To get the @expr{x^k} coefficient of polynomial @expr{p}, use
23952 @samp{poly(p, x)_(k+1)}. To get the degree of polynomial @expr{p},
23953 use @samp{vlen(poly(p, x)) - 1}. For example, @samp{poly((x+1)^4, x)}
23954 returns @samp{[1, 4, 6, 4, 1]}, so @samp{poly((x+1)^4, x)_(2+1)}
23955 gives the @expr{x^2} coefficient of this polynomial, 6.
23961 One important feature of the solver is its ability to recognize
23962 formulas which are ``essentially'' polynomials. This ability is
23963 made available to the user through the @code{gpoly} function, which
23964 is used just like @code{poly}: @samp{gpoly(@var{expr}, @var{var})}.
23965 If @var{expr} is a polynomial in some term which includes @var{var}, then
23966 this function will return a vector @samp{[@var{x}, @var{c}, @var{a}]}
23967 where @var{x} is the term that depends on @var{var}, @var{c} is a
23968 vector of polynomial coefficients (like the one returned by @code{poly}),
23969 and @var{a} is a multiplier which is usually 1. Basically,
23970 @samp{@var{expr} = @var{a}*(@var{c}_1 + @var{c}_2 @var{x} +
23971 @var{c}_3 @var{x}^2 + ...)}. The last element of @var{c} is
23972 guaranteed to be non-zero, and @var{c} will not equal @samp{[1]}
23973 (i.e., the trivial decomposition @var{expr} = @var{x} is not
23974 considered a polynomial). One side effect is that @samp{gpoly(x, x)}
23975 and @samp{gpoly(6, x)}, both of which might be expected to recognize
23976 their arguments as polynomials, will not because the decomposition
23977 is considered trivial.
23979 For example, @samp{gpoly((x-2)^2, x)} returns @samp{[x, [4, -4, 1], 1]},
23980 since the expanded form of this polynomial is @expr{4 - 4 x + x^2}.
23982 The term @var{x} may itself be a polynomial in @var{var}. This is
23983 done to reduce the size of the @var{c} vector. For example,
23984 @samp{gpoly(x^4 + x^2 - 1, x)} returns @samp{[x^2, [-1, 1, 1], 1]},
23985 since a quadratic polynomial in @expr{x^2} is easier to solve than
23986 a quartic polynomial in @expr{x}.
23988 A few more examples of the kinds of polynomials @code{gpoly} can
23992 sin(x) - 1 [sin(x), [-1, 1], 1]
23993 x + 1/x - 1 [x, [1, -1, 1], 1/x]
23994 x + 1/x [x^2, [1, 1], 1/x]
23995 x^3 + 2 x [x^2, [2, 1], x]
23996 x + x^2:3 + sqrt(x) [x^1:6, [1, 1, 0, 1], x^1:2]
23997 x^(2a) + 2 x^a + 5 [x^a, [5, 2, 1], 1]
23998 (exp(-x) + exp(x)) / 2 [e^(2 x), [0.5, 0.5], e^-x]
24001 The @code{poly} and @code{gpoly} functions accept a third integer argument
24002 which specifies the largest degree of polynomial that is acceptable.
24003 If this is @expr{n}, then only @var{c} vectors of length @expr{n+1}
24004 or less will be returned. Otherwise, the @code{poly} or @code{gpoly}
24005 call will remain in symbolic form. For example, the equation solver
24006 can handle quartics and smaller polynomials, so it calls
24007 @samp{gpoly(@var{expr}, @var{var}, 4)} to discover whether @var{expr}
24008 can be treated by its linear, quadratic, cubic, or quartic formulas.
24014 The @code{pdeg} function computes the degree of a polynomial;
24015 @samp{pdeg(p,x)} is the highest power of @code{x} that appears in
24016 @code{p}. This is the same as @samp{vlen(poly(p,x))-1}, but is
24017 much more efficient. If @code{p} is constant with respect to @code{x},
24018 then @samp{pdeg(p,x) = 0}. If @code{p} is not a polynomial in @code{x}
24019 (e.g., @samp{pdeg(2 cos(x), x)}, the function remains unevaluated.
24020 It is possible to omit the second argument @code{x}, in which case
24021 @samp{pdeg(p)} returns the highest total degree of any term of the
24022 polynomial, counting all variables that appear in @code{p}. Note
24023 that @code{pdeg(c) = pdeg(c,x) = 0} for any nonzero constant @code{c};
24024 the degree of the constant zero is considered to be @code{-inf}
24031 The @code{plead} function finds the leading term of a polynomial.
24032 Thus @samp{plead(p,x)} is equivalent to @samp{poly(p,x)_vlen(poly(p,x))},
24033 though again more efficient. In particular, @samp{plead((2x+1)^10, x)}
24034 returns 1024 without expanding out the list of coefficients. The
24035 value of @code{plead(p,x)} will be zero only if @expr{p = 0}.
24041 The @code{pcont} function finds the @dfn{content} of a polynomial. This
24042 is the greatest common divisor of all the coefficients of the polynomial.
24043 With two arguments, @code{pcont(p,x)} effectively uses @samp{poly(p,x)}
24044 to get a list of coefficients, then uses @code{pgcd} (the polynomial
24045 GCD function) to combine these into an answer. For example,
24046 @samp{pcont(4 x y^2 + 6 x^2 y, x)} is @samp{2 y}. The content is
24047 basically the ``biggest'' polynomial that can be divided into @code{p}
24048 exactly. The sign of the content is the same as the sign of the leading
24051 With only one argument, @samp{pcont(p)} computes the numerical
24052 content of the polynomial, i.e., the @code{gcd} of the numerical
24053 coefficients of all the terms in the formula. Note that @code{gcd}
24054 is defined on rational numbers as well as integers; it computes
24055 the @code{gcd} of the numerators and the @code{lcm} of the
24056 denominators. Thus @samp{pcont(4:3 x y^2 + 6 x^2 y)} returns 2:3.
24057 Dividing the polynomial by this number will clear all the
24058 denominators, as well as dividing by any common content in the
24059 numerators. The numerical content of a polynomial is negative only
24060 if all the coefficients in the polynomial are negative.
24066 The @code{pprim} function finds the @dfn{primitive part} of a
24067 polynomial, which is simply the polynomial divided (using @code{pdiv}
24068 if necessary) by its content. If the input polynomial has rational
24069 coefficients, the result will have integer coefficients in simplest
24072 @node Numerical Solutions, Curve Fitting, Solving Equations, Algebra
24073 @section Numerical Solutions
24076 Not all equations can be solved symbolically. The commands in this
24077 section use numerical algorithms that can find a solution to a specific
24078 instance of an equation to any desired accuracy. Note that the
24079 numerical commands are slower than their algebraic cousins; it is a
24080 good idea to try @kbd{a S} before resorting to these commands.
24082 (@xref{Curve Fitting}, for some other, more specialized, operations
24083 on numerical data.)
24088 * Numerical Systems of Equations::
24091 @node Root Finding, Minimization, Numerical Solutions, Numerical Solutions
24092 @subsection Root Finding
24096 @pindex calc-find-root
24098 @cindex Newton's method
24099 @cindex Roots of equations
24100 @cindex Numerical root-finding
24101 The @kbd{a R} (@code{calc-find-root}) [@code{root}] command finds a
24102 numerical solution (or @dfn{root}) of an equation. (This command treats
24103 inequalities the same as equations. If the input is any other kind
24104 of formula, it is interpreted as an equation of the form @expr{X = 0}.)
24106 The @kbd{a R} command requires an initial guess on the top of the
24107 stack, and a formula in the second-to-top position. It prompts for a
24108 solution variable, which must appear in the formula. All other variables
24109 that appear in the formula must have assigned values, i.e., when
24110 a value is assigned to the solution variable and the formula is
24111 evaluated with @kbd{=}, it should evaluate to a number. Any assigned
24112 value for the solution variable itself is ignored and unaffected by
24115 When the command completes, the initial guess is replaced on the stack
24116 by a vector of two numbers: The value of the solution variable that
24117 solves the equation, and the difference between the lefthand and
24118 righthand sides of the equation at that value. Ordinarily, the second
24119 number will be zero or very nearly zero. (Note that Calc uses a
24120 slightly higher precision while finding the root, and thus the second
24121 number may be slightly different from the value you would compute from
24122 the equation yourself.)
24124 The @kbd{v h} (@code{calc-head}) command is a handy way to extract
24125 the first element of the result vector, discarding the error term.
24127 The initial guess can be a real number, in which case Calc searches
24128 for a real solution near that number, or a complex number, in which
24129 case Calc searches the whole complex plane near that number for a
24130 solution, or it can be an interval form which restricts the search
24131 to real numbers inside that interval.
24133 Calc tries to use @kbd{a d} to take the derivative of the equation.
24134 If this succeeds, it uses Newton's method. If the equation is not
24135 differentiable Calc uses a bisection method. (If Newton's method
24136 appears to be going astray, Calc switches over to bisection if it
24137 can, or otherwise gives up. In this case it may help to try again
24138 with a slightly different initial guess.) If the initial guess is a
24139 complex number, the function must be differentiable.
24141 If the formula (or the difference between the sides of an equation)
24142 is negative at one end of the interval you specify and positive at
24143 the other end, the root finder is guaranteed to find a root.
24144 Otherwise, Calc subdivides the interval into small parts looking for
24145 positive and negative values to bracket the root. When your guess is
24146 an interval, Calc will not look outside that interval for a root.
24150 The @kbd{H a R} [@code{wroot}] command is similar to @kbd{a R}, except
24151 that if the initial guess is an interval for which the function has
24152 the same sign at both ends, then rather than subdividing the interval
24153 Calc attempts to widen it to enclose a root. Use this mode if
24154 you are not sure if the function has a root in your interval.
24156 If the function is not differentiable, and you give a simple number
24157 instead of an interval as your initial guess, Calc uses this widening
24158 process even if you did not type the Hyperbolic flag. (If the function
24159 @emph{is} differentiable, Calc uses Newton's method which does not
24160 require a bounding interval in order to work.)
24162 If Calc leaves the @code{root} or @code{wroot} function in symbolic
24163 form on the stack, it will normally display an explanation for why
24164 no root was found. If you miss this explanation, press @kbd{w}
24165 (@code{calc-why}) to get it back.
24167 @node Minimization, Numerical Systems of Equations, Root Finding, Numerical Solutions
24168 @subsection Minimization
24175 @pindex calc-find-minimum
24176 @pindex calc-find-maximum
24179 @cindex Minimization, numerical
24180 The @kbd{a N} (@code{calc-find-minimum}) [@code{minimize}] command
24181 finds a minimum value for a formula. It is very similar in operation
24182 to @kbd{a R} (@code{calc-find-root}): You give the formula and an initial
24183 guess on the stack, and are prompted for the name of a variable. The guess
24184 may be either a number near the desired minimum, or an interval enclosing
24185 the desired minimum. The function returns a vector containing the
24186 value of the variable which minimizes the formula's value, along
24187 with the minimum value itself.
24189 Note that this command looks for a @emph{local} minimum. Many functions
24190 have more than one minimum; some, like
24191 @texline @math{x \sin x},
24192 @infoline @expr{x sin(x)},
24193 have infinitely many. In fact, there is no easy way to define the
24194 ``global'' minimum of
24195 @texline @math{x \sin x}
24196 @infoline @expr{x sin(x)}
24197 but Calc can still locate any particular local minimum
24198 for you. Calc basically goes downhill from the initial guess until it
24199 finds a point at which the function's value is greater both to the left
24200 and to the right. Calc does not use derivatives when minimizing a function.
24202 If your initial guess is an interval and it looks like the minimum
24203 occurs at one or the other endpoint of the interval, Calc will return
24204 that endpoint only if that endpoint is closed; thus, minimizing @expr{17 x}
24205 over @expr{[2..3]} will return @expr{[2, 38]}, but minimizing over
24206 @expr{(2..3]} would report no minimum found. In general, you should
24207 use closed intervals to find literally the minimum value in that
24208 range of @expr{x}, or open intervals to find the local minimum, if
24209 any, that happens to lie in that range.
24211 Most functions are smooth and flat near their minimum values. Because
24212 of this flatness, if the current precision is, say, 12 digits, the
24213 variable can only be determined meaningfully to about six digits. Thus
24214 you should set the precision to twice as many digits as you need in your
24225 The @kbd{H a N} [@code{wminimize}] command, analogously to @kbd{H a R},
24226 expands the guess interval to enclose a minimum rather than requiring
24227 that the minimum lie inside the interval you supply.
24229 The @kbd{a X} (@code{calc-find-maximum}) [@code{maximize}] and
24230 @kbd{H a X} [@code{wmaximize}] commands effectively minimize the
24231 negative of the formula you supply.
24233 The formula must evaluate to a real number at all points inside the
24234 interval (or near the initial guess if the guess is a number). If
24235 the initial guess is a complex number the variable will be minimized
24236 over the complex numbers; if it is real or an interval it will
24237 be minimized over the reals.
24239 @node Numerical Systems of Equations, , Minimization, Numerical Solutions
24240 @subsection Systems of Equations
24243 @cindex Systems of equations, numerical
24244 The @kbd{a R} command can also solve systems of equations. In this
24245 case, the equation should instead be a vector of equations, the
24246 guess should instead be a vector of numbers (intervals are not
24247 supported), and the variable should be a vector of variables. You
24248 can omit the brackets while entering the list of variables. Each
24249 equation must be differentiable by each variable for this mode to
24250 work. The result will be a vector of two vectors: The variable
24251 values that solved the system of equations, and the differences
24252 between the sides of the equations with those variable values.
24253 There must be the same number of equations as variables. Since
24254 only plain numbers are allowed as guesses, the Hyperbolic flag has
24255 no effect when solving a system of equations.
24257 It is also possible to minimize over many variables with @kbd{a N}
24258 (or maximize with @kbd{a X}). Once again the variable name should
24259 be replaced by a vector of variables, and the initial guess should
24260 be an equal-sized vector of initial guesses. But, unlike the case of
24261 multidimensional @kbd{a R}, the formula being minimized should
24262 still be a single formula, @emph{not} a vector. Beware that
24263 multidimensional minimization is currently @emph{very} slow.
24265 @node Curve Fitting, Summations, Numerical Solutions, Algebra
24266 @section Curve Fitting
24269 The @kbd{a F} command fits a set of data to a @dfn{model formula},
24270 such as @expr{y = m x + b} where @expr{m} and @expr{b} are parameters
24271 to be determined. For a typical set of measured data there will be
24272 no single @expr{m} and @expr{b} that exactly fit the data; in this
24273 case, Calc chooses values of the parameters that provide the closest
24274 possible fit. The model formula can be entered in various ways after
24275 the key sequence @kbd{a F} is pressed.
24277 If the letter @kbd{P} is pressed after @kbd{a F} but before the model
24278 description is entered, the data as well as the model formula will be
24279 plotted after the formula is determined. This will be indicated by a
24280 ``P'' in the minibuffer after the help message.
24284 * Polynomial and Multilinear Fits::
24285 * Error Estimates for Fits::
24286 * Standard Nonlinear Models::
24287 * Curve Fitting Details::
24291 @node Linear Fits, Polynomial and Multilinear Fits, Curve Fitting, Curve Fitting
24292 @subsection Linear Fits
24296 @pindex calc-curve-fit
24298 @cindex Linear regression
24299 @cindex Least-squares fits
24300 The @kbd{a F} (@code{calc-curve-fit}) [@code{fit}] command attempts
24301 to fit a set of data (@expr{x} and @expr{y} vectors of numbers) to a
24302 straight line, polynomial, or other function of @expr{x}. For the
24303 moment we will consider only the case of fitting to a line, and we
24304 will ignore the issue of whether or not the model was in fact a good
24307 In a standard linear least-squares fit, we have a set of @expr{(x,y)}
24308 data points that we wish to fit to the model @expr{y = m x + b}
24309 by adjusting the parameters @expr{m} and @expr{b} to make the @expr{y}
24310 values calculated from the formula be as close as possible to the actual
24311 @expr{y} values in the data set. (In a polynomial fit, the model is
24312 instead, say, @expr{y = a x^3 + b x^2 + c x + d}. In a multilinear fit,
24313 we have data points of the form @expr{(x_1,x_2,x_3,y)} and our model is
24314 @expr{y = a x_1 + b x_2 + c x_3 + d}. These will be discussed later.)
24316 In the model formula, variables like @expr{x} and @expr{x_2} are called
24317 the @dfn{independent variables}, and @expr{y} is the @dfn{dependent
24318 variable}. Variables like @expr{m}, @expr{a}, and @expr{b} are called
24319 the @dfn{parameters} of the model.
24321 The @kbd{a F} command takes the data set to be fitted from the stack.
24322 By default, it expects the data in the form of a matrix. For example,
24323 for a linear or polynomial fit, this would be a
24324 @texline @math{2\times N}
24326 matrix where the first row is a list of @expr{x} values and the second
24327 row has the corresponding @expr{y} values. For the multilinear fit
24328 shown above, the matrix would have four rows (@expr{x_1}, @expr{x_2},
24329 @expr{x_3}, and @expr{y}, respectively).
24331 If you happen to have an
24332 @texline @math{N\times2}
24334 matrix instead of a
24335 @texline @math{2\times N}
24337 matrix, just press @kbd{v t} first to transpose the matrix.
24339 After you type @kbd{a F}, Calc prompts you to select a model. For a
24340 linear fit, press the digit @kbd{1}.
24342 Calc then prompts for you to name the variables. By default it chooses
24343 high letters like @expr{x} and @expr{y} for independent variables and
24344 low letters like @expr{a} and @expr{b} for parameters. (The dependent
24345 variable doesn't need a name.) The two kinds of variables are separated
24346 by a semicolon. Since you generally care more about the names of the
24347 independent variables than of the parameters, Calc also allows you to
24348 name only those and let the parameters use default names.
24350 For example, suppose the data matrix
24355 [ [ 1, 2, 3, 4, 5 ]
24356 [ 5, 7, 9, 11, 13 ] ]
24362 $$ \pmatrix{ 1 & 2 & 3 & 4 & 5 \cr
24363 5 & 7 & 9 & 11 & 13 }
24369 is on the stack and we wish to do a simple linear fit. Type
24370 @kbd{a F}, then @kbd{1} for the model, then @key{RET} to use
24371 the default names. The result will be the formula @expr{3. + 2. x}
24372 on the stack. Calc has created the model expression @kbd{a + b x},
24373 then found the optimal values of @expr{a} and @expr{b} to fit the
24374 data. (In this case, it was able to find an exact fit.) Calc then
24375 substituted those values for @expr{a} and @expr{b} in the model
24378 The @kbd{a F} command puts two entries in the trail. One is, as
24379 always, a copy of the result that went to the stack; the other is
24380 a vector of the actual parameter values, written as equations:
24381 @expr{[a = 3, b = 2]}, in case you'd rather read them in a list
24382 than pick them out of the formula. (You can type @kbd{t y}
24383 to move this vector to the stack; see @ref{Trail Commands}.
24385 Specifying a different independent variable name will affect the
24386 resulting formula: @kbd{a F 1 k @key{RET}} produces @kbd{3 + 2 k}.
24387 Changing the parameter names (say, @kbd{a F 1 k;b,m @key{RET}}) will affect
24388 the equations that go into the trail.
24394 To see what happens when the fit is not exact, we could change
24395 the number 13 in the data matrix to 14 and try the fit again.
24402 Evaluating this formula, say with @kbd{v x 5 @key{RET} @key{TAB} V M $ @key{RET}}, shows
24403 a reasonably close match to the y-values in the data.
24406 [4.8, 7., 9.2, 11.4, 13.6]
24409 Since there is no line which passes through all the @var{n} data points,
24410 Calc has chosen a line that best approximates the data points using
24411 the method of least squares. The idea is to define the @dfn{chi-square}
24416 chi^2 = sum((y_i - (a + b x_i))^2, i, 1, N)
24421 $$ \chi^2 = \sum_{i=1}^N (y_i - (a + b x_i))^2 $$
24426 which is clearly zero if @expr{a + b x} exactly fits all data points,
24427 and increases as various @expr{a + b x_i} values fail to match the
24428 corresponding @expr{y_i} values. There are several reasons why the
24429 summand is squared, one of them being to ensure that
24430 @texline @math{\chi^2 \ge 0}.
24431 @infoline @expr{chi^2 >= 0}.
24432 Least-squares fitting simply chooses the values of @expr{a} and @expr{b}
24433 for which the error
24434 @texline @math{\chi^2}
24435 @infoline @expr{chi^2}
24436 is as small as possible.
24438 Other kinds of models do the same thing but with a different model
24439 formula in place of @expr{a + b x_i}.
24445 A numeric prefix argument causes the @kbd{a F} command to take the
24446 data in some other form than one big matrix. A positive argument @var{n}
24447 will take @var{N} items from the stack, corresponding to the @var{n} rows
24448 of a data matrix. In the linear case, @var{n} must be 2 since there
24449 is always one independent variable and one dependent variable.
24451 A prefix of zero or plain @kbd{C-u} is a compromise; Calc takes two
24452 items from the stack, an @var{n}-row matrix of @expr{x} values, and a
24453 vector of @expr{y} values. If there is only one independent variable,
24454 the @expr{x} values can be either a one-row matrix or a plain vector,
24455 in which case the @kbd{C-u} prefix is the same as a @w{@kbd{C-u 2}} prefix.
24457 @node Polynomial and Multilinear Fits, Error Estimates for Fits, Linear Fits, Curve Fitting
24458 @subsection Polynomial and Multilinear Fits
24461 To fit the data to higher-order polynomials, just type one of the
24462 digits @kbd{2} through @kbd{9} when prompted for a model. For example,
24463 we could fit the original data matrix from the previous section
24464 (with 13, not 14) to a parabola instead of a line by typing
24465 @kbd{a F 2 @key{RET}}.
24468 2.00000000001 x - 1.5e-12 x^2 + 2.99999999999
24471 Note that since the constant and linear terms are enough to fit the
24472 data exactly, it's no surprise that Calc chose a tiny contribution
24473 for @expr{x^2}. (The fact that it's not exactly zero is due only
24474 to roundoff error. Since our data are exact integers, we could get
24475 an exact answer by typing @kbd{m f} first to get Fraction mode.
24476 Then the @expr{x^2} term would vanish altogether. Usually, though,
24477 the data being fitted will be approximate floats so Fraction mode
24480 Doing the @kbd{a F 2} fit on the data set with 14 instead of 13
24481 gives a much larger @expr{x^2} contribution, as Calc bends the
24482 line slightly to improve the fit.
24485 0.142857142855 x^2 + 1.34285714287 x + 3.59999999998
24488 An important result from the theory of polynomial fitting is that it
24489 is always possible to fit @var{n} data points exactly using a polynomial
24490 of degree @mathit{@var{n}-1}, sometimes called an @dfn{interpolating polynomial}.
24491 Using the modified (14) data matrix, a model number of 4 gives
24492 a polynomial that exactly matches all five data points:
24495 0.04167 x^4 - 0.4167 x^3 + 1.458 x^2 - 0.08333 x + 4.
24498 The actual coefficients we get with a precision of 12, like
24499 @expr{0.0416666663588}, clearly suffer from loss of precision.
24500 It is a good idea to increase the working precision to several
24501 digits beyond what you need when you do a fitting operation.
24502 Or, if your data are exact, use Fraction mode to get exact
24505 You can type @kbd{i} instead of a digit at the model prompt to fit
24506 the data exactly to a polynomial. This just counts the number of
24507 columns of the data matrix to choose the degree of the polynomial
24510 Fitting data ``exactly'' to high-degree polynomials is not always
24511 a good idea, though. High-degree polynomials have a tendency to
24512 wiggle uncontrollably in between the fitting data points. Also,
24513 if the exact-fit polynomial is going to be used to interpolate or
24514 extrapolate the data, it is numerically better to use the @kbd{a p}
24515 command described below. @xref{Interpolation}.
24521 Another generalization of the linear model is to assume the
24522 @expr{y} values are a sum of linear contributions from several
24523 @expr{x} values. This is a @dfn{multilinear} fit, and it is also
24524 selected by the @kbd{1} digit key. (Calc decides whether the fit
24525 is linear or multilinear by counting the rows in the data matrix.)
24527 Given the data matrix,
24531 [ [ 1, 2, 3, 4, 5 ]
24533 [ 14.5, 15, 18.5, 22.5, 24 ] ]
24538 the command @kbd{a F 1 @key{RET}} will call the first row @expr{x} and the
24539 second row @expr{y}, and will fit the values in the third row to the
24540 model @expr{a + b x + c y}.
24546 Calc can do multilinear fits with any number of independent variables
24547 (i.e., with any number of data rows).
24553 Yet another variation is @dfn{homogeneous} linear models, in which
24554 the constant term is known to be zero. In the linear case, this
24555 means the model formula is simply @expr{a x}; in the multilinear
24556 case, the model might be @expr{a x + b y + c z}; and in the polynomial
24557 case, the model could be @expr{a x + b x^2 + c x^3}. You can get
24558 a homogeneous linear or multilinear model by pressing the letter
24559 @kbd{h} followed by a regular model key, like @kbd{1} or @kbd{2}.
24560 This will be indicated by an ``h'' in the minibuffer after the help
24563 It is certainly possible to have other constrained linear models,
24564 like @expr{2.3 + a x} or @expr{a - 4 x}. While there is no single
24565 key to select models like these, a later section shows how to enter
24566 any desired model by hand. In the first case, for example, you
24567 would enter @kbd{a F ' 2.3 + a x}.
24569 Another class of models that will work but must be entered by hand
24570 are multinomial fits, e.g., @expr{a + b x + c y + d x^2 + e y^2 + f x y}.
24572 @node Error Estimates for Fits, Standard Nonlinear Models, Polynomial and Multilinear Fits, Curve Fitting
24573 @subsection Error Estimates for Fits
24578 With the Hyperbolic flag, @kbd{H a F} [@code{efit}] performs the same
24579 fitting operation as @kbd{a F}, but reports the coefficients as error
24580 forms instead of plain numbers. Fitting our two data matrices (first
24581 with 13, then with 14) to a line with @kbd{H a F} gives the results,
24585 2.6 +/- 0.382970843103 + 2.2 +/- 0.115470053838 x
24588 In the first case the estimated errors are zero because the linear
24589 fit is perfect. In the second case, the errors are nonzero but
24590 moderately small, because the data are still very close to linear.
24592 It is also possible for the @emph{input} to a fitting operation to
24593 contain error forms. The data values must either all include errors
24594 or all be plain numbers. Error forms can go anywhere but generally
24595 go on the numbers in the last row of the data matrix. If the last
24596 row contains error forms
24597 @texline `@var{y_i}@w{ @tfn{+/-} }@math{\sigma_i}',
24598 @infoline `@var{y_i}@w{ @tfn{+/-} }@var{sigma_i}',
24600 @texline @math{\chi^2}
24601 @infoline @expr{chi^2}
24606 chi^2 = sum(((y_i - (a + b x_i)) / sigma_i)^2, i, 1, N)
24611 $$ \chi^2 = \sum_{i=1}^N \left(y_i - (a + b x_i) \over \sigma_i\right)^2 $$
24616 so that data points with larger error estimates contribute less to
24617 the fitting operation.
24619 If there are error forms on other rows of the data matrix, all the
24620 errors for a given data point are combined; the square root of the
24621 sum of the squares of the errors forms the
24622 @texline @math{\sigma_i}
24623 @infoline @expr{sigma_i}
24624 used for the data point.
24626 Both @kbd{a F} and @kbd{H a F} can accept error forms in the input
24627 matrix, although if you are concerned about error analysis you will
24628 probably use @kbd{H a F} so that the output also contains error
24631 If the input contains error forms but all the
24632 @texline @math{\sigma_i}
24633 @infoline @expr{sigma_i}
24634 values are the same, it is easy to see that the resulting fitted model
24635 will be the same as if the input did not have error forms at all
24636 @texline (@math{\chi^2}
24637 @infoline (@expr{chi^2}
24638 is simply scaled uniformly by
24639 @texline @math{1 / \sigma^2},
24640 @infoline @expr{1 / sigma^2},
24641 which doesn't affect where it has a minimum). But there @emph{will} be
24642 a difference in the estimated errors of the coefficients reported by
24645 Consult any text on statistical modeling of data for a discussion
24646 of where these error estimates come from and how they should be
24655 With the Inverse flag, @kbd{I a F} [@code{xfit}] produces even more
24656 information. The result is a vector of six items:
24660 The model formula with error forms for its coefficients or
24661 parameters. This is the result that @kbd{H a F} would have
24665 A vector of ``raw'' parameter values for the model. These are the
24666 polynomial coefficients or other parameters as plain numbers, in the
24667 same order as the parameters appeared in the final prompt of the
24668 @kbd{I a F} command. For polynomials of degree @expr{d}, this vector
24669 will have length @expr{M = d+1} with the constant term first.
24672 The covariance matrix @expr{C} computed from the fit. This is
24673 an @var{m}x@var{m} symmetric matrix; the diagonal elements
24674 @texline @math{C_{jj}}
24675 @infoline @expr{C_j_j}
24677 @texline @math{\sigma_j^2}
24678 @infoline @expr{sigma_j^2}
24679 of the parameters. The other elements are covariances
24680 @texline @math{\sigma_{ij}^2}
24681 @infoline @expr{sigma_i_j^2}
24682 that describe the correlation between pairs of parameters. (A related
24683 set of numbers, the @dfn{linear correlation coefficients}
24684 @texline @math{r_{ij}},
24685 @infoline @expr{r_i_j},
24687 @texline @math{\sigma_{ij}^2 / \sigma_i \, \sigma_j}.)
24688 @infoline @expr{sigma_i_j^2 / sigma_i sigma_j}.)
24691 A vector of @expr{M} ``parameter filter'' functions whose
24692 meanings are described below. If no filters are necessary this
24693 will instead be an empty vector; this is always the case for the
24694 polynomial and multilinear fits described so far.
24698 @texline @math{\chi^2}
24699 @infoline @expr{chi^2}
24700 for the fit, calculated by the formulas shown above. This gives a
24701 measure of the quality of the fit; statisticians consider
24702 @texline @math{\chi^2 \approx N - M}
24703 @infoline @expr{chi^2 = N - M}
24704 to indicate a moderately good fit (where again @expr{N} is the number of
24705 data points and @expr{M} is the number of parameters).
24708 A measure of goodness of fit expressed as a probability @expr{Q}.
24709 This is computed from the @code{utpc} probability distribution
24711 @texline @math{\chi^2}
24712 @infoline @expr{chi^2}
24713 with @expr{N - M} degrees of freedom. A
24714 value of 0.5 implies a good fit; some texts recommend that often
24715 @expr{Q = 0.1} or even 0.001 can signify an acceptable fit. In
24717 @texline @math{\chi^2}
24718 @infoline @expr{chi^2}
24719 statistics assume the errors in your inputs
24720 follow a normal (Gaussian) distribution; if they don't, you may
24721 have to accept smaller values of @expr{Q}.
24723 The @expr{Q} value is computed only if the input included error
24724 estimates. Otherwise, Calc will report the symbol @code{nan}
24725 for @expr{Q}. The reason is that in this case the
24726 @texline @math{\chi^2}
24727 @infoline @expr{chi^2}
24728 value has effectively been used to estimate the original errors
24729 in the input, and thus there is no redundant information left
24730 over to use for a confidence test.
24733 @node Standard Nonlinear Models, Curve Fitting Details, Error Estimates for Fits, Curve Fitting
24734 @subsection Standard Nonlinear Models
24737 The @kbd{a F} command also accepts other kinds of models besides
24738 lines and polynomials. Some common models have quick single-key
24739 abbreviations; others must be entered by hand as algebraic formulas.
24741 Here is a complete list of the standard models recognized by @kbd{a F}:
24745 Linear or multilinear. @mathit{a + b x + c y + d z}.
24747 Polynomials. @mathit{a + b x + c x^2 + d x^3}.
24749 Exponential. @mathit{a} @tfn{exp}@mathit{(b x)} @tfn{exp}@mathit{(c y)}.
24751 Base-10 exponential. @mathit{a} @tfn{10^}@mathit{(b x)} @tfn{10^}@mathit{(c y)}.
24753 Exponential (alternate notation). @tfn{exp}@mathit{(a + b x + c y)}.
24755 Base-10 exponential (alternate). @tfn{10^}@mathit{(a + b x + c y)}.
24757 Logarithmic. @mathit{a + b} @tfn{ln}@mathit{(x) + c} @tfn{ln}@mathit{(y)}.
24759 Base-10 logarithmic. @mathit{a + b} @tfn{log10}@mathit{(x) + c} @tfn{log10}@mathit{(y)}.
24761 General exponential. @mathit{a b^x c^y}.
24763 Power law. @mathit{a x^b y^c}.
24765 Quadratic. @mathit{a + b (x-c)^2 + d (x-e)^2}.
24768 @texline @math{{a \over b \sqrt{2 \pi}} \exp\left( -{1 \over 2} \left( x - c \over b \right)^2 \right)}.
24769 @infoline @mathit{(a / b sqrt(2 pi)) exp(-0.5*((x-c)/b)^2)}.
24771 Logistic @emph{s} curve.
24772 @texline @math{a/(1+e^{b(x-c)})}.
24773 @infoline @mathit{a/(1 + exp(b (x - c)))}.
24775 Logistic bell curve.
24776 @texline @math{ae^{b(x-c)}/(1+e^{b(x-c)})^2}.
24777 @infoline @mathit{a exp(b (x - c))/(1 + exp(b (x - c)))^2}.
24779 Hubbert linearization.
24780 @texline @math{{y \over x} = a(1-x/b)}.
24781 @infoline @mathit{(y/x) = a (1 - x/b)}.
24784 All of these models are used in the usual way; just press the appropriate
24785 letter at the model prompt, and choose variable names if you wish. The
24786 result will be a formula as shown in the above table, with the best-fit
24787 values of the parameters substituted. (You may find it easier to read
24788 the parameter values from the vector that is placed in the trail.)
24790 All models except Gaussian, logistics, Hubbert and polynomials can
24791 generalize as shown to any number of independent variables. Also, all
24792 the built-in models except for the logistic and Hubbert curves have an
24793 additive or multiplicative parameter shown as @expr{a} in the above table
24794 which can be replaced by zero or one, as appropriate, by typing @kbd{h}
24795 before the model key.
24797 Note that many of these models are essentially equivalent, but express
24798 the parameters slightly differently. For example, @expr{a b^x} and
24799 the other two exponential models are all algebraic rearrangements of
24800 each other. Also, the ``quadratic'' model is just a degree-2 polynomial
24801 with the parameters expressed differently. Use whichever form best
24802 matches the problem.
24804 The HP-28/48 calculators support four different models for curve
24805 fitting, called @code{LIN}, @code{LOG}, @code{EXP}, and @code{PWR}.
24806 These correspond to Calc models @samp{a + b x}, @samp{a + b ln(x)},
24807 @samp{a exp(b x)}, and @samp{a x^b}, respectively. In each case,
24808 @expr{a} is what the HP-48 identifies as the ``intercept,'' and
24809 @expr{b} is what it calls the ``slope.''
24815 If the model you want doesn't appear on this list, press @kbd{'}
24816 (the apostrophe key) at the model prompt to enter any algebraic
24817 formula, such as @kbd{m x - b}, as the model. (Not all models
24818 will work, though---see the next section for details.)
24820 The model can also be an equation like @expr{y = m x + b}.
24821 In this case, Calc thinks of all the rows of the data matrix on
24822 equal terms; this model effectively has two parameters
24823 (@expr{m} and @expr{b}) and two independent variables (@expr{x}
24824 and @expr{y}), with no ``dependent'' variables. Model equations
24825 do not need to take this @expr{y =} form. For example, the
24826 implicit line equation @expr{a x + b y = 1} works fine as a
24829 When you enter a model, Calc makes an alphabetical list of all
24830 the variables that appear in the model. These are used for the
24831 default parameters, independent variables, and dependent variable
24832 (in that order). If you enter a plain formula (not an equation),
24833 Calc assumes the dependent variable does not appear in the formula
24834 and thus does not need a name.
24836 For example, if the model formula has the variables @expr{a,mu,sigma,t,x},
24837 and the data matrix has three rows (meaning two independent variables),
24838 Calc will use @expr{a,mu,sigma} as the default parameters, and the
24839 data rows will be named @expr{t} and @expr{x}, respectively. If you
24840 enter an equation instead of a plain formula, Calc will use @expr{a,mu}
24841 as the parameters, and @expr{sigma,t,x} as the three independent
24844 You can, of course, override these choices by entering something
24845 different at the prompt. If you leave some variables out of the list,
24846 those variables must have stored values and those stored values will
24847 be used as constants in the model. (Stored values for the parameters
24848 and independent variables are ignored by the @kbd{a F} command.)
24849 If you list only independent variables, all the remaining variables
24850 in the model formula will become parameters.
24852 If there are @kbd{$} signs in the model you type, they will stand
24853 for parameters and all other variables (in alphabetical order)
24854 will be independent. Use @kbd{$} for one parameter, @kbd{$$} for
24855 another, and so on. Thus @kbd{$ x + $$} is another way to describe
24858 If you type a @kbd{$} instead of @kbd{'} at the model prompt itself,
24859 Calc will take the model formula from the stack. (The data must then
24860 appear at the second stack level.) The same conventions are used to
24861 choose which variables in the formula are independent by default and
24862 which are parameters.
24864 Models taken from the stack can also be expressed as vectors of
24865 two or three elements, @expr{[@var{model}, @var{vars}]} or
24866 @expr{[@var{model}, @var{vars}, @var{params}]}. Each of @var{vars}
24867 and @var{params} may be either a variable or a vector of variables.
24868 (If @var{params} is omitted, all variables in @var{model} except
24869 those listed as @var{vars} are parameters.)
24871 When you enter a model manually with @kbd{'}, Calc puts a 3-vector
24872 describing the model in the trail so you can get it back if you wish.
24880 Finally, you can store a model in one of the Calc variables
24881 @code{Model1} or @code{Model2}, then use this model by typing
24882 @kbd{a F u} or @kbd{a F U} (respectively). The value stored in
24883 the variable can be any of the formats that @kbd{a F $} would
24884 accept for a model on the stack.
24890 Calc uses the principal values of inverse functions like @code{ln}
24891 and @code{arcsin} when doing fits. For example, when you enter
24892 the model @samp{y = sin(a t + b)} Calc actually uses the easier
24893 form @samp{arcsin(y) = a t + b}. The @code{arcsin} function always
24894 returns results in the range from @mathit{-90} to 90 degrees (or the
24895 equivalent range in radians). Suppose you had data that you
24896 believed to represent roughly three oscillations of a sine wave,
24897 so that the argument of the sine might go from zero to
24898 @texline @math{3\times360}
24899 @infoline @mathit{3*360}
24901 The above model would appear to be a good way to determine the
24902 true frequency and phase of the sine wave, but in practice it
24903 would fail utterly. The righthand side of the actual model
24904 @samp{arcsin(y) = a t + b} will grow smoothly with @expr{t}, but
24905 the lefthand side will bounce back and forth between @mathit{-90} and 90.
24906 No values of @expr{a} and @expr{b} can make the two sides match,
24907 even approximately.
24909 There is no good solution to this problem at present. You could
24910 restrict your data to small enough ranges so that the above problem
24911 doesn't occur (i.e., not straddling any peaks in the sine wave).
24912 Or, in this case, you could use a totally different method such as
24913 Fourier analysis, which is beyond the scope of the @kbd{a F} command.
24914 (Unfortunately, Calc does not currently have any facilities for
24915 taking Fourier and related transforms.)
24917 @node Curve Fitting Details, Interpolation, Standard Nonlinear Models, Curve Fitting
24918 @subsection Curve Fitting Details
24921 Calc's internal least-squares fitter can only handle multilinear
24922 models. More precisely, it can handle any model of the form
24923 @expr{a f(x,y,z) + b g(x,y,z) + c h(x,y,z)}, where @expr{a,b,c}
24924 are the parameters and @expr{x,y,z} are the independent variables
24925 (of course there can be any number of each, not just three).
24927 In a simple multilinear or polynomial fit, it is easy to see how
24928 to convert the model into this form. For example, if the model
24929 is @expr{a + b x + c x^2}, then @expr{f(x) = 1}, @expr{g(x) = x},
24930 and @expr{h(x) = x^2} are suitable functions.
24932 For most other models, Calc uses a variety of algebraic manipulations
24933 to try to put the problem into the form
24936 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)
24940 where @expr{Y,A,B,C,F,G,H} are arbitrary functions. It computes
24941 @expr{Y}, @expr{F}, @expr{G}, and @expr{H} for all the data points,
24942 does a standard linear fit to find the values of @expr{A}, @expr{B},
24943 and @expr{C}, then uses the equation solver to solve for @expr{a,b,c}
24944 in terms of @expr{A,B,C}.
24946 A remarkable number of models can be cast into this general form.
24947 We'll look at two examples here to see how it works. The power-law
24948 model @expr{y = a x^b} with two independent variables and two parameters
24949 can be rewritten as follows:
24954 y = exp(ln(a) + b ln(x))
24955 ln(y) = ln(a) + b ln(x)
24959 which matches the desired form with
24960 @texline @math{Y = \ln(y)},
24961 @infoline @expr{Y = ln(y)},
24962 @texline @math{A = \ln(a)},
24963 @infoline @expr{A = ln(a)},
24964 @expr{F = 1}, @expr{B = b}, and
24965 @texline @math{G = \ln(x)}.
24966 @infoline @expr{G = ln(x)}.
24967 Calc thus computes the logarithms of your @expr{y} and @expr{x} values,
24968 does a linear fit for @expr{A} and @expr{B}, then solves to get
24969 @texline @math{a = \exp(A)}
24970 @infoline @expr{a = exp(A)}
24973 Another interesting example is the ``quadratic'' model, which can
24974 be handled by expanding according to the distributive law.
24977 y = a + b*(x - c)^2
24978 y = a + b c^2 - 2 b c x + b x^2
24982 which matches with @expr{Y = y}, @expr{A = a + b c^2}, @expr{F = 1},
24983 @expr{B = -2 b c}, @expr{G = x} (the @mathit{-2} factor could just as easily
24984 have been put into @expr{G} instead of @expr{B}), @expr{C = b}, and
24987 The Gaussian model looks quite complicated, but a closer examination
24988 shows that it's actually similar to the quadratic model but with an
24989 exponential that can be brought to the top and moved into @expr{Y}.
24991 The logistic models cannot be put into general linear form. For these
24992 models, and the Hubbert linearization, Calc computes a rough
24993 approximation for the parameters, then uses the Levenberg-Marquardt
24994 iterative method to refine the approximations.
24996 Another model that cannot be put into general linear
24997 form is a Gaussian with a constant background added on, i.e.,
24998 @expr{d} + the regular Gaussian formula. If you have a model like
24999 this, your best bet is to replace enough of your parameters with
25000 constants to make the model linearizable, then adjust the constants
25001 manually by doing a series of fits. You can compare the fits by
25002 graphing them, by examining the goodness-of-fit measures returned by
25003 @kbd{I a F}, or by some other method suitable to your application.
25004 Note that some models can be linearized in several ways. The
25005 Gaussian-plus-@var{d} model can be linearized by setting @expr{d}
25006 (the background) to a constant, or by setting @expr{b} (the standard
25007 deviation) and @expr{c} (the mean) to constants.
25009 To fit a model with constants substituted for some parameters, just
25010 store suitable values in those parameter variables, then omit them
25011 from the list of parameters when you answer the variables prompt.
25017 A last desperate step would be to use the general-purpose
25018 @code{minimize} function rather than @code{fit}. After all, both
25019 functions solve the problem of minimizing an expression (the
25020 @texline @math{\chi^2}
25021 @infoline @expr{chi^2}
25022 sum) by adjusting certain parameters in the expression. The @kbd{a F}
25023 command is able to use a vastly more efficient algorithm due to its
25024 special knowledge about linear chi-square sums, but the @kbd{a N}
25025 command can do the same thing by brute force.
25027 A compromise would be to pick out a few parameters without which the
25028 fit is linearizable, and use @code{minimize} on a call to @code{fit}
25029 which efficiently takes care of the rest of the parameters. The thing
25030 to be minimized would be the value of
25031 @texline @math{\chi^2}
25032 @infoline @expr{chi^2}
25033 returned as the fifth result of the @code{xfit} function:
25036 minimize(xfit(gaus(a,b,c,d,x), x, [a,b,c], data)_5, d, guess)
25040 where @code{gaus} represents the Gaussian model with background,
25041 @code{data} represents the data matrix, and @code{guess} represents
25042 the initial guess for @expr{d} that @code{minimize} requires.
25043 This operation will only be, shall we say, extraordinarily slow
25044 rather than astronomically slow (as would be the case if @code{minimize}
25045 were used by itself to solve the problem).
25051 The @kbd{I a F} [@code{xfit}] command is somewhat trickier when
25052 nonlinear models are used. The second item in the result is the
25053 vector of ``raw'' parameters @expr{A}, @expr{B}, @expr{C}. The
25054 covariance matrix is written in terms of those raw parameters.
25055 The fifth item is a vector of @dfn{filter} expressions. This
25056 is the empty vector @samp{[]} if the raw parameters were the same
25057 as the requested parameters, i.e., if @expr{A = a}, @expr{B = b},
25058 and so on (which is always true if the model is already linear
25059 in the parameters as written, e.g., for polynomial fits). If the
25060 parameters had to be rearranged, the fifth item is instead a vector
25061 of one formula per parameter in the original model. The raw
25062 parameters are expressed in these ``filter'' formulas as
25063 @samp{fitdummy(1)} for @expr{A}, @samp{fitdummy(2)} for @expr{B},
25066 When Calc needs to modify the model to return the result, it replaces
25067 @samp{fitdummy(1)} in all the filters with the first item in the raw
25068 parameters list, and so on for the other raw parameters, then
25069 evaluates the resulting filter formulas to get the actual parameter
25070 values to be substituted into the original model. In the case of
25071 @kbd{H a F} and @kbd{I a F} where the parameters must be error forms,
25072 Calc uses the square roots of the diagonal entries of the covariance
25073 matrix as error values for the raw parameters, then lets Calc's
25074 standard error-form arithmetic take it from there.
25076 If you use @kbd{I a F} with a nonlinear model, be sure to remember
25077 that the covariance matrix is in terms of the raw parameters,
25078 @emph{not} the actual requested parameters. It's up to you to
25079 figure out how to interpret the covariances in the presence of
25080 nontrivial filter functions.
25082 Things are also complicated when the input contains error forms.
25083 Suppose there are three independent and dependent variables, @expr{x},
25084 @expr{y}, and @expr{z}, one or more of which are error forms in the
25085 data. Calc combines all the error values by taking the square root
25086 of the sum of the squares of the errors. It then changes @expr{x}
25087 and @expr{y} to be plain numbers, and makes @expr{z} into an error
25088 form with this combined error. The @expr{Y(x,y,z)} part of the
25089 linearized model is evaluated, and the result should be an error
25090 form. The error part of that result is used for
25091 @texline @math{\sigma_i}
25092 @infoline @expr{sigma_i}
25093 for the data point. If for some reason @expr{Y(x,y,z)} does not return
25094 an error form, the combined error from @expr{z} is used directly for
25095 @texline @math{\sigma_i}.
25096 @infoline @expr{sigma_i}.
25097 Finally, @expr{z} is also stripped of its error
25098 for use in computing @expr{F(x,y,z)}, @expr{G(x,y,z)} and so on;
25099 the righthand side of the linearized model is computed in regular
25100 arithmetic with no error forms.
25102 (While these rules may seem complicated, they are designed to do
25103 the most reasonable thing in the typical case that @expr{Y(x,y,z)}
25104 depends only on the dependent variable @expr{z}, and in fact is
25105 often simply equal to @expr{z}. For common cases like polynomials
25106 and multilinear models, the combined error is simply used as the
25107 @texline @math{\sigma}
25108 @infoline @expr{sigma}
25109 for the data point with no further ado.)
25116 It may be the case that the model you wish to use is linearizable,
25117 but Calc's built-in rules are unable to figure it out. Calc uses
25118 its algebraic rewrite mechanism to linearize a model. The rewrite
25119 rules are kept in the variable @code{FitRules}. You can edit this
25120 variable using the @kbd{s e FitRules} command; in fact, there is
25121 a special @kbd{s F} command just for editing @code{FitRules}.
25122 @xref{Operations on Variables}.
25124 @xref{Rewrite Rules}, for a discussion of rewrite rules.
25158 Calc uses @code{FitRules} as follows. First, it converts the model
25159 to an equation if necessary and encloses the model equation in a
25160 call to the function @code{fitmodel} (which is not actually a defined
25161 function in Calc; it is only used as a placeholder by the rewrite rules).
25162 Parameter variables are renamed to function calls @samp{fitparam(1)},
25163 @samp{fitparam(2)}, and so on, and independent variables are renamed
25164 to @samp{fitvar(1)}, @samp{fitvar(2)}, etc. The dependent variable
25165 is the highest-numbered @code{fitvar}. For example, the power law
25166 model @expr{a x^b} is converted to @expr{y = a x^b}, then to
25170 fitmodel(fitvar(2) = fitparam(1) fitvar(1)^fitparam(2))
25174 Calc then applies the rewrites as if by @samp{C-u 0 a r FitRules}.
25175 (The zero prefix means that rewriting should continue until no further
25176 changes are possible.)
25178 When rewriting is complete, the @code{fitmodel} call should have
25179 been replaced by a @code{fitsystem} call that looks like this:
25182 fitsystem(@var{Y}, @var{FGH}, @var{abc})
25186 where @var{Y} is a formula that describes the function @expr{Y(x,y,z)},
25187 @var{FGH} is the vector of formulas @expr{[F(x,y,z), G(x,y,z), H(x,y,z)]},
25188 and @var{abc} is the vector of parameter filters which refer to the
25189 raw parameters as @samp{fitdummy(1)} for @expr{A}, @samp{fitdummy(2)}
25190 for @expr{B}, etc. While the number of raw parameters (the length of
25191 the @var{FGH} vector) is usually the same as the number of original
25192 parameters (the length of the @var{abc} vector), this is not required.
25194 The power law model eventually boils down to
25198 fitsystem(ln(fitvar(2)),
25199 [1, ln(fitvar(1))],
25200 [exp(fitdummy(1)), fitdummy(2)])
25204 The actual implementation of @code{FitRules} is complicated; it
25205 proceeds in four phases. First, common rearrangements are done
25206 to try to bring linear terms together and to isolate functions like
25207 @code{exp} and @code{ln} either all the way ``out'' (so that they
25208 can be put into @var{Y}) or all the way ``in'' (so that they can
25209 be put into @var{abc} or @var{FGH}). In particular, all
25210 non-constant powers are converted to logs-and-exponentials form,
25211 and the distributive law is used to expand products of sums.
25212 Quotients are rewritten to use the @samp{fitinv} function, where
25213 @samp{fitinv(x)} represents @expr{1/x} while the @code{FitRules}
25214 are operating. (The use of @code{fitinv} makes recognition of
25215 linear-looking forms easier.) If you modify @code{FitRules}, you
25216 will probably only need to modify the rules for this phase.
25218 Phase two, whose rules can actually also apply during phases one
25219 and three, first rewrites @code{fitmodel} to a two-argument
25220 form @samp{fitmodel(@var{Y}, @var{model})}, where @var{Y} is
25221 initially zero and @var{model} has been changed from @expr{a=b}
25222 to @expr{a-b} form. It then tries to peel off invertible functions
25223 from the outside of @var{model} and put them into @var{Y} instead,
25224 calling the equation solver to invert the functions. Finally, when
25225 this is no longer possible, the @code{fitmodel} is changed to a
25226 four-argument @code{fitsystem}, where the fourth argument is
25227 @var{model} and the @var{FGH} and @var{abc} vectors are initially
25228 empty. (The last vector is really @var{ABC}, corresponding to
25229 raw parameters, for now.)
25231 Phase three converts a sum of items in the @var{model} to a sum
25232 of @samp{fitpart(@var{a}, @var{b}, @var{c})} terms which represent
25233 terms @samp{@var{a}*@var{b}*@var{c}} of the sum, where @var{a}
25234 is all factors that do not involve any variables, @var{b} is all
25235 factors that involve only parameters, and @var{c} is the factors
25236 that involve only independent variables. (If this decomposition
25237 is not possible, the rule set will not complete and Calc will
25238 complain that the model is too complex.) Then @code{fitpart}s
25239 with equal @var{b} or @var{c} components are merged back together
25240 using the distributive law in order to minimize the number of
25241 raw parameters needed.
25243 Phase four moves the @code{fitpart} terms into the @var{FGH} and
25244 @var{ABC} vectors. Also, some of the algebraic expansions that
25245 were done in phase 1 are undone now to make the formulas more
25246 computationally efficient. Finally, it calls the solver one more
25247 time to convert the @var{ABC} vector to an @var{abc} vector, and
25248 removes the fourth @var{model} argument (which by now will be zero)
25249 to obtain the three-argument @code{fitsystem} that the linear
25250 least-squares solver wants to see.
25256 @mindex hasfit@idots
25258 @tindex hasfitparams
25266 Two functions which are useful in connection with @code{FitRules}
25267 are @samp{hasfitparams(x)} and @samp{hasfitvars(x)}, which check
25268 whether @expr{x} refers to any parameters or independent variables,
25269 respectively. Specifically, these functions return ``true'' if the
25270 argument contains any @code{fitparam} (or @code{fitvar}) function
25271 calls, and ``false'' otherwise. (Recall that ``true'' means a
25272 nonzero number, and ``false'' means zero. The actual nonzero number
25273 returned is the largest @var{n} from all the @samp{fitparam(@var{n})}s
25274 or @samp{fitvar(@var{n})}s, respectively, that appear in the formula.)
25280 The @code{fit} function in algebraic notation normally takes four
25281 arguments, @samp{fit(@var{model}, @var{vars}, @var{params}, @var{data})},
25282 where @var{model} is the model formula as it would be typed after
25283 @kbd{a F '}, @var{vars} is the independent variable or a vector of
25284 independent variables, @var{params} likewise gives the parameter(s),
25285 and @var{data} is the data matrix. Note that the length of @var{vars}
25286 must be equal to the number of rows in @var{data} if @var{model} is
25287 an equation, or one less than the number of rows if @var{model} is
25288 a plain formula. (Actually, a name for the dependent variable is
25289 allowed but will be ignored in the plain-formula case.)
25291 If @var{params} is omitted, the parameters are all variables in
25292 @var{model} except those that appear in @var{vars}. If @var{vars}
25293 is also omitted, Calc sorts all the variables that appear in
25294 @var{model} alphabetically and uses the higher ones for @var{vars}
25295 and the lower ones for @var{params}.
25297 Alternatively, @samp{fit(@var{modelvec}, @var{data})} is allowed
25298 where @var{modelvec} is a 2- or 3-vector describing the model
25299 and variables, as discussed previously.
25301 If Calc is unable to do the fit, the @code{fit} function is left
25302 in symbolic form, ordinarily with an explanatory message. The
25303 message will be ``Model expression is too complex'' if the
25304 linearizer was unable to put the model into the required form.
25306 The @code{efit} (corresponding to @kbd{H a F}) and @code{xfit}
25307 (for @kbd{I a F}) functions are completely analogous.
25309 @node Interpolation, , Curve Fitting Details, Curve Fitting
25310 @subsection Polynomial Interpolation
25313 @pindex calc-poly-interp
25315 The @kbd{a p} (@code{calc-poly-interp}) [@code{polint}] command does
25316 a polynomial interpolation at a particular @expr{x} value. It takes
25317 two arguments from the stack: A data matrix of the sort used by
25318 @kbd{a F}, and a single number which represents the desired @expr{x}
25319 value. Calc effectively does an exact polynomial fit as if by @kbd{a F i},
25320 then substitutes the @expr{x} value into the result in order to get an
25321 approximate @expr{y} value based on the fit. (Calc does not actually
25322 use @kbd{a F i}, however; it uses a direct method which is both more
25323 efficient and more numerically stable.)
25325 The result of @kbd{a p} is actually a vector of two values: The @expr{y}
25326 value approximation, and an error measure @expr{dy} that reflects Calc's
25327 estimation of the probable error of the approximation at that value of
25328 @expr{x}. If the input @expr{x} is equal to any of the @expr{x} values
25329 in the data matrix, the output @expr{y} will be the corresponding @expr{y}
25330 value from the matrix, and the output @expr{dy} will be exactly zero.
25332 A prefix argument of 2 causes @kbd{a p} to take separate x- and
25333 y-vectors from the stack instead of one data matrix.
25335 If @expr{x} is a vector of numbers, @kbd{a p} will return a matrix of
25336 interpolated results for each of those @expr{x} values. (The matrix will
25337 have two columns, the @expr{y} values and the @expr{dy} values.)
25338 If @expr{x} is a formula instead of a number, the @code{polint} function
25339 remains in symbolic form; use the @kbd{a "} command to expand it out to
25340 a formula that describes the fit in symbolic terms.
25342 In all cases, the @kbd{a p} command leaves the data vectors or matrix
25343 on the stack. Only the @expr{x} value is replaced by the result.
25347 The @kbd{H a p} [@code{ratint}] command does a rational function
25348 interpolation. It is used exactly like @kbd{a p}, except that it
25349 uses as its model the quotient of two polynomials. If there are
25350 @expr{N} data points, the numerator and denominator polynomials will
25351 each have degree @expr{N/2} (if @expr{N} is odd, the denominator will
25352 have degree one higher than the numerator).
25354 Rational approximations have the advantage that they can accurately
25355 describe functions that have poles (points at which the function's value
25356 goes to infinity, so that the denominator polynomial of the approximation
25357 goes to zero). If @expr{x} corresponds to a pole of the fitted rational
25358 function, then the result will be a division by zero. If Infinite mode
25359 is enabled, the result will be @samp{[uinf, uinf]}.
25361 There is no way to get the actual coefficients of the rational function
25362 used by @kbd{H a p}. (The algorithm never generates these coefficients
25363 explicitly, and quotients of polynomials are beyond @w{@kbd{a F}}'s
25364 capabilities to fit.)
25366 @node Summations, Logical Operations, Curve Fitting, Algebra
25367 @section Summations
25370 @cindex Summation of a series
25372 @pindex calc-summation
25374 The @kbd{a +} (@code{calc-summation}) [@code{sum}] command computes
25375 the sum of a formula over a certain range of index values. The formula
25376 is taken from the top of the stack; the command prompts for the
25377 name of the summation index variable, the lower limit of the
25378 sum (any formula), and the upper limit of the sum. If you
25379 enter a blank line at any of these prompts, that prompt and
25380 any later ones are answered by reading additional elements from
25381 the stack. Thus, @kbd{' k^2 @key{RET} ' k @key{RET} 1 @key{RET} 5 @key{RET} a + @key{RET}}
25382 produces the result 55.
25384 $$ \sum_{k=1}^5 k^2 = 55 $$
25387 The choice of index variable is arbitrary, but it's best not to
25388 use a variable with a stored value. In particular, while
25389 @code{i} is often a favorite index variable, it should be avoided
25390 in Calc because @code{i} has the imaginary constant @expr{(0, 1)}
25391 as a value. If you pressed @kbd{=} on a sum over @code{i}, it would
25392 be changed to a nonsensical sum over the ``variable'' @expr{(0, 1)}!
25393 If you really want to use @code{i} as an index variable, use
25394 @w{@kbd{s u i @key{RET}}} first to ``unstore'' this variable.
25395 (@xref{Storing Variables}.)
25397 A numeric prefix argument steps the index by that amount rather
25398 than by one. Thus @kbd{' a_k @key{RET} C-u -2 a + k @key{RET} 10 @key{RET} 0 @key{RET}}
25399 yields @samp{a_10 + a_8 + a_6 + a_4 + a_2 + a_0}. A prefix
25400 argument of plain @kbd{C-u} causes @kbd{a +} to prompt for the
25401 step value, in which case you can enter any formula or enter
25402 a blank line to take the step value from the stack. With the
25403 @kbd{C-u} prefix, @kbd{a +} can take up to five arguments from
25404 the stack: The formula, the variable, the lower limit, the
25405 upper limit, and (at the top of the stack), the step value.
25407 Calc knows how to do certain sums in closed form. For example,
25408 @samp{sum(6 k^2, k, 1, n) = @w{2 n^3} + 3 n^2 + n}. In particular,
25409 this is possible if the formula being summed is polynomial or
25410 exponential in the index variable. Sums of logarithms are
25411 transformed into logarithms of products. Sums of trigonometric
25412 and hyperbolic functions are transformed to sums of exponentials
25413 and then done in closed form. Also, of course, sums in which the
25414 lower and upper limits are both numbers can always be evaluated
25415 just by grinding them out, although Calc will use closed forms
25416 whenever it can for the sake of efficiency.
25418 The notation for sums in algebraic formulas is
25419 @samp{sum(@var{expr}, @var{var}, @var{low}, @var{high}, @var{step})}.
25420 If @var{step} is omitted, it defaults to one. If @var{high} is
25421 omitted, @var{low} is actually the upper limit and the lower limit
25422 is one. If @var{low} is also omitted, the limits are @samp{-inf}
25423 and @samp{inf}, respectively.
25425 Infinite sums can sometimes be evaluated: @samp{sum(.5^k, k, 1, inf)}
25426 returns @expr{1}. This is done by evaluating the sum in closed
25427 form (to @samp{1. - 0.5^n} in this case), then evaluating this
25428 formula with @code{n} set to @code{inf}. Calc's usual rules
25429 for ``infinite'' arithmetic can find the answer from there. If
25430 infinite arithmetic yields a @samp{nan}, or if the sum cannot be
25431 solved in closed form, Calc leaves the @code{sum} function in
25432 symbolic form. @xref{Infinities}.
25434 As a special feature, if the limits are infinite (or omitted, as
25435 described above) but the formula includes vectors subscripted by
25436 expressions that involve the iteration variable, Calc narrows
25437 the limits to include only the range of integers which result in
25438 valid subscripts for the vector. For example, the sum
25439 @samp{sum(k [a,b,c,d,e,f,g]_(2k),k)} evaluates to @samp{b + 2 d + 3 f}.
25441 The limits of a sum do not need to be integers. For example,
25442 @samp{sum(a_k, k, 0, 2 n, n)} produces @samp{a_0 + a_n + a_(2 n)}.
25443 Calc computes the number of iterations using the formula
25444 @samp{1 + (@var{high} - @var{low}) / @var{step}}, which must,
25445 after simplification as if by @kbd{a s}, evaluate to an integer.
25447 If the number of iterations according to the above formula does
25448 not come out to an integer, the sum is invalid and will be left
25449 in symbolic form. However, closed forms are still supplied, and
25450 you are on your honor not to misuse the resulting formulas by
25451 substituting mismatched bounds into them. For example,
25452 @samp{sum(k, k, 1, 10, 2)} is invalid, but Calc will go ahead and
25453 evaluate the closed form solution for the limits 1 and 10 to get
25454 the rather dubious answer, 29.25.
25456 If the lower limit is greater than the upper limit (assuming a
25457 positive step size), the result is generally zero. However,
25458 Calc only guarantees a zero result when the upper limit is
25459 exactly one step less than the lower limit, i.e., if the number
25460 of iterations is @mathit{-1}. Thus @samp{sum(f(k), k, n, n-1)} is zero
25461 but the sum from @samp{n} to @samp{n-2} may report a nonzero value
25462 if Calc used a closed form solution.
25464 Calc's logical predicates like @expr{a < b} return 1 for ``true''
25465 and 0 for ``false.'' @xref{Logical Operations}. This can be
25466 used to advantage for building conditional sums. For example,
25467 @samp{sum(prime(k)*k^2, k, 1, 20)} is the sum of the squares of all
25468 prime numbers from 1 to 20; the @code{prime} predicate returns 1 if
25469 its argument is prime and 0 otherwise. You can read this expression
25470 as ``the sum of @expr{k^2}, where @expr{k} is prime.'' Indeed,
25471 @samp{sum(prime(k)*k^2, k)} would represent the sum of @emph{all} primes
25472 squared, since the limits default to plus and minus infinity, but
25473 there are no such sums that Calc's built-in rules can do in
25476 As another example, @samp{sum((k != k_0) * f(k), k, 1, n)} is the
25477 sum of @expr{f(k)} for all @expr{k} from 1 to @expr{n}, excluding
25478 one value @expr{k_0}. Slightly more tricky is the summand
25479 @samp{(k != k_0) / (k - k_0)}, which is an attempt to describe
25480 the sum of all @expr{1/(k-k_0)} except at @expr{k = k_0}, where
25481 this would be a division by zero. But at @expr{k = k_0}, this
25482 formula works out to the indeterminate form @expr{0 / 0}, which
25483 Calc will not assume is zero. Better would be to use
25484 @samp{(k != k_0) ? 1/(k-k_0) : 0}; the @samp{? :} operator does
25485 an ``if-then-else'' test: This expression says, ``if
25486 @texline @math{k \ne k_0},
25487 @infoline @expr{k != k_0},
25488 then @expr{1/(k-k_0)}, else zero.'' Now the formula @expr{1/(k-k_0)}
25489 will not even be evaluated by Calc when @expr{k = k_0}.
25491 @cindex Alternating sums
25493 @pindex calc-alt-summation
25495 The @kbd{a -} (@code{calc-alt-summation}) [@code{asum}] command
25496 computes an alternating sum. Successive terms of the sequence
25497 are given alternating signs, with the first term (corresponding
25498 to the lower index value) being positive. Alternating sums
25499 are converted to normal sums with an extra term of the form
25500 @samp{(-1)^(k-@var{low})}. This formula is adjusted appropriately
25501 if the step value is other than one. For example, the Taylor
25502 series for the sine function is @samp{asum(x^k / k!, k, 1, inf, 2)}.
25503 (Calc cannot evaluate this infinite series, but it can approximate
25504 it if you replace @code{inf} with any particular odd number.)
25505 Calc converts this series to a regular sum with a step of one,
25506 namely @samp{sum((-1)^k x^(2k+1) / (2k+1)!, k, 0, inf)}.
25508 @cindex Product of a sequence
25510 @pindex calc-product
25512 The @kbd{a *} (@code{calc-product}) [@code{prod}] command is
25513 the analogous way to take a product of many terms. Calc also knows
25514 some closed forms for products, such as @samp{prod(k, k, 1, n) = n!}.
25515 Conditional products can be written @samp{prod(k^prime(k), k, 1, n)}
25516 or @samp{prod(prime(k) ? k : 1, k, 1, n)}.
25519 @pindex calc-tabulate
25521 The @kbd{a T} (@code{calc-tabulate}) [@code{table}] command
25522 evaluates a formula at a series of iterated index values, just
25523 like @code{sum} and @code{prod}, but its result is simply a
25524 vector of the results. For example, @samp{table(a_i, i, 1, 7, 2)}
25525 produces @samp{[a_1, a_3, a_5, a_7]}.
25527 @node Logical Operations, Rewrite Rules, Summations, Algebra
25528 @section Logical Operations
25531 The following commands and algebraic functions return true/false values,
25532 where 1 represents ``true'' and 0 represents ``false.'' In cases where
25533 a truth value is required (such as for the condition part of a rewrite
25534 rule, or as the condition for a @w{@kbd{Z [ Z ]}} control structure), any
25535 nonzero value is accepted to mean ``true.'' (Specifically, anything
25536 for which @code{dnonzero} returns 1 is ``true,'' and anything for
25537 which @code{dnonzero} returns 0 or cannot decide is assumed ``false.''
25538 Note that this means that @w{@kbd{Z [ Z ]}} will execute the ``then''
25539 portion if its condition is provably true, but it will execute the
25540 ``else'' portion for any condition like @expr{a = b} that is not
25541 provably true, even if it might be true. Algebraic functions that
25542 have conditions as arguments, like @code{? :} and @code{&&}, remain
25543 unevaluated if the condition is neither provably true nor provably
25544 false. @xref{Declarations}.)
25547 @pindex calc-equal-to
25551 The @kbd{a =} (@code{calc-equal-to}) command, or @samp{eq(a,b)} function
25552 (which can also be written @samp{a = b} or @samp{a == b} in an algebraic
25553 formula) is true if @expr{a} and @expr{b} are equal, either because they
25554 are identical expressions, or because they are numbers which are
25555 numerically equal. (Thus the integer 1 is considered equal to the float
25556 1.0.) If the equality of @expr{a} and @expr{b} cannot be determined,
25557 the comparison is left in symbolic form. Note that as a command, this
25558 operation pops two values from the stack and pushes back either a 1 or
25559 a 0, or a formula @samp{a = b} if the values' equality cannot be determined.
25561 Many Calc commands use @samp{=} formulas to represent @dfn{equations}.
25562 For example, the @kbd{a S} (@code{calc-solve-for}) command rearranges
25563 an equation to solve for a given variable. The @kbd{a M}
25564 (@code{calc-map-equation}) command can be used to apply any
25565 function to both sides of an equation; for example, @kbd{2 a M *}
25566 multiplies both sides of the equation by two. Note that just
25567 @kbd{2 *} would not do the same thing; it would produce the formula
25568 @samp{2 (a = b)} which represents 2 if the equality is true or
25571 The @code{eq} function with more than two arguments (e.g., @kbd{C-u 3 a =}
25572 or @samp{a = b = c}) tests if all of its arguments are equal. In
25573 algebraic notation, the @samp{=} operator is unusual in that it is
25574 neither left- nor right-associative: @samp{a = b = c} is not the
25575 same as @samp{(a = b) = c} or @samp{a = (b = c)} (which each compare
25576 one variable with the 1 or 0 that results from comparing two other
25580 @pindex calc-not-equal-to
25583 The @kbd{a #} (@code{calc-not-equal-to}) command, or @samp{neq(a,b)} or
25584 @samp{a != b} function, is true if @expr{a} and @expr{b} are not equal.
25585 This also works with more than two arguments; @samp{a != b != c != d}
25586 tests that all four of @expr{a}, @expr{b}, @expr{c}, and @expr{d} are
25603 @pindex calc-less-than
25604 @pindex calc-greater-than
25605 @pindex calc-less-equal
25606 @pindex calc-greater-equal
25635 The @kbd{a <} (@code{calc-less-than}) [@samp{lt(a,b)} or @samp{a < b}]
25636 operation is true if @expr{a} is less than @expr{b}. Similar functions
25637 are @kbd{a >} (@code{calc-greater-than}) [@samp{gt(a,b)} or @samp{a > b}],
25638 @kbd{a [} (@code{calc-less-equal}) [@samp{leq(a,b)} or @samp{a <= b}], and
25639 @kbd{a ]} (@code{calc-greater-equal}) [@samp{geq(a,b)} or @samp{a >= b}].
25641 While the inequality functions like @code{lt} do not accept more
25642 than two arguments, the syntax @w{@samp{a <= b < c}} is translated to an
25643 equivalent expression involving intervals: @samp{b in [a .. c)}.
25644 (See the description of @code{in} below.) All four combinations
25645 of @samp{<} and @samp{<=} are allowed, or any of the four combinations
25646 of @samp{>} and @samp{>=}. Four-argument constructions like
25647 @samp{a < b < c < d}, and mixtures like @w{@samp{a < b = c}} that
25648 involve both equalities and inequalities, are not allowed.
25651 @pindex calc-remove-equal
25653 The @kbd{a .} (@code{calc-remove-equal}) [@code{rmeq}] command extracts
25654 the righthand side of the equation or inequality on the top of the
25655 stack. It also works elementwise on vectors. For example, if
25656 @samp{[x = 2.34, y = z / 2]} is on the stack, then @kbd{a .} produces
25657 @samp{[2.34, z / 2]}. As a special case, if the righthand side is a
25658 variable and the lefthand side is a number (as in @samp{2.34 = x}), then
25659 Calc keeps the lefthand side instead. Finally, this command works with
25660 assignments @samp{x := 2.34} as well as equations, always taking the
25661 righthand side, and for @samp{=>} (evaluates-to) operators, always
25662 taking the lefthand side.
25665 @pindex calc-logical-and
25668 The @kbd{a &} (@code{calc-logical-and}) [@samp{land(a,b)} or @samp{a && b}]
25669 function is true if both of its arguments are true, i.e., are
25670 non-zero numbers. In this case, the result will be either @expr{a} or
25671 @expr{b}, chosen arbitrarily. If either argument is zero, the result is
25672 zero. Otherwise, the formula is left in symbolic form.
25675 @pindex calc-logical-or
25678 The @kbd{a |} (@code{calc-logical-or}) [@samp{lor(a,b)} or @samp{a || b}]
25679 function is true if either or both of its arguments are true (nonzero).
25680 The result is whichever argument was nonzero, choosing arbitrarily if both
25681 are nonzero. If both @expr{a} and @expr{b} are zero, the result is
25685 @pindex calc-logical-not
25688 The @kbd{a !} (@code{calc-logical-not}) [@samp{lnot(a)} or @samp{!@: a}]
25689 function is true if @expr{a} is false (zero), or false if @expr{a} is
25690 true (nonzero). It is left in symbolic form if @expr{a} is not a
25694 @pindex calc-logical-if
25704 @cindex Arguments, not evaluated
25705 The @kbd{a :} (@code{calc-logical-if}) [@samp{if(a,b,c)} or @samp{a ? b :@: c}]
25706 function is equal to either @expr{b} or @expr{c} if @expr{a} is a nonzero
25707 number or zero, respectively. If @expr{a} is not a number, the test is
25708 left in symbolic form and neither @expr{b} nor @expr{c} is evaluated in
25709 any way. In algebraic formulas, this is one of the few Calc functions
25710 whose arguments are not automatically evaluated when the function itself
25711 is evaluated. The others are @code{lambda}, @code{quote}, and
25714 One minor surprise to watch out for is that the formula @samp{a?3:4}
25715 will not work because the @samp{3:4} is parsed as a fraction instead of
25716 as three separate symbols. Type something like @samp{a ? 3 : 4} or
25717 @samp{a?(3):4} instead.
25719 As a special case, if @expr{a} evaluates to a vector, then both @expr{b}
25720 and @expr{c} are evaluated; the result is a vector of the same length
25721 as @expr{a} whose elements are chosen from corresponding elements of
25722 @expr{b} and @expr{c} according to whether each element of @expr{a}
25723 is zero or nonzero. Each of @expr{b} and @expr{c} must be either a
25724 vector of the same length as @expr{a}, or a non-vector which is matched
25725 with all elements of @expr{a}.
25728 @pindex calc-in-set
25730 The @kbd{a @{} (@code{calc-in-set}) [@samp{in(a,b)}] function is true if
25731 the number @expr{a} is in the set of numbers represented by @expr{b}.
25732 If @expr{b} is an interval form, @expr{a} must be one of the values
25733 encompassed by the interval. If @expr{b} is a vector, @expr{a} must be
25734 equal to one of the elements of the vector. (If any vector elements are
25735 intervals, @expr{a} must be in any of the intervals.) If @expr{b} is a
25736 plain number, @expr{a} must be numerically equal to @expr{b}.
25737 @xref{Set Operations}, for a group of commands that manipulate sets
25744 The @samp{typeof(a)} function produces an integer or variable which
25745 characterizes @expr{a}. If @expr{a} is a number, vector, or variable,
25746 the result will be one of the following numbers:
25751 3 Floating-point number
25753 5 Rectangular complex number
25754 6 Polar complex number
25760 12 Infinity (inf, uinf, or nan)
25762 101 Vector (but not a matrix)
25766 Otherwise, @expr{a} is a formula, and the result is a variable which
25767 represents the name of the top-level function call.
25781 The @samp{integer(a)} function returns true if @expr{a} is an integer.
25782 The @samp{real(a)} function
25783 is true if @expr{a} is a real number, either integer, fraction, or
25784 float. The @samp{constant(a)} function returns true if @expr{a} is
25785 any of the objects for which @code{typeof} would produce an integer
25786 code result except for variables, and provided that the components of
25787 an object like a vector or error form are themselves constant.
25788 Note that infinities do not satisfy any of these tests, nor do
25789 special constants like @code{pi} and @code{e}.
25791 @xref{Declarations}, for a set of similar functions that recognize
25792 formulas as well as actual numbers. For example, @samp{dint(floor(x))}
25793 is true because @samp{floor(x)} is provably integer-valued, but
25794 @samp{integer(floor(x))} does not because @samp{floor(x)} is not
25795 literally an integer constant.
25801 The @samp{refers(a,b)} function is true if the variable (or sub-expression)
25802 @expr{b} appears in @expr{a}, or false otherwise. Unlike the other
25803 tests described here, this function returns a definite ``no'' answer
25804 even if its arguments are still in symbolic form. The only case where
25805 @code{refers} will be left unevaluated is if @expr{a} is a plain
25806 variable (different from @expr{b}).
25812 The @samp{negative(a)} function returns true if @expr{a} ``looks'' negative,
25813 because it is a negative number, because it is of the form @expr{-x},
25814 or because it is a product or quotient with a term that looks negative.
25815 This is most useful in rewrite rules. Beware that @samp{negative(a)}
25816 evaluates to 1 or 0 for @emph{any} argument @expr{a}, so it can only
25817 be stored in a formula if the default simplifications are turned off
25818 first with @kbd{m O} (or if it appears in an unevaluated context such
25819 as a rewrite rule condition).
25825 The @samp{variable(a)} function is true if @expr{a} is a variable,
25826 or false if not. If @expr{a} is a function call, this test is left
25827 in symbolic form. Built-in variables like @code{pi} and @code{inf}
25828 are considered variables like any others by this test.
25834 The @samp{nonvar(a)} function is true if @expr{a} is a non-variable.
25835 If its argument is a variable it is left unsimplified; it never
25836 actually returns zero. However, since Calc's condition-testing
25837 commands consider ``false'' anything not provably true, this is
25856 @cindex Linearity testing
25857 The functions @code{lin}, @code{linnt}, @code{islin}, and @code{islinnt}
25858 check if an expression is ``linear,'' i.e., can be written in the form
25859 @expr{a + b x} for some constants @expr{a} and @expr{b}, and some
25860 variable or subformula @expr{x}. The function @samp{islin(f,x)} checks
25861 if formula @expr{f} is linear in @expr{x}, returning 1 if so. For
25862 example, @samp{islin(x,x)}, @samp{islin(-x,x)}, @samp{islin(3,x)}, and
25863 @samp{islin(x y / 3 - 2, x)} all return 1. The @samp{lin(f,x)} function
25864 is similar, except that instead of returning 1 it returns the vector
25865 @expr{[a, b, x]}. For the above examples, this vector would be
25866 @expr{[0, 1, x]}, @expr{[0, -1, x]}, @expr{[3, 0, x]}, and
25867 @expr{[-2, y/3, x]}, respectively. Both @code{lin} and @code{islin}
25868 generally remain unevaluated for expressions which are not linear,
25869 e.g., @samp{lin(2 x^2, x)} and @samp{lin(sin(x), x)}. The second
25870 argument can also be a formula; @samp{islin(2 + 3 sin(x), sin(x))}
25873 The @code{linnt} and @code{islinnt} functions perform a similar check,
25874 but require a ``non-trivial'' linear form, which means that the
25875 @expr{b} coefficient must be non-zero. For example, @samp{lin(2,x)}
25876 returns @expr{[2, 0, x]} and @samp{lin(y,x)} returns @expr{[y, 0, x]},
25877 but @samp{linnt(2,x)} and @samp{linnt(y,x)} are left unevaluated
25878 (in other words, these formulas are considered to be only ``trivially''
25879 linear in @expr{x}).
25881 All four linearity-testing functions allow you to omit the second
25882 argument, in which case the input may be linear in any non-constant
25883 formula. Here, the @expr{a=0}, @expr{b=1} case is also considered
25884 trivial, and only constant values for @expr{a} and @expr{b} are
25885 recognized. Thus, @samp{lin(2 x y)} returns @expr{[0, 2, x y]},
25886 @samp{lin(2 - x y)} returns @expr{[2, -1, x y]}, and @samp{lin(x y)}
25887 returns @expr{[0, 1, x y]}. The @code{linnt} function would allow the
25888 first two cases but not the third. Also, neither @code{lin} nor
25889 @code{linnt} accept plain constants as linear in the one-argument
25890 case: @samp{islin(2,x)} is true, but @samp{islin(2)} is false.
25896 The @samp{istrue(a)} function returns 1 if @expr{a} is a nonzero
25897 number or provably nonzero formula, or 0 if @expr{a} is anything else.
25898 Calls to @code{istrue} can only be manipulated if @kbd{m O} mode is
25899 used to make sure they are not evaluated prematurely. (Note that
25900 declarations are used when deciding whether a formula is true;
25901 @code{istrue} returns 1 when @code{dnonzero} would return 1, and
25902 it returns 0 when @code{dnonzero} would return 0 or leave itself
25905 @node Rewrite Rules, , Logical Operations, Algebra
25906 @section Rewrite Rules
25909 @cindex Rewrite rules
25910 @cindex Transformations
25911 @cindex Pattern matching
25913 @pindex calc-rewrite
25915 The @kbd{a r} (@code{calc-rewrite}) [@code{rewrite}] command makes
25916 substitutions in a formula according to a specified pattern or patterns
25917 known as @dfn{rewrite rules}. Whereas @kbd{a b} (@code{calc-substitute})
25918 matches literally, so that substituting @samp{sin(x)} with @samp{cos(x)}
25919 matches only the @code{sin} function applied to the variable @code{x},
25920 rewrite rules match general kinds of formulas; rewriting using the rule
25921 @samp{sin(x) := cos(x)} matches @code{sin} of any argument and replaces
25922 it with @code{cos} of that same argument. The only significance of the
25923 name @code{x} is that the same name is used on both sides of the rule.
25925 Rewrite rules rearrange formulas already in Calc's memory.
25926 @xref{Syntax Tables}, to read about @dfn{syntax rules}, which are
25927 similar to algebraic rewrite rules but operate when new algebraic
25928 entries are being parsed, converting strings of characters into
25932 * Entering Rewrite Rules::
25933 * Basic Rewrite Rules::
25934 * Conditional Rewrite Rules::
25935 * Algebraic Properties of Rewrite Rules::
25936 * Other Features of Rewrite Rules::
25937 * Composing Patterns in Rewrite Rules::
25938 * Nested Formulas with Rewrite Rules::
25939 * Multi-Phase Rewrite Rules::
25940 * Selections with Rewrite Rules::
25941 * Matching Commands::
25942 * Automatic Rewrites::
25943 * Debugging Rewrites::
25944 * Examples of Rewrite Rules::
25947 @node Entering Rewrite Rules, Basic Rewrite Rules, Rewrite Rules, Rewrite Rules
25948 @subsection Entering Rewrite Rules
25951 Rewrite rules normally use the ``assignment'' operator
25952 @samp{@var{old} := @var{new}}.
25953 This operator is equivalent to the function call @samp{assign(old, new)}.
25954 The @code{assign} function is undefined by itself in Calc, so an
25955 assignment formula such as a rewrite rule will be left alone by ordinary
25956 Calc commands. But certain commands, like the rewrite system, interpret
25957 assignments in special ways.
25959 For example, the rule @samp{sin(x)^2 := 1-cos(x)^2} says to replace
25960 every occurrence of the sine of something, squared, with one minus the
25961 square of the cosine of that same thing. All by itself as a formula
25962 on the stack it does nothing, but when given to the @kbd{a r} command
25963 it turns that command into a sine-squared-to-cosine-squared converter.
25965 To specify a set of rules to be applied all at once, make a vector of
25968 When @kbd{a r} prompts you to enter the rewrite rules, you can answer
25973 With a rule: @kbd{f(x) := g(x) @key{RET}}.
25975 With a vector of rules: @kbd{[f1(x) := g1(x), f2(x) := g2(x)] @key{RET}}.
25976 (You can omit the enclosing square brackets if you wish.)
25978 With the name of a variable that contains the rule or rules vector:
25979 @kbd{myrules @key{RET}}.
25981 With any formula except a rule, a vector, or a variable name; this
25982 will be interpreted as the @var{old} half of a rewrite rule,
25983 and you will be prompted a second time for the @var{new} half:
25984 @kbd{f(x) @key{RET} g(x) @key{RET}}.
25986 With a blank line, in which case the rule, rules vector, or variable
25987 will be taken from the top of the stack (and the formula to be
25988 rewritten will come from the second-to-top position).
25991 If you enter the rules directly (as opposed to using rules stored
25992 in a variable), those rules will be put into the Trail so that you
25993 can retrieve them later. @xref{Trail Commands}.
25995 It is most convenient to store rules you use often in a variable and
25996 invoke them by giving the variable name. The @kbd{s e}
25997 (@code{calc-edit-variable}) command is an easy way to create or edit a
25998 rule set stored in a variable. You may also wish to use @kbd{s p}
25999 (@code{calc-permanent-variable}) to save your rules permanently;
26000 @pxref{Operations on Variables}.
26002 Rewrite rules are compiled into a special internal form for faster
26003 matching. If you enter a rule set directly it must be recompiled
26004 every time. If you store the rules in a variable and refer to them
26005 through that variable, they will be compiled once and saved away
26006 along with the variable for later reference. This is another good
26007 reason to store your rules in a variable.
26009 Calc also accepts an obsolete notation for rules, as vectors
26010 @samp{[@var{old}, @var{new}]}. But because it is easily confused with a
26011 vector of two rules, the use of this notation is no longer recommended.
26013 @node Basic Rewrite Rules, Conditional Rewrite Rules, Entering Rewrite Rules, Rewrite Rules
26014 @subsection Basic Rewrite Rules
26017 To match a particular formula @expr{x} with a particular rewrite rule
26018 @samp{@var{old} := @var{new}}, Calc compares the structure of @expr{x} with
26019 the structure of @var{old}. Variables that appear in @var{old} are
26020 treated as @dfn{meta-variables}; the corresponding positions in @expr{x}
26021 may contain any sub-formulas. For example, the pattern @samp{f(x,y)}
26022 would match the expression @samp{f(12, a+1)} with the meta-variable
26023 @samp{x} corresponding to 12 and with @samp{y} corresponding to
26024 @samp{a+1}. However, this pattern would not match @samp{f(12)} or
26025 @samp{g(12, a+1)}, since there is no assignment of the meta-variables
26026 that will make the pattern match these expressions. Notice that if
26027 the pattern is a single meta-variable, it will match any expression.
26029 If a given meta-variable appears more than once in @var{old}, the
26030 corresponding sub-formulas of @expr{x} must be identical. Thus
26031 the pattern @samp{f(x,x)} would match @samp{f(12, 12)} and
26032 @samp{f(a+1, a+1)} but not @samp{f(12, a+1)} or @samp{f(a+b, b+a)}.
26033 (@xref{Conditional Rewrite Rules}, for a way to match the latter.)
26035 Things other than variables must match exactly between the pattern
26036 and the target formula. To match a particular variable exactly, use
26037 the pseudo-function @samp{quote(v)} in the pattern. For example, the
26038 pattern @samp{x+quote(y)} matches @samp{x+y}, @samp{2+y}, or
26041 The special variable names @samp{e}, @samp{pi}, @samp{i}, @samp{phi},
26042 @samp{gamma}, @samp{inf}, @samp{uinf}, and @samp{nan} always match
26043 literally. Thus the pattern @samp{sin(d + e + f)} acts exactly like
26044 @samp{sin(d + quote(e) + f)}.
26046 If the @var{old} pattern is found to match a given formula, that
26047 formula is replaced by @var{new}, where any occurrences in @var{new}
26048 of meta-variables from the pattern are replaced with the sub-formulas
26049 that they matched. Thus, applying the rule @samp{f(x,y) := g(y+x,x)}
26050 to @samp{f(12, a+1)} would produce @samp{g(a+13, 12)}.
26052 The normal @kbd{a r} command applies rewrite rules over and over
26053 throughout the target formula until no further changes are possible
26054 (up to a limit of 100 times). Use @kbd{C-u 1 a r} to make only one
26057 @node Conditional Rewrite Rules, Algebraic Properties of Rewrite Rules, Basic Rewrite Rules, Rewrite Rules
26058 @subsection Conditional Rewrite Rules
26061 A rewrite rule can also be @dfn{conditional}, written in the form
26062 @samp{@var{old} := @var{new} :: @var{cond}}. (There is also the obsolete
26063 form @samp{[@var{old}, @var{new}, @var{cond}]}.) If a @var{cond} part
26065 rule, this is an additional condition that must be satisfied before
26066 the rule is accepted. Once @var{old} has been successfully matched
26067 to the target expression, @var{cond} is evaluated (with all the
26068 meta-variables substituted for the values they matched) and simplified
26069 with @kbd{a s} (@code{calc-simplify}). If the result is a nonzero
26070 number or any other object known to be nonzero (@pxref{Declarations}),
26071 the rule is accepted. If the result is zero or if it is a symbolic
26072 formula that is not known to be nonzero, the rule is rejected.
26073 @xref{Logical Operations}, for a number of functions that return
26074 1 or 0 according to the results of various tests.
26076 For example, the formula @samp{n > 0} simplifies to 1 or 0 if @expr{n}
26077 is replaced by a positive or nonpositive number, respectively (or if
26078 @expr{n} has been declared to be positive or nonpositive). Thus,
26079 the rule @samp{f(x,y) := g(y+x,x) :: x+y > 0} would apply to
26080 @samp{f(0, 4)} but not to @samp{f(-3, 2)} or @samp{f(12, a+1)}
26081 (assuming no outstanding declarations for @expr{a}). In the case of
26082 @samp{f(-3, 2)}, the condition can be shown not to be satisfied; in
26083 the case of @samp{f(12, a+1)}, the condition merely cannot be shown
26084 to be satisfied, but that is enough to reject the rule.
26086 While Calc will use declarations to reason about variables in the
26087 formula being rewritten, declarations do not apply to meta-variables.
26088 For example, the rule @samp{f(a) := g(a+1)} will match for any values
26089 of @samp{a}, such as complex numbers, vectors, or formulas, even if
26090 @samp{a} has been declared to be real or scalar. If you want the
26091 meta-variable @samp{a} to match only literal real numbers, use
26092 @samp{f(a) := g(a+1) :: real(a)}. If you want @samp{a} to match only
26093 reals and formulas which are provably real, use @samp{dreal(a)} as
26096 The @samp{::} operator is a shorthand for the @code{condition}
26097 function; @samp{@var{old} := @var{new} :: @var{cond}} is equivalent to
26098 the formula @samp{condition(assign(@var{old}, @var{new}), @var{cond})}.
26100 If you have several conditions, you can use @samp{... :: c1 :: c2 :: c3}
26101 or @samp{... :: c1 && c2 && c3}. The two are entirely equivalent.
26103 It is also possible to embed conditions inside the pattern:
26104 @samp{f(x :: x>0, y) := g(y+x, x)}. This is purely a notational
26105 convenience, though; where a condition appears in a rule has no
26106 effect on when it is tested. The rewrite-rule compiler automatically
26107 decides when it is best to test each condition while a rule is being
26110 Certain conditions are handled as special cases by the rewrite rule
26111 system and are tested very efficiently: Where @expr{x} is any
26112 meta-variable, these conditions are @samp{integer(x)}, @samp{real(x)},
26113 @samp{constant(x)}, @samp{negative(x)}, @samp{x >= y} where @expr{y}
26114 is either a constant or another meta-variable and @samp{>=} may be
26115 replaced by any of the six relational operators, and @samp{x % a = b}
26116 where @expr{a} and @expr{b} are constants. Other conditions, like
26117 @samp{x >= y+1} or @samp{dreal(x)}, will be less efficient to check
26118 since Calc must bring the whole evaluator and simplifier into play.
26120 An interesting property of @samp{::} is that neither of its arguments
26121 will be touched by Calc's default simplifications. This is important
26122 because conditions often are expressions that cannot safely be
26123 evaluated early. For example, the @code{typeof} function never
26124 remains in symbolic form; entering @samp{typeof(a)} will put the
26125 number 100 (the type code for variables like @samp{a}) on the stack.
26126 But putting the condition @samp{... :: typeof(a) = 6} on the stack
26127 is safe since @samp{::} prevents the @code{typeof} from being
26128 evaluated until the condition is actually used by the rewrite system.
26130 Since @samp{::} protects its lefthand side, too, you can use a dummy
26131 condition to protect a rule that must itself not evaluate early.
26132 For example, it's not safe to put @samp{a(f,x) := apply(f, [x])} on
26133 the stack because it will immediately evaluate to @samp{a(f,x) := f(x)},
26134 where the meta-variable-ness of @code{f} on the righthand side has been
26135 lost. But @samp{a(f,x) := apply(f, [x]) :: 1} is safe, and of course
26136 the condition @samp{1} is always true (nonzero) so it has no effect on
26137 the functioning of the rule. (The rewrite compiler will ensure that
26138 it doesn't even impact the speed of matching the rule.)
26140 @node Algebraic Properties of Rewrite Rules, Other Features of Rewrite Rules, Conditional Rewrite Rules, Rewrite Rules
26141 @subsection Algebraic Properties of Rewrite Rules
26144 The rewrite mechanism understands the algebraic properties of functions
26145 like @samp{+} and @samp{*}. In particular, pattern matching takes
26146 the associativity and commutativity of the following functions into
26150 + - * = != && || and or xor vint vunion vxor gcd lcm max min beta
26153 For example, the rewrite rule:
26156 a x + b x := (a + b) x
26160 will match formulas of the form,
26163 a x + b x, x a + x b, a x + x b, x a + b x
26166 Rewrites also understand the relationship between the @samp{+} and @samp{-}
26167 operators. The above rewrite rule will also match the formulas,
26170 a x - b x, x a - x b, a x - x b, x a - b x
26174 by matching @samp{b} in the pattern to @samp{-b} from the formula.
26176 Applied to a sum of many terms like @samp{r + a x + s + b x + t}, this
26177 pattern will check all pairs of terms for possible matches. The rewrite
26178 will take whichever suitable pair it discovers first.
26180 In general, a pattern using an associative operator like @samp{a + b}
26181 will try @var{2 n} different ways to match a sum of @var{n} terms
26182 like @samp{x + y + z - w}. First, @samp{a} is matched against each
26183 of @samp{x}, @samp{y}, @samp{z}, and @samp{-w} in turn, with @samp{b}
26184 being matched to the remainders @samp{y + z - w}, @samp{x + z - w}, etc.
26185 If none of these succeed, then @samp{b} is matched against each of the
26186 four terms with @samp{a} matching the remainder. Half-and-half matches,
26187 like @samp{(x + y) + (z - w)}, are not tried.
26189 Note that @samp{*} is not commutative when applied to matrices, but
26190 rewrite rules pretend that it is. If you type @kbd{m v} to enable
26191 Matrix mode (@pxref{Matrix Mode}), rewrite rules will match @samp{*}
26192 literally, ignoring its usual commutativity property. (In the
26193 current implementation, the associativity also vanishes---it is as
26194 if the pattern had been enclosed in a @code{plain} marker; see below.)
26195 If you are applying rewrites to formulas with matrices, it's best to
26196 enable Matrix mode first to prevent algebraically incorrect rewrites
26199 The pattern @samp{-x} will actually match any expression. For example,
26207 will rewrite @samp{f(a)} to @samp{-f(-a)}. To avoid this, either use
26208 a @code{plain} marker as described below, or add a @samp{negative(x)}
26209 condition. The @code{negative} function is true if its argument
26210 ``looks'' negative, for example, because it is a negative number or
26211 because it is a formula like @samp{-x}. The new rule using this
26215 f(x) := -f(-x) :: negative(x) @r{or, equivalently,}
26216 f(-x) := -f(x) :: negative(-x)
26219 In the same way, the pattern @samp{x - y} will match the sum @samp{a + b}
26220 by matching @samp{y} to @samp{-b}.
26222 The pattern @samp{a b} will also match the formula @samp{x/y} if
26223 @samp{y} is a number. Thus the rule @samp{a x + @w{b x} := (a+b) x}
26224 will also convert @samp{a x + x / 2} to @samp{(a + 0.5) x} (or
26225 @samp{(a + 1:2) x}, depending on the current fraction mode).
26227 Calc will @emph{not} take other liberties with @samp{*}, @samp{/}, and
26228 @samp{^}. For example, the pattern @samp{f(a b)} will not match
26229 @samp{f(x^2)}, and @samp{f(a + b)} will not match @samp{f(2 x)}, even
26230 though conceivably these patterns could match with @samp{a = b = x}.
26231 Nor will @samp{f(a b)} match @samp{f(x / y)} if @samp{y} is not a
26232 constant, even though it could be considered to match with @samp{a = x}
26233 and @samp{b = 1/y}. The reasons are partly for efficiency, and partly
26234 because while few mathematical operations are substantively different
26235 for addition and subtraction, often it is preferable to treat the cases
26236 of multiplication, division, and integer powers separately.
26238 Even more subtle is the rule set
26241 [ f(a) + f(b) := f(a + b), -f(a) := f(-a) ]
26245 attempting to match @samp{f(x) - f(y)}. You might think that Calc
26246 will view this subtraction as @samp{f(x) + (-f(y))} and then apply
26247 the above two rules in turn, but actually this will not work because
26248 Calc only does this when considering rules for @samp{+} (like the
26249 first rule in this set). So it will see first that @samp{f(x) + (-f(y))}
26250 does not match @samp{f(a) + f(b)} for any assignments of the
26251 meta-variables, and then it will see that @samp{f(x) - f(y)} does
26252 not match @samp{-f(a)} for any assignment of @samp{a}. Because Calc
26253 tries only one rule at a time, it will not be able to rewrite
26254 @samp{f(x) - f(y)} with this rule set. An explicit @samp{f(a) - f(b)}
26255 rule will have to be added.
26257 Another thing patterns will @emph{not} do is break up complex numbers.
26258 The pattern @samp{myconj(a + @w{b i)} := a - b i} will work for formulas
26259 involving the special constant @samp{i} (such as @samp{3 - 4 i}), but
26260 it will not match actual complex numbers like @samp{(3, -4)}. A version
26261 of the above rule for complex numbers would be
26264 myconj(a) := re(a) - im(a) (0,1) :: im(a) != 0
26268 (Because the @code{re} and @code{im} functions understand the properties
26269 of the special constant @samp{i}, this rule will also work for
26270 @samp{3 - 4 i}. In fact, this particular rule would probably be better
26271 without the @samp{im(a) != 0} condition, since if @samp{im(a) = 0} the
26272 righthand side of the rule will still give the correct answer for the
26273 conjugate of a real number.)
26275 It is also possible to specify optional arguments in patterns. The rule
26278 opt(a) x + opt(b) (x^opt(c) + opt(d)) := f(a, b, c, d)
26282 will match the formula
26289 in a fairly straightforward manner, but it will also match reduced
26293 x + x^2, 2(x + 1) - x, x + x
26297 producing, respectively,
26300 f(1, 1, 2, 0), f(-1, 2, 1, 1), f(1, 1, 1, 0)
26303 (The latter two formulas can be entered only if default simplifications
26304 have been turned off with @kbd{m O}.)
26306 The default value for a term of a sum is zero. The default value
26307 for a part of a product, for a power, or for the denominator of a
26308 quotient, is one. Also, @samp{-x} matches the pattern @samp{opt(a) b}
26309 with @samp{a = -1}.
26311 In particular, the distributive-law rule can be refined to
26314 opt(a) x + opt(b) x := (a + b) x
26318 so that it will convert, e.g., @samp{a x - x}, to @samp{(a - 1) x}.
26320 The pattern @samp{opt(a) + opt(b) x} matches almost any formulas which
26321 are linear in @samp{x}. You can also use the @code{lin} and @code{islin}
26322 functions with rewrite conditions to test for this; @pxref{Logical
26323 Operations}. These functions are not as convenient to use in rewrite
26324 rules, but they recognize more kinds of formulas as linear:
26325 @samp{x/z} is considered linear with @expr{b = 1/z} by @code{lin},
26326 but it will not match the above pattern because that pattern calls
26327 for a multiplication, not a division.
26329 As another example, the obvious rule to replace @samp{sin(x)^2 + cos(x)^2}
26333 sin(x)^2 + cos(x)^2 := 1
26337 misses many cases because the sine and cosine may both be multiplied by
26338 an equal factor. Here's a more successful rule:
26341 opt(a) sin(x)^2 + opt(a) cos(x)^2 := a
26344 Note that this rule will @emph{not} match @samp{sin(x)^2 + 6 cos(x)^2}
26345 because one @expr{a} would have ``matched'' 1 while the other matched 6.
26347 Calc automatically converts a rule like
26357 f(temp, x) := g(x) :: temp = x-1
26361 (where @code{temp} stands for a new, invented meta-variable that
26362 doesn't actually have a name). This modified rule will successfully
26363 match @samp{f(6, 7)}, binding @samp{temp} and @samp{x} to 6 and 7,
26364 respectively, then verifying that they differ by one even though
26365 @samp{6} does not superficially look like @samp{x-1}.
26367 However, Calc does not solve equations to interpret a rule. The
26371 f(x-1, x+1) := g(x)
26375 will not work. That is, it will match @samp{f(a - 1 + b, a + 1 + b)}
26376 but not @samp{f(6, 8)}. Calc always interprets at least one occurrence
26377 of a variable by literal matching. If the variable appears ``isolated''
26378 then Calc is smart enough to use it for literal matching. But in this
26379 last example, Calc is forced to rewrite the rule to @samp{f(x-1, temp)
26380 := g(x) :: temp = x+1} where the @samp{x-1} term must correspond to an
26381 actual ``something-minus-one'' in the target formula.
26383 A successful way to write this would be @samp{f(x, x+2) := g(x+1)}.
26384 You could make this resemble the original form more closely by using
26385 @code{let} notation, which is described in the next section:
26388 f(xm1, x+1) := g(x) :: let(x := xm1+1)
26391 Calc does this rewriting or ``conditionalizing'' for any sub-pattern
26392 which involves only the functions in the following list, operating
26393 only on constants and meta-variables which have already been matched
26394 elsewhere in the pattern. When matching a function call, Calc is
26395 careful to match arguments which are plain variables before arguments
26396 which are calls to any of the functions below, so that a pattern like
26397 @samp{f(x-1, x)} can be conditionalized even though the isolated
26398 @samp{x} comes after the @samp{x-1}.
26401 + - * / \ % ^ abs sign round rounde roundu trunc floor ceil
26402 max min re im conj arg
26405 You can suppress all of the special treatments described in this
26406 section by surrounding a function call with a @code{plain} marker.
26407 This marker causes the function call which is its argument to be
26408 matched literally, without regard to commutativity, associativity,
26409 negation, or conditionalization. When you use @code{plain}, the
26410 ``deep structure'' of the formula being matched can show through.
26414 plain(a - a b) := f(a, b)
26418 will match only literal subtractions. However, the @code{plain}
26419 marker does not affect its arguments' arguments. In this case,
26420 commutativity and associativity is still considered while matching
26421 the @w{@samp{a b}} sub-pattern, so the whole pattern will match
26422 @samp{x - y x} as well as @samp{x - x y}. We could go still
26426 plain(a - plain(a b)) := f(a, b)
26430 which would do a completely strict match for the pattern.
26432 By contrast, the @code{quote} marker means that not only the
26433 function name but also the arguments must be literally the same.
26434 The above pattern will match @samp{x - x y} but
26437 quote(a - a b) := f(a, b)
26441 will match only the single formula @samp{a - a b}. Also,
26444 quote(a - quote(a b)) := f(a, b)
26448 will match only @samp{a - quote(a b)}---probably not the desired
26451 A certain amount of algebra is also done when substituting the
26452 meta-variables on the righthand side of a rule. For example,
26456 a + f(b) := f(a + b)
26460 matching @samp{f(x) - y} would produce @samp{f((-y) + x)} if
26461 taken literally, but the rewrite mechanism will simplify the
26462 righthand side to @samp{f(x - y)} automatically. (Of course,
26463 the default simplifications would do this anyway, so this
26464 special simplification is only noticeable if you have turned the
26465 default simplifications off.) This rewriting is done only when
26466 a meta-variable expands to a ``negative-looking'' expression.
26467 If this simplification is not desirable, you can use a @code{plain}
26468 marker on the righthand side:
26471 a + f(b) := f(plain(a + b))
26475 In this example, we are still allowing the pattern-matcher to
26476 use all the algebra it can muster, but the righthand side will
26477 always simplify to a literal addition like @samp{f((-y) + x)}.
26479 @node Other Features of Rewrite Rules, Composing Patterns in Rewrite Rules, Algebraic Properties of Rewrite Rules, Rewrite Rules
26480 @subsection Other Features of Rewrite Rules
26483 Certain ``function names'' serve as markers in rewrite rules.
26484 Here is a complete list of these markers. First are listed the
26485 markers that work inside a pattern; then come the markers that
26486 work in the righthand side of a rule.
26492 One kind of marker, @samp{import(x)}, takes the place of a whole
26493 rule. Here @expr{x} is the name of a variable containing another
26494 rule set; those rules are ``spliced into'' the rule set that
26495 imports them. For example, if @samp{[f(a+b) := f(a) + f(b),
26496 f(a b) := a f(b) :: real(a)]} is stored in variable @samp{linearF},
26497 then the rule set @samp{[f(0) := 0, import(linearF)]} will apply
26498 all three rules. It is possible to modify the imported rules
26499 slightly: @samp{import(x, v1, x1, v2, x2, @dots{})} imports
26500 the rule set @expr{x} with all occurrences of
26501 @texline @math{v_1},
26502 @infoline @expr{v1},
26503 as either a variable name or a function name, replaced with
26504 @texline @math{x_1}
26505 @infoline @expr{x1}
26507 @texline @math{v_1}
26508 @infoline @expr{v1}
26509 is used as a function name, then
26510 @texline @math{x_1}
26511 @infoline @expr{x1}
26512 must be either a function name itself or a @w{@samp{< >}} nameless
26513 function; @pxref{Specifying Operators}.) For example, @samp{[g(0) := 0,
26514 import(linearF, f, g)]} applies the linearity rules to the function
26515 @samp{g} instead of @samp{f}. Imports can be nested, but the
26516 import-with-renaming feature may fail to rename sub-imports properly.
26518 The special functions allowed in patterns are:
26526 This pattern matches exactly @expr{x}; variable names in @expr{x} are
26527 not interpreted as meta-variables. The only flexibility is that
26528 numbers are compared for numeric equality, so that the pattern
26529 @samp{f(quote(12))} will match both @samp{f(12)} and @samp{f(12.0)}.
26530 (Numbers are always treated this way by the rewrite mechanism:
26531 The rule @samp{f(x,x) := g(x)} will match @samp{f(12, 12.0)}.
26532 The rewrite may produce either @samp{g(12)} or @samp{g(12.0)}
26533 as a result in this case.)
26540 Here @expr{x} must be a function call @samp{f(x1,x2,@dots{})}. This
26541 pattern matches a call to function @expr{f} with the specified
26542 argument patterns. No special knowledge of the properties of the
26543 function @expr{f} is used in this case; @samp{+} is not commutative or
26544 associative. Unlike @code{quote}, the arguments @samp{x1,x2,@dots{}}
26545 are treated as patterns. If you wish them to be treated ``plainly''
26546 as well, you must enclose them with more @code{plain} markers:
26547 @samp{plain(plain(@w{-a}) + plain(b c))}.
26554 Here @expr{x} must be a variable name. This must appear as an
26555 argument to a function or an element of a vector; it specifies that
26556 the argument or element is optional.
26557 As an argument to @samp{+}, @samp{-}, @samp{*}, @samp{&&}, or @samp{||},
26558 or as the second argument to @samp{/} or @samp{^}, the value @var{def}
26559 may be omitted. The pattern @samp{x + opt(y)} matches a sum by
26560 binding one summand to @expr{x} and the other to @expr{y}, and it
26561 matches anything else by binding the whole expression to @expr{x} and
26562 zero to @expr{y}. The other operators above work similarly.
26564 For general miscellaneous functions, the default value @code{def}
26565 must be specified. Optional arguments are dropped starting with
26566 the rightmost one during matching. For example, the pattern
26567 @samp{f(opt(a,0), b, opt(c,b))} will match @samp{f(b)}, @samp{f(a,b)},
26568 or @samp{f(a,b,c)}. Default values of zero and @expr{b} are
26569 supplied in this example for the omitted arguments. Note that
26570 the literal variable @expr{b} will be the default in the latter
26571 case, @emph{not} the value that matched the meta-variable @expr{b}.
26572 In other words, the default @var{def} is effectively quoted.
26574 @item condition(x,c)
26580 This matches the pattern @expr{x}, with the attached condition
26581 @expr{c}. It is the same as @samp{x :: c}.
26589 This matches anything that matches both pattern @expr{x} and
26590 pattern @expr{y}. It is the same as @samp{x &&& y}.
26591 @pxref{Composing Patterns in Rewrite Rules}.
26599 This matches anything that matches either pattern @expr{x} or
26600 pattern @expr{y}. It is the same as @w{@samp{x ||| y}}.
26608 This matches anything that does not match pattern @expr{x}.
26609 It is the same as @samp{!!! x}.
26615 @tindex cons (rewrites)
26616 This matches any vector of one or more elements. The first
26617 element is matched to @expr{h}; a vector of the remaining
26618 elements is matched to @expr{t}. Note that vectors of fixed
26619 length can also be matched as actual vectors: The rule
26620 @samp{cons(a,cons(b,[])) := cons(a+b,[])} is equivalent
26621 to the rule @samp{[a,b] := [a+b]}.
26627 @tindex rcons (rewrites)
26628 This is like @code{cons}, except that the @emph{last} element
26629 is matched to @expr{h}, with the remaining elements matched
26632 @item apply(f,args)
26636 @tindex apply (rewrites)
26637 This matches any function call. The name of the function, in
26638 the form of a variable, is matched to @expr{f}. The arguments
26639 of the function, as a vector of zero or more objects, are
26640 matched to @samp{args}. Constants, variables, and vectors
26641 do @emph{not} match an @code{apply} pattern. For example,
26642 @samp{apply(f,x)} matches any function call, @samp{apply(quote(f),x)}
26643 matches any call to the function @samp{f}, @samp{apply(f,[a,b])}
26644 matches any function call with exactly two arguments, and
26645 @samp{apply(quote(f), cons(a,cons(b,x)))} matches any call
26646 to the function @samp{f} with two or more arguments. Another
26647 way to implement the latter, if the rest of the rule does not
26648 need to refer to the first two arguments of @samp{f} by name,
26649 would be @samp{apply(quote(f), x :: vlen(x) >= 2)}.
26650 Here's a more interesting sample use of @code{apply}:
26653 apply(f,[x+n]) := n + apply(f,[x])
26654 :: in(f, [floor,ceil,round,trunc]) :: integer(n)
26657 Note, however, that this will be slower to match than a rule
26658 set with four separate rules. The reason is that Calc sorts
26659 the rules of a rule set according to top-level function name;
26660 if the top-level function is @code{apply}, Calc must try the
26661 rule for every single formula and sub-formula. If the top-level
26662 function in the pattern is, say, @code{floor}, then Calc invokes
26663 the rule only for sub-formulas which are calls to @code{floor}.
26665 Formulas normally written with operators like @code{+} are still
26666 considered function calls: @code{apply(f,x)} matches @samp{a+b}
26667 with @samp{f = add}, @samp{x = [a,b]}.
26669 You must use @code{apply} for meta-variables with function names
26670 on both sides of a rewrite rule: @samp{apply(f, [x]) := f(x+1)}
26671 is @emph{not} correct, because it rewrites @samp{spam(6)} into
26672 @samp{f(7)}. The righthand side should be @samp{apply(f, [x+1])}.
26673 Also note that you will have to use No-Simplify mode (@kbd{m O})
26674 when entering this rule so that the @code{apply} isn't
26675 evaluated immediately to get the new rule @samp{f(x) := f(x+1)}.
26676 Or, use @kbd{s e} to enter the rule without going through the stack,
26677 or enter the rule as @samp{apply(f, [x]) := apply(f, [x+1]) @w{:: 1}}.
26678 @xref{Conditional Rewrite Rules}.
26685 This is used for applying rules to formulas with selections;
26686 @pxref{Selections with Rewrite Rules}.
26689 Special functions for the righthand sides of rules are:
26693 The notation @samp{quote(x)} is changed to @samp{x} when the
26694 righthand side is used. As far as the rewrite rule is concerned,
26695 @code{quote} is invisible. However, @code{quote} has the special
26696 property in Calc that its argument is not evaluated. Thus,
26697 while it will not work to put the rule @samp{t(a) := typeof(a)}
26698 on the stack because @samp{typeof(a)} is evaluated immediately
26699 to produce @samp{t(a) := 100}, you can use @code{quote} to
26700 protect the righthand side: @samp{t(a) := quote(typeof(a))}.
26701 (@xref{Conditional Rewrite Rules}, for another trick for
26702 protecting rules from evaluation.)
26705 Special properties of and simplifications for the function call
26706 @expr{x} are not used. One interesting case where @code{plain}
26707 is useful is the rule, @samp{q(x) := quote(x)}, trying to expand a
26708 shorthand notation for the @code{quote} function. This rule will
26709 not work as shown; instead of replacing @samp{q(foo)} with
26710 @samp{quote(foo)}, it will replace it with @samp{foo}! The correct
26711 rule would be @samp{q(x) := plain(quote(x))}.
26714 Where @expr{t} is a vector, this is converted into an expanded
26715 vector during rewrite processing. Note that @code{cons} is a regular
26716 Calc function which normally does this anyway; the only way @code{cons}
26717 is treated specially by rewrites is that @code{cons} on the righthand
26718 side of a rule will be evaluated even if default simplifications
26719 have been turned off.
26722 Analogous to @code{cons} except putting @expr{h} at the @emph{end} of
26723 the vector @expr{t}.
26725 @item apply(f,args)
26726 Where @expr{f} is a variable and @var{args} is a vector, this
26727 is converted to a function call. Once again, note that @code{apply}
26728 is also a regular Calc function.
26735 The formula @expr{x} is handled in the usual way, then the
26736 default simplifications are applied to it even if they have
26737 been turned off normally. This allows you to treat any function
26738 similarly to the way @code{cons} and @code{apply} are always
26739 treated. However, there is a slight difference: @samp{cons(2+3, [])}
26740 with default simplifications off will be converted to @samp{[2+3]},
26741 whereas @samp{eval(cons(2+3, []))} will be converted to @samp{[5]}.
26748 The formula @expr{x} has meta-variables substituted in the usual
26749 way, then algebraically simplified as if by the @kbd{a s} command.
26751 @item evalextsimp(x)
26755 @tindex evalextsimp
26756 The formula @expr{x} has meta-variables substituted in the normal
26757 way, then ``extendedly'' simplified as if by the @kbd{a e} command.
26760 @xref{Selections with Rewrite Rules}.
26763 There are also some special functions you can use in conditions.
26771 The expression @expr{x} is evaluated with meta-variables substituted.
26772 The @kbd{a s} command's simplifications are @emph{not} applied by
26773 default, but @expr{x} can include calls to @code{evalsimp} or
26774 @code{evalextsimp} as described above to invoke higher levels
26775 of simplification. The
26776 result of @expr{x} is then bound to the meta-variable @expr{v}. As
26777 usual, if this meta-variable has already been matched to something
26778 else the two values must be equal; if the meta-variable is new then
26779 it is bound to the result of the expression. This variable can then
26780 appear in later conditions, and on the righthand side of the rule.
26781 In fact, @expr{v} may be any pattern in which case the result of
26782 evaluating @expr{x} is matched to that pattern, binding any
26783 meta-variables that appear in that pattern. Note that @code{let}
26784 can only appear by itself as a condition, or as one term of an
26785 @samp{&&} which is a whole condition: It cannot be inside
26786 an @samp{||} term or otherwise buried.
26788 The alternate, equivalent form @samp{let(v, x)} is also recognized.
26789 Note that the use of @samp{:=} by @code{let}, while still being
26790 assignment-like in character, is unrelated to the use of @samp{:=}
26791 in the main part of a rewrite rule.
26793 As an example, @samp{f(a) := g(ia) :: let(ia := 1/a) :: constant(ia)}
26794 replaces @samp{f(a)} with @samp{g} of the inverse of @samp{a}, if
26795 that inverse exists and is constant. For example, if @samp{a} is a
26796 singular matrix the operation @samp{1/a} is left unsimplified and
26797 @samp{constant(ia)} fails, but if @samp{a} is an invertible matrix
26798 then the rule succeeds. Without @code{let} there would be no way
26799 to express this rule that didn't have to invert the matrix twice.
26800 Note that, because the meta-variable @samp{ia} is otherwise unbound
26801 in this rule, the @code{let} condition itself always ``succeeds''
26802 because no matter what @samp{1/a} evaluates to, it can successfully
26803 be bound to @code{ia}.
26805 Here's another example, for integrating cosines of linear
26806 terms: @samp{myint(cos(y),x) := sin(y)/b :: let([a,b,x] := lin(y,x))}.
26807 The @code{lin} function returns a 3-vector if its argument is linear,
26808 or leaves itself unevaluated if not. But an unevaluated @code{lin}
26809 call will not match the 3-vector on the lefthand side of the @code{let},
26810 so this @code{let} both verifies that @code{y} is linear, and binds
26811 the coefficients @code{a} and @code{b} for use elsewhere in the rule.
26812 (It would have been possible to use @samp{sin(a x + b)/b} for the
26813 righthand side instead, but using @samp{sin(y)/b} avoids gratuitous
26814 rearrangement of the argument of the sine.)
26820 Similarly, here is a rule that implements an inverse-@code{erf}
26821 function. It uses @code{root} to search for a solution. If
26822 @code{root} succeeds, it will return a vector of two numbers
26823 where the first number is the desired solution. If no solution
26824 is found, @code{root} remains in symbolic form. So we use
26825 @code{let} to check that the result was indeed a vector.
26828 ierf(x) := y :: let([y,z] := root(erf(a) = x, a, .5))
26832 The meta-variable @var{v}, which must already have been matched
26833 to something elsewhere in the rule, is compared against pattern
26834 @var{p}. Since @code{matches} is a standard Calc function, it
26835 can appear anywhere in a condition. But if it appears alone or
26836 as a term of a top-level @samp{&&}, then you get the special
26837 extra feature that meta-variables which are bound to things
26838 inside @var{p} can be used elsewhere in the surrounding rewrite
26841 The only real difference between @samp{let(p := v)} and
26842 @samp{matches(v, p)} is that the former evaluates @samp{v} using
26843 the default simplifications, while the latter does not.
26847 This is actually a variable, not a function. If @code{remember}
26848 appears as a condition in a rule, then when that rule succeeds
26849 the original expression and rewritten expression are added to the
26850 front of the rule set that contained the rule. If the rule set
26851 was not stored in a variable, @code{remember} is ignored. The
26852 lefthand side is enclosed in @code{quote} in the added rule if it
26853 contains any variables.
26855 For example, the rule @samp{f(n) := n f(n-1) :: remember} applied
26856 to @samp{f(7)} will add the rule @samp{f(7) := 7 f(6)} to the front
26857 of the rule set. The rule set @code{EvalRules} works slightly
26858 differently: There, the evaluation of @samp{f(6)} will complete before
26859 the result is added to the rule set, in this case as @samp{f(7) := 5040}.
26860 Thus @code{remember} is most useful inside @code{EvalRules}.
26862 It is up to you to ensure that the optimization performed by
26863 @code{remember} is safe. For example, the rule @samp{foo(n) := n
26864 :: evalv(eatfoo) > 0 :: remember} is a bad idea (@code{evalv} is
26865 the function equivalent of the @kbd{=} command); if the variable
26866 @code{eatfoo} ever contains 1, rules like @samp{foo(7) := 7} will
26867 be added to the rule set and will continue to operate even if
26868 @code{eatfoo} is later changed to 0.
26875 Remember the match as described above, but only if condition @expr{c}
26876 is true. For example, @samp{remember(n % 4 = 0)} in the above factorial
26877 rule remembers only every fourth result. Note that @samp{remember(1)}
26878 is equivalent to @samp{remember}, and @samp{remember(0)} has no effect.
26881 @node Composing Patterns in Rewrite Rules, Nested Formulas with Rewrite Rules, Other Features of Rewrite Rules, Rewrite Rules
26882 @subsection Composing Patterns in Rewrite Rules
26885 There are three operators, @samp{&&&}, @samp{|||}, and @samp{!!!},
26886 that combine rewrite patterns to make larger patterns. The
26887 combinations are ``and,'' ``or,'' and ``not,'' respectively, and
26888 these operators are the pattern equivalents of @samp{&&}, @samp{||}
26889 and @samp{!} (which operate on zero-or-nonzero logical values).
26891 Note that @samp{&&&}, @samp{|||}, and @samp{!!!} are left in symbolic
26892 form by all regular Calc features; they have special meaning only in
26893 the context of rewrite rule patterns.
26895 The pattern @samp{@var{p1} &&& @var{p2}} matches anything that
26896 matches both @var{p1} and @var{p2}. One especially useful case is
26897 when one of @var{p1} or @var{p2} is a meta-variable. For example,
26898 here is a rule that operates on error forms:
26901 f(x &&& a +/- b, x) := g(x)
26904 This does the same thing, but is arguably simpler than, the rule
26907 f(a +/- b, a +/- b) := g(a +/- b)
26914 Here's another interesting example:
26917 ends(cons(a, x) &&& rcons(y, b)) := [a, b]
26921 which effectively clips out the middle of a vector leaving just
26922 the first and last elements. This rule will change a one-element
26923 vector @samp{[a]} to @samp{[a, a]}. The similar rule
26926 ends(cons(a, rcons(y, b))) := [a, b]
26930 would do the same thing except that it would fail to match a
26931 one-element vector.
26937 The pattern @samp{@var{p1} ||| @var{p2}} matches anything that
26938 matches either @var{p1} or @var{p2}. Calc first tries matching
26939 against @var{p1}; if that fails, it goes on to try @var{p2}.
26945 A simple example of @samp{|||} is
26948 curve(inf ||| -inf) := 0
26952 which converts both @samp{curve(inf)} and @samp{curve(-inf)} to zero.
26954 Here is a larger example:
26957 log(a, b) ||| (ln(a) :: let(b := e)) := mylog(a, b)
26960 This matches both generalized and natural logarithms in a single rule.
26961 Note that the @samp{::} term must be enclosed in parentheses because
26962 that operator has lower precedence than @samp{|||} or @samp{:=}.
26964 (In practice this rule would probably include a third alternative,
26965 omitted here for brevity, to take care of @code{log10}.)
26967 While Calc generally treats interior conditions exactly the same as
26968 conditions on the outside of a rule, it does guarantee that if all the
26969 variables in the condition are special names like @code{e}, or already
26970 bound in the pattern to which the condition is attached (say, if
26971 @samp{a} had appeared in this condition), then Calc will process this
26972 condition right after matching the pattern to the left of the @samp{::}.
26973 Thus, we know that @samp{b} will be bound to @samp{e} only if the
26974 @code{ln} branch of the @samp{|||} was taken.
26976 Note that this rule was careful to bind the same set of meta-variables
26977 on both sides of the @samp{|||}. Calc does not check this, but if
26978 you bind a certain meta-variable only in one branch and then use that
26979 meta-variable elsewhere in the rule, results are unpredictable:
26982 f(a,b) ||| g(b) := h(a,b)
26985 Here if the pattern matches @samp{g(17)}, Calc makes no promises about
26986 the value that will be substituted for @samp{a} on the righthand side.
26992 The pattern @samp{!!! @var{pat}} matches anything that does not
26993 match @var{pat}. Any meta-variables that are bound while matching
26994 @var{pat} remain unbound outside of @var{pat}.
26999 f(x &&& !!! a +/- b, !!![]) := g(x)
27003 converts @code{f} whose first argument is anything @emph{except} an
27004 error form, and whose second argument is not the empty vector, into
27005 a similar call to @code{g} (but without the second argument).
27007 If we know that the second argument will be a vector (empty or not),
27008 then an equivalent rule would be:
27011 f(x, y) := g(x) :: typeof(x) != 7 :: vlen(y) > 0
27015 where of course 7 is the @code{typeof} code for error forms.
27016 Another final condition, that works for any kind of @samp{y},
27017 would be @samp{!istrue(y == [])}. (The @code{istrue} function
27018 returns an explicit 0 if its argument was left in symbolic form;
27019 plain @samp{!(y == [])} or @samp{y != []} would not work to replace
27020 @samp{!!![]} since these would be left unsimplified, and thus cause
27021 the rule to fail, if @samp{y} was something like a variable name.)
27023 It is possible for a @samp{!!!} to refer to meta-variables bound
27024 elsewhere in the pattern. For example,
27031 matches any call to @code{f} with different arguments, changing
27032 this to @code{g} with only the first argument.
27034 If a function call is to be matched and one of the argument patterns
27035 contains a @samp{!!!} somewhere inside it, that argument will be
27043 will be careful to bind @samp{a} to the second argument of @code{f}
27044 before testing the first argument. If Calc had tried to match the
27045 first argument of @code{f} first, the results would have been
27046 disastrous: since @code{a} was unbound so far, the pattern @samp{a}
27047 would have matched anything at all, and the pattern @samp{!!!a}
27048 therefore would @emph{not} have matched anything at all!
27050 @node Nested Formulas with Rewrite Rules, Multi-Phase Rewrite Rules, Composing Patterns in Rewrite Rules, Rewrite Rules
27051 @subsection Nested Formulas with Rewrite Rules
27054 When @kbd{a r} (@code{calc-rewrite}) is used, it takes an expression from
27055 the top of the stack and attempts to match any of the specified rules
27056 to any part of the expression, starting with the whole expression
27057 and then, if that fails, trying deeper and deeper sub-expressions.
27058 For each part of the expression, the rules are tried in the order
27059 they appear in the rules vector. The first rule to match the first
27060 sub-expression wins; it replaces the matched sub-expression according
27061 to the @var{new} part of the rule.
27063 Often, the rule set will match and change the formula several times.
27064 The top-level formula is first matched and substituted repeatedly until
27065 it no longer matches the pattern; then, sub-formulas are tried, and
27066 so on. Once every part of the formula has gotten its chance, the
27067 rewrite mechanism starts over again with the top-level formula
27068 (in case a substitution of one of its arguments has caused it again
27069 to match). This continues until no further matches can be made
27070 anywhere in the formula.
27072 It is possible for a rule set to get into an infinite loop. The
27073 most obvious case, replacing a formula with itself, is not a problem
27074 because a rule is not considered to ``succeed'' unless the righthand
27075 side actually comes out to something different than the original
27076 formula or sub-formula that was matched. But if you accidentally
27077 had both @samp{ln(a b) := ln(a) + ln(b)} and the reverse
27078 @samp{ln(a) + ln(b) := ln(a b)} in your rule set, Calc would
27079 run forever switching a formula back and forth between the two
27082 To avoid disaster, Calc normally stops after 100 changes have been
27083 made to the formula. This will be enough for most multiple rewrites,
27084 but it will keep an endless loop of rewrites from locking up the
27085 computer forever. (On most systems, you can also type @kbd{C-g} to
27086 halt any Emacs command prematurely.)
27088 To change this limit, give a positive numeric prefix argument.
27089 In particular, @kbd{M-1 a r} applies only one rewrite at a time,
27090 useful when you are first testing your rule (or just if repeated
27091 rewriting is not what is called for by your application).
27100 You can also put a ``function call'' @samp{iterations(@var{n})}
27101 in place of a rule anywhere in your rules vector (but usually at
27102 the top). Then, @var{n} will be used instead of 100 as the default
27103 number of iterations for this rule set. You can use
27104 @samp{iterations(inf)} if you want no iteration limit by default.
27105 A prefix argument will override the @code{iterations} limit in the
27113 More precisely, the limit controls the number of ``iterations,''
27114 where each iteration is a successful matching of a rule pattern whose
27115 righthand side, after substituting meta-variables and applying the
27116 default simplifications, is different from the original sub-formula
27119 A prefix argument of zero sets the limit to infinity. Use with caution!
27121 Given a negative numeric prefix argument, @kbd{a r} will match and
27122 substitute the top-level expression up to that many times, but
27123 will not attempt to match the rules to any sub-expressions.
27125 In a formula, @code{rewrite(@var{expr}, @var{rules}, @var{n})}
27126 does a rewriting operation. Here @var{expr} is the expression
27127 being rewritten, @var{rules} is the rule, vector of rules, or
27128 variable containing the rules, and @var{n} is the optional
27129 iteration limit, which may be a positive integer, a negative
27130 integer, or @samp{inf} or @samp{-inf}. If @var{n} is omitted
27131 the @code{iterations} value from the rule set is used; if both
27132 are omitted, 100 is used.
27134 @node Multi-Phase Rewrite Rules, Selections with Rewrite Rules, Nested Formulas with Rewrite Rules, Rewrite Rules
27135 @subsection Multi-Phase Rewrite Rules
27138 It is possible to separate a rewrite rule set into several @dfn{phases}.
27139 During each phase, certain rules will be enabled while certain others
27140 will be disabled. A @dfn{phase schedule} controls the order in which
27141 phases occur during the rewriting process.
27148 If a call to the marker function @code{phase} appears in the rules
27149 vector in place of a rule, all rules following that point will be
27150 members of the phase(s) identified in the arguments to @code{phase}.
27151 Phases are given integer numbers. The markers @samp{phase()} and
27152 @samp{phase(all)} both mean the following rules belong to all phases;
27153 this is the default at the start of the rule set.
27155 If you do not explicitly schedule the phases, Calc sorts all phase
27156 numbers that appear in the rule set and executes the phases in
27157 ascending order. For example, the rule set
27174 has three phases, 1 through 3. Phase 1 consists of the @code{f0},
27175 @code{f1}, and @code{f4} rules (in that order). Phase 2 consists of
27176 @code{f0}, @code{f2}, and @code{f4}. Phase 3 consists of @code{f0}
27179 When Calc rewrites a formula using this rule set, it first rewrites
27180 the formula using only the phase 1 rules until no further changes are
27181 possible. Then it switches to the phase 2 rule set and continues
27182 until no further changes occur, then finally rewrites with phase 3.
27183 When no more phase 3 rules apply, rewriting finishes. (This is
27184 assuming @kbd{a r} with a large enough prefix argument to allow the
27185 rewriting to run to completion; the sequence just described stops
27186 early if the number of iterations specified in the prefix argument,
27187 100 by default, is reached.)
27189 During each phase, Calc descends through the nested levels of the
27190 formula as described previously. (@xref{Nested Formulas with Rewrite
27191 Rules}.) Rewriting starts at the top of the formula, then works its
27192 way down to the parts, then goes back to the top and works down again.
27193 The phase 2 rules do not begin until no phase 1 rules apply anywhere
27200 A @code{schedule} marker appearing in the rule set (anywhere, but
27201 conventionally at the top) changes the default schedule of phases.
27202 In the simplest case, @code{schedule} has a sequence of phase numbers
27203 for arguments; each phase number is invoked in turn until the
27204 arguments to @code{schedule} are exhausted. Thus adding
27205 @samp{schedule(3,2,1)} at the top of the above rule set would
27206 reverse the order of the phases; @samp{schedule(1,2,3)} would have
27207 no effect since this is the default schedule; and @samp{schedule(1,2,1,3)}
27208 would give phase 1 a second chance after phase 2 has completed, before
27209 moving on to phase 3.
27211 Any argument to @code{schedule} can instead be a vector of phase
27212 numbers (or even of sub-vectors). Then the sub-sequence of phases
27213 described by the vector are tried repeatedly until no change occurs
27214 in any phase in the sequence. For example, @samp{schedule([1, 2], 3)}
27215 tries phase 1, then phase 2, then, if either phase made any changes
27216 to the formula, repeats these two phases until they can make no
27217 further progress. Finally, it goes on to phase 3 for finishing
27220 Also, items in @code{schedule} can be variable names as well as
27221 numbers. A variable name is interpreted as the name of a function
27222 to call on the whole formula. For example, @samp{schedule(1, simplify)}
27223 says to apply the phase-1 rules (presumably, all of them), then to
27224 call @code{simplify} which is the function name equivalent of @kbd{a s}.
27225 Likewise, @samp{schedule([1, simplify])} says to alternate between
27226 phase 1 and @kbd{a s} until no further changes occur.
27228 Phases can be used purely to improve efficiency; if it is known that
27229 a certain group of rules will apply only at the beginning of rewriting,
27230 and a certain other group will apply only at the end, then rewriting
27231 will be faster if these groups are identified as separate phases.
27232 Once the phase 1 rules are done, Calc can put them aside and no longer
27233 spend any time on them while it works on phase 2.
27235 There are also some problems that can only be solved with several
27236 rewrite phases. For a real-world example of a multi-phase rule set,
27237 examine the set @code{FitRules}, which is used by the curve-fitting
27238 command to convert a model expression to linear form.
27239 @xref{Curve Fitting Details}. This set is divided into four phases.
27240 The first phase rewrites certain kinds of expressions to be more
27241 easily linearizable, but less computationally efficient. After the
27242 linear components have been picked out, the final phase includes the
27243 opposite rewrites to put each component back into an efficient form.
27244 If both sets of rules were included in one big phase, Calc could get
27245 into an infinite loop going back and forth between the two forms.
27247 Elsewhere in @code{FitRules}, the components are first isolated,
27248 then recombined where possible to reduce the complexity of the linear
27249 fit, then finally packaged one component at a time into vectors.
27250 If the packaging rules were allowed to begin before the recombining
27251 rules were finished, some components might be put away into vectors
27252 before they had a chance to recombine. By putting these rules in
27253 two separate phases, this problem is neatly avoided.
27255 @node Selections with Rewrite Rules, Matching Commands, Multi-Phase Rewrite Rules, Rewrite Rules
27256 @subsection Selections with Rewrite Rules
27259 If a sub-formula of the current formula is selected (as by @kbd{j s};
27260 @pxref{Selecting Subformulas}), the @kbd{a r} (@code{calc-rewrite})
27261 command applies only to that sub-formula. Together with a negative
27262 prefix argument, you can use this fact to apply a rewrite to one
27263 specific part of a formula without affecting any other parts.
27266 @pindex calc-rewrite-selection
27267 The @kbd{j r} (@code{calc-rewrite-selection}) command allows more
27268 sophisticated operations on selections. This command prompts for
27269 the rules in the same way as @kbd{a r}, but it then applies those
27270 rules to the whole formula in question even though a sub-formula
27271 of it has been selected. However, the selected sub-formula will
27272 first have been surrounded by a @samp{select( )} function call.
27273 (Calc's evaluator does not understand the function name @code{select};
27274 this is only a tag used by the @kbd{j r} command.)
27276 For example, suppose the formula on the stack is @samp{2 (a + b)^2}
27277 and the sub-formula @samp{a + b} is selected. This formula will
27278 be rewritten to @samp{2 select(a + b)^2} and then the rewrite
27279 rules will be applied in the usual way. The rewrite rules can
27280 include references to @code{select} to tell where in the pattern
27281 the selected sub-formula should appear.
27283 If there is still exactly one @samp{select( )} function call in
27284 the formula after rewriting is done, it indicates which part of
27285 the formula should be selected afterwards. Otherwise, the
27286 formula will be unselected.
27288 You can make @kbd{j r} act much like @kbd{a r} by enclosing both parts
27289 of the rewrite rule with @samp{select()}. However, @kbd{j r}
27290 allows you to use the current selection in more flexible ways.
27291 Suppose you wished to make a rule which removed the exponent from
27292 the selected term; the rule @samp{select(a)^x := select(a)} would
27293 work. In the above example, it would rewrite @samp{2 select(a + b)^2}
27294 to @samp{2 select(a + b)}. This would then be returned to the
27295 stack as @samp{2 (a + b)} with the @samp{a + b} selected.
27297 The @kbd{j r} command uses one iteration by default, unlike
27298 @kbd{a r} which defaults to 100 iterations. A numeric prefix
27299 argument affects @kbd{j r} in the same way as @kbd{a r}.
27300 @xref{Nested Formulas with Rewrite Rules}.
27302 As with other selection commands, @kbd{j r} operates on the stack
27303 entry that contains the cursor. (If the cursor is on the top-of-stack
27304 @samp{.} marker, it works as if the cursor were on the formula
27307 If you don't specify a set of rules, the rules are taken from the
27308 top of the stack, just as with @kbd{a r}. In this case, the
27309 cursor must indicate stack entry 2 or above as the formula to be
27310 rewritten (otherwise the same formula would be used as both the
27311 target and the rewrite rules).
27313 If the indicated formula has no selection, the cursor position within
27314 the formula temporarily selects a sub-formula for the purposes of this
27315 command. If the cursor is not on any sub-formula (e.g., it is in
27316 the line-number area to the left of the formula), the @samp{select( )}
27317 markers are ignored by the rewrite mechanism and the rules are allowed
27318 to apply anywhere in the formula.
27320 As a special feature, the normal @kbd{a r} command also ignores
27321 @samp{select( )} calls in rewrite rules. For example, if you used the
27322 above rule @samp{select(a)^x := select(a)} with @kbd{a r}, it would apply
27323 the rule as if it were @samp{a^x := a}. Thus, you can write general
27324 purpose rules with @samp{select( )} hints inside them so that they
27325 will ``do the right thing'' in both @kbd{a r} and @kbd{j r},
27326 both with and without selections.
27328 @node Matching Commands, Automatic Rewrites, Selections with Rewrite Rules, Rewrite Rules
27329 @subsection Matching Commands
27335 The @kbd{a m} (@code{calc-match}) [@code{match}] function takes a
27336 vector of formulas and a rewrite-rule-style pattern, and produces
27337 a vector of all formulas which match the pattern. The command
27338 prompts you to enter the pattern; as for @kbd{a r}, you can enter
27339 a single pattern (i.e., a formula with meta-variables), or a
27340 vector of patterns, or a variable which contains patterns, or
27341 you can give a blank response in which case the patterns are taken
27342 from the top of the stack. The pattern set will be compiled once
27343 and saved if it is stored in a variable. If there are several
27344 patterns in the set, vector elements are kept if they match any
27347 For example, @samp{match(a+b, [x, x+y, x-y, 7, x+y+z])}
27348 will return @samp{[x+y, x-y, x+y+z]}.
27350 The @code{import} mechanism is not available for pattern sets.
27352 The @kbd{a m} command can also be used to extract all vector elements
27353 which satisfy any condition: The pattern @samp{x :: x>0} will select
27354 all the positive vector elements.
27358 With the Inverse flag [@code{matchnot}], this command extracts all
27359 vector elements which do @emph{not} match the given pattern.
27365 There is also a function @samp{matches(@var{x}, @var{p})} which
27366 evaluates to 1 if expression @var{x} matches pattern @var{p}, or
27367 to 0 otherwise. This is sometimes useful for including into the
27368 conditional clauses of other rewrite rules.
27374 The function @code{vmatches} is just like @code{matches}, except
27375 that if the match succeeds it returns a vector of assignments to
27376 the meta-variables instead of the number 1. For example,
27377 @samp{vmatches(f(1,2), f(a,b))} returns @samp{[a := 1, b := 2]}.
27378 If the match fails, the function returns the number 0.
27380 @node Automatic Rewrites, Debugging Rewrites, Matching Commands, Rewrite Rules
27381 @subsection Automatic Rewrites
27384 @cindex @code{EvalRules} variable
27386 It is possible to get Calc to apply a set of rewrite rules on all
27387 results, effectively adding to the built-in set of default
27388 simplifications. To do this, simply store your rule set in the
27389 variable @code{EvalRules}. There is a convenient @kbd{s E} command
27390 for editing @code{EvalRules}; @pxref{Operations on Variables}.
27392 For example, suppose you want @samp{sin(a + b)} to be expanded out
27393 to @samp{sin(b) cos(a) + cos(b) sin(a)} wherever it appears, and
27394 similarly for @samp{cos(a + b)}. The corresponding rewrite rule
27399 [ sin(a + b) := cos(a) sin(b) + sin(a) cos(b),
27400 cos(a + b) := cos(a) cos(b) - sin(a) sin(b) ]
27404 To apply these manually, you could put them in a variable called
27405 @code{trigexp} and then use @kbd{a r trigexp} every time you wanted
27406 to expand trig functions. But if instead you store them in the
27407 variable @code{EvalRules}, they will automatically be applied to all
27408 sines and cosines of sums. Then, with @samp{2 x} and @samp{45} on
27409 the stack, typing @kbd{+ S} will (assuming Degrees mode) result in
27410 @samp{0.7071 sin(2 x) + 0.7071 cos(2 x)} automatically.
27412 As each level of a formula is evaluated, the rules from
27413 @code{EvalRules} are applied before the default simplifications.
27414 Rewriting continues until no further @code{EvalRules} apply.
27415 Note that this is different from the usual order of application of
27416 rewrite rules: @code{EvalRules} works from the bottom up, simplifying
27417 the arguments to a function before the function itself, while @kbd{a r}
27418 applies rules from the top down.
27420 Because the @code{EvalRules} are tried first, you can use them to
27421 override the normal behavior of any built-in Calc function.
27423 It is important not to write a rule that will get into an infinite
27424 loop. For example, the rule set @samp{[f(0) := 1, f(n) := n f(n-1)]}
27425 appears to be a good definition of a factorial function, but it is
27426 unsafe. Imagine what happens if @samp{f(2.5)} is simplified. Calc
27427 will continue to subtract 1 from this argument forever without reaching
27428 zero. A safer second rule would be @samp{f(n) := n f(n-1) :: n>0}.
27429 Another dangerous rule is @samp{g(x, y) := g(y, x)}. Rewriting
27430 @samp{g(2, 4)}, this would bounce back and forth between that and
27431 @samp{g(4, 2)} forever. If an infinite loop in @code{EvalRules}
27432 occurs, Emacs will eventually stop with a ``Computation got stuck
27433 or ran too long'' message.
27435 Another subtle difference between @code{EvalRules} and regular rewrites
27436 concerns rules that rewrite a formula into an identical formula. For
27437 example, @samp{f(n) := f(floor(n))} ``fails to match'' when @expr{n} is
27438 already an integer. But in @code{EvalRules} this case is detected only
27439 if the righthand side literally becomes the original formula before any
27440 further simplification. This means that @samp{f(n) := f(floor(n))} will
27441 get into an infinite loop if it occurs in @code{EvalRules}. Calc will
27442 replace @samp{f(6)} with @samp{f(floor(6))}, which is different from
27443 @samp{f(6)}, so it will consider the rule to have matched and will
27444 continue simplifying that formula; first the argument is simplified
27445 to get @samp{f(6)}, then the rule matches again to get @samp{f(floor(6))}
27446 again, ad infinitum. A much safer rule would check its argument first,
27447 say, with @samp{f(n) := f(floor(n)) :: !dint(n)}.
27449 (What really happens is that the rewrite mechanism substitutes the
27450 meta-variables in the righthand side of a rule, compares to see if the
27451 result is the same as the original formula and fails if so, then uses
27452 the default simplifications to simplify the result and compares again
27453 (and again fails if the formula has simplified back to its original
27454 form). The only special wrinkle for the @code{EvalRules} is that the
27455 same rules will come back into play when the default simplifications
27456 are used. What Calc wants to do is build @samp{f(floor(6))}, see that
27457 this is different from the original formula, simplify to @samp{f(6)},
27458 see that this is the same as the original formula, and thus halt the
27459 rewriting. But while simplifying, @samp{f(6)} will again trigger
27460 the same @code{EvalRules} rule and Calc will get into a loop inside
27461 the rewrite mechanism itself.)
27463 The @code{phase}, @code{schedule}, and @code{iterations} markers do
27464 not work in @code{EvalRules}. If the rule set is divided into phases,
27465 only the phase 1 rules are applied, and the schedule is ignored.
27466 The rules are always repeated as many times as possible.
27468 The @code{EvalRules} are applied to all function calls in a formula,
27469 but not to numbers (and other number-like objects like error forms),
27470 nor to vectors or individual variable names. (Though they will apply
27471 to @emph{components} of vectors and error forms when appropriate.) You
27472 might try to make a variable @code{phihat} which automatically expands
27473 to its definition without the need to press @kbd{=} by writing the
27474 rule @samp{quote(phihat) := (1-sqrt(5))/2}, but unfortunately this rule
27475 will not work as part of @code{EvalRules}.
27477 Finally, another limitation is that Calc sometimes calls its built-in
27478 functions directly rather than going through the default simplifications.
27479 When it does this, @code{EvalRules} will not be able to override those
27480 functions. For example, when you take the absolute value of the complex
27481 number @expr{(2, 3)}, Calc computes @samp{sqrt(2*2 + 3*3)} by calling
27482 the multiplication, addition, and square root functions directly rather
27483 than applying the default simplifications to this formula. So an
27484 @code{EvalRules} rule that (perversely) rewrites @samp{sqrt(13) := 6}
27485 would not apply. (However, if you put Calc into Symbolic mode so that
27486 @samp{sqrt(13)} will be left in symbolic form by the built-in square
27487 root function, your rule will be able to apply. But if the complex
27488 number were @expr{(3,4)}, so that @samp{sqrt(25)} must be calculated,
27489 then Symbolic mode will not help because @samp{sqrt(25)} can be
27490 evaluated exactly to 5.)
27492 One subtle restriction that normally only manifests itself with
27493 @code{EvalRules} is that while a given rewrite rule is in the process
27494 of being checked, that same rule cannot be recursively applied. Calc
27495 effectively removes the rule from its rule set while checking the rule,
27496 then puts it back once the match succeeds or fails. (The technical
27497 reason for this is that compiled pattern programs are not reentrant.)
27498 For example, consider the rule @samp{foo(x) := x :: foo(x/2) > 0}
27499 attempting to match @samp{foo(8)}. This rule will be inactive while
27500 the condition @samp{foo(4) > 0} is checked, even though it might be
27501 an integral part of evaluating that condition. Note that this is not
27502 a problem for the more usual recursive type of rule, such as
27503 @samp{foo(x) := foo(x/2)}, because there the rule has succeeded and
27504 been reactivated by the time the righthand side is evaluated.
27506 If @code{EvalRules} has no stored value (its default state), or if
27507 anything but a vector is stored in it, then it is ignored.
27509 Even though Calc's rewrite mechanism is designed to compare rewrite
27510 rules to formulas as quickly as possible, storing rules in
27511 @code{EvalRules} may make Calc run substantially slower. This is
27512 particularly true of rules where the top-level call is a commonly used
27513 function, or is not fixed. The rule @samp{f(n) := n f(n-1) :: n>0} will
27514 only activate the rewrite mechanism for calls to the function @code{f},
27515 but @samp{lg(n) + lg(m) := lg(n m)} will check every @samp{+} operator.
27518 apply(f, [a*b]) := apply(f, [a]) + apply(f, [b]) :: in(f, [ln, log10])
27522 may seem more ``efficient'' than two separate rules for @code{ln} and
27523 @code{log10}, but actually it is vastly less efficient because rules
27524 with @code{apply} as the top-level pattern must be tested against
27525 @emph{every} function call that is simplified.
27527 @cindex @code{AlgSimpRules} variable
27528 @vindex AlgSimpRules
27529 Suppose you want @samp{sin(a + b)} to be expanded out not all the time,
27530 but only when @kbd{a s} is used to simplify the formula. The variable
27531 @code{AlgSimpRules} holds rules for this purpose. The @kbd{a s} command
27532 will apply @code{EvalRules} and @code{AlgSimpRules} to the formula, as
27533 well as all of its built-in simplifications.
27535 Most of the special limitations for @code{EvalRules} don't apply to
27536 @code{AlgSimpRules}. Calc simply does an @kbd{a r AlgSimpRules}
27537 command with an infinite repeat count as the first step of @kbd{a s}.
27538 It then applies its own built-in simplifications throughout the
27539 formula, and then repeats these two steps (along with applying the
27540 default simplifications) until no further changes are possible.
27542 @cindex @code{ExtSimpRules} variable
27543 @cindex @code{UnitSimpRules} variable
27544 @vindex ExtSimpRules
27545 @vindex UnitSimpRules
27546 There are also @code{ExtSimpRules} and @code{UnitSimpRules} variables
27547 that are used by @kbd{a e} and @kbd{u s}, respectively; these commands
27548 also apply @code{EvalRules} and @code{AlgSimpRules}. The variable
27549 @code{IntegSimpRules} contains simplification rules that are used
27550 only during integration by @kbd{a i}.
27552 @node Debugging Rewrites, Examples of Rewrite Rules, Automatic Rewrites, Rewrite Rules
27553 @subsection Debugging Rewrites
27556 If a buffer named @samp{*Trace*} exists, the rewrite mechanism will
27557 record some useful information there as it operates. The original
27558 formula is written there, as is the result of each successful rewrite,
27559 and the final result of the rewriting. All phase changes are also
27562 Calc always appends to @samp{*Trace*}. You must empty this buffer
27563 yourself periodically if it is in danger of growing unwieldy.
27565 Note that the rewriting mechanism is substantially slower when the
27566 @samp{*Trace*} buffer exists, even if the buffer is not visible on
27567 the screen. Once you are done, you will probably want to kill this
27568 buffer (with @kbd{C-x k *Trace* @key{RET}}). If you leave it in
27569 existence and forget about it, all your future rewrite commands will
27570 be needlessly slow.
27572 @node Examples of Rewrite Rules, , Debugging Rewrites, Rewrite Rules
27573 @subsection Examples of Rewrite Rules
27576 Returning to the example of substituting the pattern
27577 @samp{sin(x)^2 + cos(x)^2} with 1, we saw that the rule
27578 @samp{opt(a) sin(x)^2 + opt(a) cos(x)^2 := a} does a good job of
27579 finding suitable cases. Another solution would be to use the rule
27580 @samp{cos(x)^2 := 1 - sin(x)^2}, followed by algebraic simplification
27581 if necessary. This rule will be the most effective way to do the job,
27582 but at the expense of making some changes that you might not desire.
27584 Another algebraic rewrite rule is @samp{exp(x+y) := exp(x) exp(y)}.
27585 To make this work with the @w{@kbd{j r}} command so that it can be
27586 easily targeted to a particular exponential in a large formula,
27587 you might wish to write the rule as @samp{select(exp(x+y)) :=
27588 select(exp(x) exp(y))}. The @samp{select} markers will be
27589 ignored by the regular @kbd{a r} command
27590 (@pxref{Selections with Rewrite Rules}).
27592 A surprisingly useful rewrite rule is @samp{a/(b-c) := a*(b+c)/(b^2-c^2)}.
27593 This will simplify the formula whenever @expr{b} and/or @expr{c} can
27594 be made simpler by squaring. For example, applying this rule to
27595 @samp{2 / (sqrt(2) + 3)} yields @samp{6:7 - 2:7 sqrt(2)} (assuming
27596 Symbolic mode has been enabled to keep the square root from being
27597 evaluated to a floating-point approximation). This rule is also
27598 useful when working with symbolic complex numbers, e.g.,
27599 @samp{(a + b i) / (c + d i)}.
27601 As another example, we could define our own ``triangular numbers'' function
27602 with the rules @samp{[tri(0) := 0, tri(n) := n + tri(n-1) :: n>0]}. Enter
27603 this vector and store it in a variable: @kbd{@w{s t} trirules}. Now, given
27604 a suitable formula like @samp{tri(5)} on the stack, type @samp{a r trirules}
27605 to apply these rules repeatedly. After six applications, @kbd{a r} will
27606 stop with 15 on the stack. Once these rules are debugged, it would probably
27607 be most useful to add them to @code{EvalRules} so that Calc will evaluate
27608 the new @code{tri} function automatically. We could then use @kbd{Z K} on
27609 the keyboard macro @kbd{' tri($) @key{RET}} to make a command that applies
27610 @code{tri} to the value on the top of the stack. @xref{Programming}.
27612 @cindex Quaternions
27613 The following rule set, contributed by
27614 @texline Fran\c cois
27616 Pinard, implements @dfn{quaternions}, a generalization of the concept of
27617 complex numbers. Quaternions have four components, and are here
27618 represented by function calls @samp{quat(@var{w}, [@var{x}, @var{y},
27619 @var{z}])} with ``real part'' @var{w} and the three ``imaginary'' parts
27620 collected into a vector. Various arithmetical operations on quaternions
27621 are supported. To use these rules, either add them to @code{EvalRules},
27622 or create a command based on @kbd{a r} for simplifying quaternion
27623 formulas. A convenient way to enter quaternions would be a command
27624 defined by a keyboard macro containing: @kbd{' quat($$$$, [$$$, $$, $])
27628 [ quat(w, x, y, z) := quat(w, [x, y, z]),
27629 quat(w, [0, 0, 0]) := w,
27630 abs(quat(w, v)) := hypot(w, v),
27631 -quat(w, v) := quat(-w, -v),
27632 r + quat(w, v) := quat(r + w, v) :: real(r),
27633 r - quat(w, v) := quat(r - w, -v) :: real(r),
27634 quat(w1, v1) + quat(w2, v2) := quat(w1 + w2, v1 + v2),
27635 r * quat(w, v) := quat(r * w, r * v) :: real(r),
27636 plain(quat(w1, v1) * quat(w2, v2))
27637 := quat(w1 * w2 - v1 * v2, w1 * v2 + w2 * v1 + cross(v1, v2)),
27638 quat(w1, v1) / r := quat(w1 / r, v1 / r) :: real(r),
27639 z / quat(w, v) := z * quatinv(quat(w, v)),
27640 quatinv(quat(w, v)) := quat(w, -v) / (w^2 + v^2),
27641 quatsqr(quat(w, v)) := quat(w^2 - v^2, 2 * w * v),
27642 quat(w, v)^k := quatsqr(quat(w, v)^(k / 2))
27643 :: integer(k) :: k > 0 :: k % 2 = 0,
27644 quat(w, v)^k := quatsqr(quat(w, v)^((k - 1) / 2)) * quat(w, v)
27645 :: integer(k) :: k > 2,
27646 quat(w, v)^-k := quatinv(quat(w, v)^k) :: integer(k) :: k > 0 ]
27649 Quaternions, like matrices, have non-commutative multiplication.
27650 In other words, @expr{q1 * q2 = q2 * q1} is not necessarily true if
27651 @expr{q1} and @expr{q2} are @code{quat} forms. The @samp{quat*quat}
27652 rule above uses @code{plain} to prevent Calc from rearranging the
27653 product. It may also be wise to add the line @samp{[quat(), matrix]}
27654 to the @code{Decls} matrix, to ensure that Calc's other algebraic
27655 operations will not rearrange a quaternion product. @xref{Declarations}.
27657 These rules also accept a four-argument @code{quat} form, converting
27658 it to the preferred form in the first rule. If you would rather see
27659 results in the four-argument form, just append the two items
27660 @samp{phase(2), quat(w, [x, y, z]) := quat(w, x, y, z)} to the end
27661 of the rule set. (But remember that multi-phase rule sets don't work
27662 in @code{EvalRules}.)
27664 @node Units, Store and Recall, Algebra, Top
27665 @chapter Operating on Units
27668 One special interpretation of algebraic formulas is as numbers with units.
27669 For example, the formula @samp{5 m / s^2} can be read ``five meters
27670 per second squared.'' The commands in this chapter help you
27671 manipulate units expressions in this form. Units-related commands
27672 begin with the @kbd{u} prefix key.
27675 * Basic Operations on Units::
27676 * The Units Table::
27677 * Predefined Units::
27678 * User-Defined Units::
27681 @node Basic Operations on Units, The Units Table, Units, Units
27682 @section Basic Operations on Units
27685 A @dfn{units expression} is a formula which is basically a number
27686 multiplied and/or divided by one or more @dfn{unit names}, which may
27687 optionally be raised to integer powers. Actually, the value part need not
27688 be a number; any product or quotient involving unit names is a units
27689 expression. Many of the units commands will also accept any formula,
27690 where the command applies to all units expressions which appear in the
27693 A unit name is a variable whose name appears in the @dfn{unit table},
27694 or a variable whose name is a prefix character like @samp{k} (for ``kilo'')
27695 or @samp{u} (for ``micro'') followed by a name in the unit table.
27696 A substantial table of built-in units is provided with Calc;
27697 @pxref{Predefined Units}. You can also define your own unit names;
27698 @pxref{User-Defined Units}.
27700 Note that if the value part of a units expression is exactly @samp{1},
27701 it will be removed by the Calculator's automatic algebra routines: The
27702 formula @samp{1 mm} is ``simplified'' to @samp{mm}. This is only a
27703 display anomaly, however; @samp{mm} will work just fine as a
27704 representation of one millimeter.
27706 You may find that Algebraic mode (@pxref{Algebraic Entry}) makes working
27707 with units expressions easier. Otherwise, you will have to remember
27708 to hit the apostrophe key every time you wish to enter units.
27711 @pindex calc-simplify-units
27713 @mindex usimpl@idots
27716 The @kbd{u s} (@code{calc-simplify-units}) [@code{usimplify}] command
27718 expression. It uses @kbd{a s} (@code{calc-simplify}) to simplify the
27719 expression first as a regular algebraic formula; it then looks for
27720 features that can be further simplified by converting one object's units
27721 to be compatible with another's. For example, @samp{5 m + 23 mm} will
27722 simplify to @samp{5.023 m}. When different but compatible units are
27723 added, the righthand term's units are converted to match those of the
27724 lefthand term. @xref{Simplification Modes}, for a way to have this done
27725 automatically at all times.
27727 Units simplification also handles quotients of two units with the same
27728 dimensionality, as in @w{@samp{2 in s/L cm}} to @samp{5.08 s/L}; fractional
27729 powers of unit expressions, as in @samp{sqrt(9 mm^2)} to @samp{3 mm} and
27730 @samp{sqrt(9 acre)} to a quantity in meters; and @code{floor},
27731 @code{ceil}, @code{round}, @code{rounde}, @code{roundu}, @code{trunc},
27732 @code{float}, @code{frac}, @code{abs}, and @code{clean}
27733 applied to units expressions, in which case
27734 the operation in question is applied only to the numeric part of the
27735 expression. Finally, trigonometric functions of quantities with units
27736 of angle are evaluated, regardless of the current angular mode.
27739 @pindex calc-convert-units
27740 The @kbd{u c} (@code{calc-convert-units}) command converts a units
27741 expression to new, compatible units. For example, given the units
27742 expression @samp{55 mph}, typing @kbd{u c m/s @key{RET}} produces
27743 @samp{24.5872 m/s}. If you have previously converted a units expression
27744 with the same type of units (in this case, distance over time), you will
27745 be offered the previous choice of new units as a default. Continuing
27746 the above example, entering the units expression @samp{100 km/hr} and
27747 typing @kbd{u c @key{RET}} (without specifying new units) produces
27748 @samp{27.7777777778 m/s}.
27750 While many of Calc's conversion factors are exact, some are necessarily
27751 approximate. If Calc is in fraction mode (@pxref{Fraction Mode}), then
27752 unit conversions will try to give exact, rational conversions, but it
27753 isn't always possible. Given @samp{55 mph} in fraction mode, typing
27754 @kbd{u c m/s @key{RET}} produces @samp{15367:625 m/s}, for example,
27755 while typing @kbd{u c au/yr @key{RET}} produces
27756 @samp{5.18665819999e-3 au/yr}.
27758 If the units you request are inconsistent with the original units, the
27759 number will be converted into your units times whatever ``remainder''
27760 units are left over. For example, converting @samp{55 mph} into acres
27761 produces @samp{6.08e-3 acre / m s}. (Recall that multiplication binds
27762 more strongly than division in Calc formulas, so the units here are
27763 acres per meter-second.) Remainder units are expressed in terms of
27764 ``fundamental'' units like @samp{m} and @samp{s}, regardless of the
27767 One special exception is that if you specify a single unit name, and
27768 a compatible unit appears somewhere in the units expression, then
27769 that compatible unit will be converted to the new unit and the
27770 remaining units in the expression will be left alone. For example,
27771 given the input @samp{980 cm/s^2}, the command @kbd{u c ms} will
27772 change the @samp{s} to @samp{ms} to get @samp{9.8e-4 cm/ms^2}.
27773 The ``remainder unit'' @samp{cm} is left alone rather than being
27774 changed to the base unit @samp{m}.
27776 You can use explicit unit conversion instead of the @kbd{u s} command
27777 to gain more control over the units of the result of an expression.
27778 For example, given @samp{5 m + 23 mm}, you can type @kbd{u c m} or
27779 @kbd{u c mm} to express the result in either meters or millimeters.
27780 (For that matter, you could type @kbd{u c fath} to express the result
27781 in fathoms, if you preferred!)
27783 In place of a specific set of units, you can also enter one of the
27784 units system names @code{si}, @code{mks} (equivalent), or @code{cgs}.
27785 For example, @kbd{u c si @key{RET}} converts the expression into
27786 International System of Units (SI) base units. Also, @kbd{u c base}
27787 converts to Calc's base units, which are the same as @code{si} units
27788 except that @code{base} uses @samp{g} as the fundamental unit of mass
27789 whereas @code{si} uses @samp{kg}.
27791 @cindex Composite units
27792 The @kbd{u c} command also accepts @dfn{composite units}, which
27793 are expressed as the sum of several compatible unit names. For
27794 example, converting @samp{30.5 in} to units @samp{mi+ft+in} (miles,
27795 feet, and inches) produces @samp{2 ft + 6.5 in}. Calc first
27796 sorts the unit names into order of decreasing relative size.
27797 It then accounts for as much of the input quantity as it can
27798 using an integer number times the largest unit, then moves on
27799 to the next smaller unit, and so on. Only the smallest unit
27800 may have a non-integer amount attached in the result. A few
27801 standard unit names exist for common combinations, such as
27802 @code{mfi} for @samp{mi+ft+in}, and @code{tpo} for @samp{ton+lb+oz}.
27803 Composite units are expanded as if by @kbd{a x}, so that
27804 @samp{(ft+in)/hr} is first converted to @samp{ft/hr+in/hr}.
27806 If the value on the stack does not contain any units, @kbd{u c} will
27807 prompt first for the old units which this value should be considered
27808 to have, then for the new units. Assuming the old and new units you
27809 give are consistent with each other, the result also will not contain
27810 any units. For example, @kbd{@w{u c} cm @key{RET} in @key{RET}}
27811 converts the number 2 on the stack to 5.08.
27814 @pindex calc-base-units
27815 The @kbd{u b} (@code{calc-base-units}) command is shorthand for
27816 @kbd{u c base}; it converts the units expression on the top of the
27817 stack into @code{base} units. If @kbd{u s} does not simplify a
27818 units expression as far as you would like, try @kbd{u b}.
27820 The @kbd{u c} and @kbd{u b} commands treat temperature units (like
27821 @samp{degC} and @samp{K}) as relative temperatures. For example,
27822 @kbd{u c} converts @samp{10 degC} to @samp{18 degF}: A change of 10
27823 degrees Celsius corresponds to a change of 18 degrees Fahrenheit.
27826 @pindex calc-convert-temperature
27827 @cindex Temperature conversion
27828 The @kbd{u t} (@code{calc-convert-temperature}) command converts
27829 absolute temperatures. The value on the stack must be a simple units
27830 expression with units of temperature only. This command would convert
27831 @samp{10 degC} to @samp{50 degF}, the equivalent temperature on the
27835 @pindex calc-remove-units
27837 @pindex calc-extract-units
27838 The @kbd{u r} (@code{calc-remove-units}) command removes units from the
27839 formula at the top of the stack. The @kbd{u x}
27840 (@code{calc-extract-units}) command extracts only the units portion of a
27841 formula. These commands essentially replace every term of the formula
27842 that does or doesn't (respectively) look like a unit name by the
27843 constant 1, then resimplify the formula.
27846 @pindex calc-autorange-units
27847 The @kbd{u a} (@code{calc-autorange-units}) command turns on and off a
27848 mode in which unit prefixes like @code{k} (``kilo'') are automatically
27849 applied to keep the numeric part of a units expression in a reasonable
27850 range. This mode affects @kbd{u s} and all units conversion commands
27851 except @kbd{u b}. For example, with autoranging on, @samp{12345 Hz}
27852 will be simplified to @samp{12.345 kHz}. Autoranging is useful for
27853 some kinds of units (like @code{Hz} and @code{m}), but is probably
27854 undesirable for non-metric units like @code{ft} and @code{tbsp}.
27855 (Composite units are more appropriate for those; see above.)
27857 Autoranging always applies the prefix to the leftmost unit name.
27858 Calc chooses the largest prefix that causes the number to be greater
27859 than or equal to 1.0. Thus an increasing sequence of adjusted times
27860 would be @samp{1 ms, 10 ms, 100 ms, 1 s, 10 s, 100 s, 1 ks}.
27861 Generally the rule of thumb is that the number will be adjusted
27862 to be in the interval @samp{[1 .. 1000)}, although there are several
27863 exceptions to this rule. First, if the unit has a power then this
27864 is not possible; @samp{0.1 s^2} simplifies to @samp{100000 ms^2}.
27865 Second, the ``centi-'' prefix is allowed to form @code{cm} (centimeters),
27866 but will not apply to other units. The ``deci-,'' ``deka-,'' and
27867 ``hecto-'' prefixes are never used. Thus the allowable interval is
27868 @samp{[1 .. 10)} for millimeters and @samp{[1 .. 100)} for centimeters.
27869 Finally, a prefix will not be added to a unit if the resulting name
27870 is also the actual name of another unit; @samp{1e-15 t} would normally
27871 be considered a ``femto-ton,'' but it is written as @samp{1000 at}
27872 (1000 atto-tons) instead because @code{ft} would be confused with feet.
27874 @node The Units Table, Predefined Units, Basic Operations on Units, Units
27875 @section The Units Table
27879 @pindex calc-enter-units-table
27880 The @kbd{u v} (@code{calc-enter-units-table}) command displays the units table
27881 in another buffer called @code{*Units Table*}. Each entry in this table
27882 gives the unit name as it would appear in an expression, the definition
27883 of the unit in terms of simpler units, and a full name or description of
27884 the unit. Fundamental units are defined as themselves; these are the
27885 units produced by the @kbd{u b} command. The fundamental units are
27886 meters, seconds, grams, kelvins, amperes, candelas, moles, radians,
27889 The Units Table buffer also displays the Unit Prefix Table. Note that
27890 two prefixes, ``kilo'' and ``hecto,'' accept either upper- or lower-case
27891 prefix letters. @samp{Meg} is also accepted as a synonym for the @samp{M}
27892 prefix. Whenever a unit name can be interpreted as either a built-in name
27893 or a prefix followed by another built-in name, the former interpretation
27894 wins. For example, @samp{2 pt} means two pints, not two pico-tons.
27896 The Units Table buffer, once created, is not rebuilt unless you define
27897 new units. To force the buffer to be rebuilt, give any numeric prefix
27898 argument to @kbd{u v}.
27901 @pindex calc-view-units-table
27902 The @kbd{u V} (@code{calc-view-units-table}) command is like @kbd{u v} except
27903 that the cursor is not moved into the Units Table buffer. You can
27904 type @kbd{u V} again to remove the Units Table from the display. To
27905 return from the Units Table buffer after a @kbd{u v}, type @kbd{C-x * c}
27906 again or use the regular Emacs @w{@kbd{C-x o}} (@code{other-window})
27907 command. You can also kill the buffer with @kbd{C-x k} if you wish;
27908 the actual units table is safely stored inside the Calculator.
27911 @pindex calc-get-unit-definition
27912 The @kbd{u g} (@code{calc-get-unit-definition}) command retrieves a unit's
27913 defining expression and pushes it onto the Calculator stack. For example,
27914 @kbd{u g in} will produce the expression @samp{2.54 cm}. This is the
27915 same definition for the unit that would appear in the Units Table buffer.
27916 Note that this command works only for actual unit names; @kbd{u g km}
27917 will report that no such unit exists, for example, because @code{km} is
27918 really the unit @code{m} with a @code{k} (``kilo'') prefix. To see a
27919 definition of a unit in terms of base units, it is easier to push the
27920 unit name on the stack and then reduce it to base units with @kbd{u b}.
27923 @pindex calc-explain-units
27924 The @kbd{u e} (@code{calc-explain-units}) command displays an English
27925 description of the units of the expression on the stack. For example,
27926 for the expression @samp{62 km^2 g / s^2 mol K}, the description is
27927 ``Square-Kilometer Gram per (Second-squared Mole Degree-Kelvin).'' This
27928 command uses the English descriptions that appear in the righthand
27929 column of the Units Table.
27931 @node Predefined Units, User-Defined Units, The Units Table, Units
27932 @section Predefined Units
27935 The definitions of many units have changed over the years. For example,
27936 the meter was originally defined in 1791 as one ten-millionth of the
27937 distance from the equator to the north pole. In order to be more
27938 precise, the definition was adjusted several times, and now a meter is
27939 defined as the distance that light will travel in a vacuum in
27940 1/299792458 of a second; consequently, the speed of light in a
27941 vacuum is exactly 299792458 m/s. Many other units have been
27942 redefined in terms of fundamental physical processes; a second, for
27943 example, is currently defined as 9192631770 periods of a certain
27944 radiation related to the cesium-133 atom. The only SI unit that is not
27945 based on a fundamental physical process (although there are efforts to
27946 change this) is the kilogram, which was originally defined as the mass
27947 of one liter of water, but is now defined as the mass of the
27948 International Prototype Kilogram (IPK), a cylinder of platinum-iridium
27949 kept at the Bureau International des Poids et Mesures in S@`evres,
27950 France. (There are several copies of the IPK throughout the world.)
27951 The British imperial units, once defined in terms of physical objects,
27952 were redefined in 1963 in terms of SI units. The US customary units,
27953 which were the same as British units until the British imperial system
27954 was created in 1824, were also defined in terms of the SI units in 1893.
27955 Because of these redefinitions, conversions between metric, British
27956 Imperial, and US customary units can often be done precisely.
27958 Since the exact definitions of many kinds of units have evolved over the
27959 years, and since certain countries sometimes have local differences in
27960 their definitions, it is a good idea to examine Calc's definition of a
27961 unit before depending on its exact value. For example, there are three
27962 different units for gallons, corresponding to the US (@code{gal}),
27963 Canadian (@code{galC}), and British (@code{galUK}) definitions. Also,
27964 note that @code{oz} is a standard ounce of mass, @code{ozt} is a Troy
27965 ounce, and @code{ozfl} is a fluid ounce.
27967 The temperature units corresponding to degrees Kelvin and Centigrade
27968 (Celsius) are the same in this table, since most units commands treat
27969 temperatures as being relative. The @code{calc-convert-temperature}
27970 command has special rules for handling the different absolute magnitudes
27971 of the various temperature scales.
27973 The unit of volume ``liters'' can be referred to by either the lower-case
27974 @code{l} or the upper-case @code{L}.
27976 The unit @code{A} stands for Amperes; the name @code{Ang} is used
27984 The unit @code{pt} stands for pints; the name @code{point} stands for
27985 a typographical point, defined by @samp{72 point = 1 in}. This is
27986 slightly different than the point defined by the American Typefounder's
27987 Association in 1886, but the point used by Calc has become standard
27988 largely due to its use by the PostScript page description language.
27989 There is also @code{texpt}, which stands for a printer's point as
27990 defined by the @TeX{} typesetting system: @samp{72.27 texpt = 1 in}.
27991 Other units used by @TeX{} are available; they are @code{texpc} (a pica),
27992 @code{texbp} (a ``big point'', equal to a standard point which is larger
27993 than the point used by @TeX{}), @code{texdd} (a Didot point),
27994 @code{texcc} (a Cicero) and @code{texsp} (a scaled @TeX{} point,
27995 all dimensions representable in @TeX{} are multiples of this value).
27997 When Calc is using the @TeX{} or La@TeX{} language mode (@pxref{TeX
27998 and LaTeX Language Modes}), the @TeX{} specific unit names will not
27999 use the @samp{tex} prefix; the unit name for a @TeX{} point will be
28000 @samp{pt} instead of @samp{texpt}, for example. To avoid conflicts,
28001 the unit names for pint and parsec will simply be @samp{pint} and
28002 @samp{parsec} instead of @samp{pt} and @samp{pc}.
28005 The unit @code{e} stands for the elementary (electron) unit of charge;
28006 because algebra command could mistake this for the special constant
28007 @expr{e}, Calc provides the alternate unit name @code{ech} which is
28008 preferable to @code{e}.
28010 The name @code{g} stands for one gram of mass; there is also @code{gf},
28011 one gram of force. (Likewise for @kbd{lb}, pounds, and @kbd{lbf}.)
28012 Meanwhile, one ``@expr{g}'' of acceleration is denoted @code{ga}.
28014 The unit @code{ton} is a U.S. ton of @samp{2000 lb}, and @code{t} is
28015 a metric ton of @samp{1000 kg}.
28017 The names @code{s} (or @code{sec}) and @code{min} refer to units of
28018 time; @code{arcsec} and @code{arcmin} are units of angle.
28020 Some ``units'' are really physical constants; for example, @code{c}
28021 represents the speed of light, and @code{h} represents Planck's
28022 constant. You can use these just like other units: converting
28023 @samp{.5 c} to @samp{m/s} expresses one-half the speed of light in
28024 meters per second. You can also use this merely as a handy reference;
28025 the @kbd{u g} command gets the definition of one of these constants
28026 in its normal terms, and @kbd{u b} expresses the definition in base
28029 Two units, @code{pi} and @code{alpha} (the fine structure constant,
28030 approximately @mathit{1/137}) are dimensionless. The units simplification
28031 commands simply treat these names as equivalent to their corresponding
28032 values. However you can, for example, use @kbd{u c} to convert a pure
28033 number into multiples of the fine structure constant, or @kbd{u b} to
28034 convert this back into a pure number. (When @kbd{u c} prompts for the
28035 ``old units,'' just enter a blank line to signify that the value
28036 really is unitless.)
28038 @c Describe angular units, luminosity vs. steradians problem.
28040 @node User-Defined Units, , Predefined Units, Units
28041 @section User-Defined Units
28044 Calc provides ways to get quick access to your selected ``favorite''
28045 units, as well as ways to define your own new units.
28048 @pindex calc-quick-units
28050 @cindex @code{Units} variable
28051 @cindex Quick units
28052 To select your favorite units, store a vector of unit names or
28053 expressions in the Calc variable @code{Units}. The @kbd{u 1}
28054 through @kbd{u 9} commands (@code{calc-quick-units}) provide access
28055 to these units. If the value on the top of the stack is a plain
28056 number (with no units attached), then @kbd{u 1} gives it the
28057 specified units. (Basically, it multiplies the number by the
28058 first item in the @code{Units} vector.) If the number on the
28059 stack @emph{does} have units, then @kbd{u 1} converts that number
28060 to the new units. For example, suppose the vector @samp{[in, ft]}
28061 is stored in @code{Units}. Then @kbd{30 u 1} will create the
28062 expression @samp{30 in}, and @kbd{u 2} will convert that expression
28065 The @kbd{u 0} command accesses the tenth element of @code{Units}.
28066 Only ten quick units may be defined at a time. If the @code{Units}
28067 variable has no stored value (the default), or if its value is not
28068 a vector, then the quick-units commands will not function. The
28069 @kbd{s U} command is a convenient way to edit the @code{Units}
28070 variable; @pxref{Operations on Variables}.
28073 @pindex calc-define-unit
28074 @cindex User-defined units
28075 The @kbd{u d} (@code{calc-define-unit}) command records the units
28076 expression on the top of the stack as the definition for a new,
28077 user-defined unit. For example, putting @samp{16.5 ft} on the stack and
28078 typing @kbd{u d rod} defines the new unit @samp{rod} to be equivalent to
28079 16.5 feet. The unit conversion and simplification commands will now
28080 treat @code{rod} just like any other unit of length. You will also be
28081 prompted for an optional English description of the unit, which will
28082 appear in the Units Table. If you wish the definition of this unit to
28083 be displayed in a special way in the Units Table buffer (such as with an
28084 asterisk to indicate an approximate value), then you can call this
28085 command with an argument, @kbd{C-u u d}; you will then also be prompted
28086 for a string that will be used to display the definition.
28089 @pindex calc-undefine-unit
28090 The @kbd{u u} (@code{calc-undefine-unit}) command removes a user-defined
28091 unit. It is not possible to remove one of the predefined units,
28094 If you define a unit with an existing unit name, your new definition
28095 will replace the original definition of that unit. If the unit was a
28096 predefined unit, the old definition will not be replaced, only
28097 ``shadowed.'' The built-in definition will reappear if you later use
28098 @kbd{u u} to remove the shadowing definition.
28100 To create a new fundamental unit, use either 1 or the unit name itself
28101 as the defining expression. Otherwise the expression can involve any
28102 other units that you like (except for composite units like @samp{mfi}).
28103 You can create a new composite unit with a sum of other units as the
28104 defining expression. The next unit operation like @kbd{u c} or @kbd{u v}
28105 will rebuild the internal unit table incorporating your modifications.
28106 Note that erroneous definitions (such as two units defined in terms of
28107 each other) will not be detected until the unit table is next rebuilt;
28108 @kbd{u v} is a convenient way to force this to happen.
28110 Temperature units are treated specially inside the Calculator; it is not
28111 possible to create user-defined temperature units.
28114 @pindex calc-permanent-units
28115 @cindex Calc init file, user-defined units
28116 The @kbd{u p} (@code{calc-permanent-units}) command stores the user-defined
28117 units in your Calc init file (the file given by the variable
28118 @code{calc-settings-file}, typically @file{~/.emacs.d/calc.el}), so that the
28119 units will still be available in subsequent Emacs sessions. If there
28120 was already a set of user-defined units in your Calc init file, it
28121 is replaced by the new set. (@xref{General Mode Commands}, for a way to
28122 tell Calc to use a different file for the Calc init file.)
28124 @node Store and Recall, Graphics, Units, Top
28125 @chapter Storing and Recalling
28128 Calculator variables are really just Lisp variables that contain numbers
28129 or formulas in a form that Calc can understand. The commands in this
28130 section allow you to manipulate variables conveniently. Commands related
28131 to variables use the @kbd{s} prefix key.
28134 * Storing Variables::
28135 * Recalling Variables::
28136 * Operations on Variables::
28138 * Evaluates-To Operator::
28141 @node Storing Variables, Recalling Variables, Store and Recall, Store and Recall
28142 @section Storing Variables
28147 @cindex Storing variables
28148 @cindex Quick variables
28151 The @kbd{s s} (@code{calc-store}) command stores the value at the top of
28152 the stack into a specified variable. It prompts you to enter the
28153 name of the variable. If you press a single digit, the value is stored
28154 immediately in one of the ``quick'' variables @code{q0} through
28155 @code{q9}. Or you can enter any variable name.
28158 @pindex calc-store-into
28159 The @kbd{s s} command leaves the stored value on the stack. There is
28160 also an @kbd{s t} (@code{calc-store-into}) command, which removes a
28161 value from the stack and stores it in a variable.
28163 If the top of stack value is an equation @samp{a = 7} or assignment
28164 @samp{a := 7} with a variable on the lefthand side, then Calc will
28165 assign that variable with that value by default, i.e., if you type
28166 @kbd{s s @key{RET}} or @kbd{s t @key{RET}}. In this example, the
28167 value 7 would be stored in the variable @samp{a}. (If you do type
28168 a variable name at the prompt, the top-of-stack value is stored in
28169 its entirety, even if it is an equation: @samp{s s b @key{RET}}
28170 with @samp{a := 7} on the stack stores @samp{a := 7} in @code{b}.)
28172 In fact, the top of stack value can be a vector of equations or
28173 assignments with different variables on their lefthand sides; the
28174 default will be to store all the variables with their corresponding
28175 righthand sides simultaneously.
28177 It is also possible to type an equation or assignment directly at
28178 the prompt for the @kbd{s s} or @kbd{s t} command: @kbd{s s foo = 7}.
28179 In this case the expression to the right of the @kbd{=} or @kbd{:=}
28180 symbol is evaluated as if by the @kbd{=} command, and that value is
28181 stored in the variable. No value is taken from the stack; @kbd{s s}
28182 and @kbd{s t} are equivalent when used in this way.
28186 The prefix keys @kbd{s} and @kbd{t} may be followed immediately by a
28187 digit; @kbd{s 9} is equivalent to @kbd{s s 9}, and @kbd{t 9} is
28188 equivalent to @kbd{s t 9}. (The @kbd{t} prefix is otherwise used
28189 for trail and time/date commands.)
28225 @pindex calc-store-plus
28226 @pindex calc-store-minus
28227 @pindex calc-store-times
28228 @pindex calc-store-div
28229 @pindex calc-store-power
28230 @pindex calc-store-concat
28231 @pindex calc-store-neg
28232 @pindex calc-store-inv
28233 @pindex calc-store-decr
28234 @pindex calc-store-incr
28235 There are also several ``arithmetic store'' commands. For example,
28236 @kbd{s +} removes a value from the stack and adds it to the specified
28237 variable. The other arithmetic stores are @kbd{s -}, @kbd{s *}, @kbd{s /},
28238 @kbd{s ^}, and @w{@kbd{s |}} (vector concatenation), plus @kbd{s n} and
28239 @kbd{s &} which negate or invert the value in a variable, and @w{@kbd{s [}}
28240 and @kbd{s ]} which decrease or increase a variable by one.
28242 All the arithmetic stores accept the Inverse prefix to reverse the
28243 order of the operands. If @expr{v} represents the contents of the
28244 variable, and @expr{a} is the value drawn from the stack, then regular
28245 @w{@kbd{s -}} assigns
28246 @texline @math{v \coloneq v - a},
28247 @infoline @expr{v := v - a},
28248 but @kbd{I s -} assigns
28249 @texline @math{v \coloneq a - v}.
28250 @infoline @expr{v := a - v}.
28251 While @kbd{I s *} might seem pointless, it is
28252 useful if matrix multiplication is involved. Actually, all the
28253 arithmetic stores use formulas designed to behave usefully both
28254 forwards and backwards:
28258 s + v := v + a v := a + v
28259 s - v := v - a v := a - v
28260 s * v := v * a v := a * v
28261 s / v := v / a v := a / v
28262 s ^ v := v ^ a v := a ^ v
28263 s | v := v | a v := a | v
28264 s n v := v / (-1) v := (-1) / v
28265 s & v := v ^ (-1) v := (-1) ^ v
28266 s [ v := v - 1 v := 1 - v
28267 s ] v := v - (-1) v := (-1) - v
28271 In the last four cases, a numeric prefix argument will be used in
28272 place of the number one. (For example, @kbd{M-2 s ]} increases
28273 a variable by 2, and @kbd{M-2 I s ]} replaces a variable by
28274 minus-two minus the variable.
28276 The first six arithmetic stores can also be typed @kbd{s t +}, @kbd{s t -},
28277 etc. The commands @kbd{s s +}, @kbd{s s -}, and so on are analogous
28278 arithmetic stores that don't remove the value @expr{a} from the stack.
28280 All arithmetic stores report the new value of the variable in the
28281 Trail for your information. They signal an error if the variable
28282 previously had no stored value. If default simplifications have been
28283 turned off, the arithmetic stores temporarily turn them on for numeric
28284 arguments only (i.e., they temporarily do an @kbd{m N} command).
28285 @xref{Simplification Modes}. Large vectors put in the trail by
28286 these commands always use abbreviated (@kbd{t .}) mode.
28289 @pindex calc-store-map
28290 The @kbd{s m} command is a general way to adjust a variable's value
28291 using any Calc function. It is a ``mapping'' command analogous to
28292 @kbd{V M}, @kbd{V R}, etc. @xref{Reducing and Mapping}, to see
28293 how to specify a function for a mapping command. Basically,
28294 all you do is type the Calc command key that would invoke that
28295 function normally. For example, @kbd{s m n} applies the @kbd{n}
28296 key to negate the contents of the variable, so @kbd{s m n} is
28297 equivalent to @kbd{s n}. Also, @kbd{s m Q} takes the square root
28298 of the value stored in a variable, @kbd{s m v v} uses @kbd{v v} to
28299 reverse the vector stored in the variable, and @kbd{s m H I S}
28300 takes the hyperbolic arcsine of the variable contents.
28302 If the mapping function takes two or more arguments, the additional
28303 arguments are taken from the stack; the old value of the variable
28304 is provided as the first argument. Thus @kbd{s m -} with @expr{a}
28305 on the stack computes @expr{v - a}, just like @kbd{s -}. With the
28306 Inverse prefix, the variable's original value becomes the @emph{last}
28307 argument instead of the first. Thus @kbd{I s m -} is also
28308 equivalent to @kbd{I s -}.
28311 @pindex calc-store-exchange
28312 The @kbd{s x} (@code{calc-store-exchange}) command exchanges the value
28313 of a variable with the value on the top of the stack. Naturally, the
28314 variable must already have a stored value for this to work.
28316 You can type an equation or assignment at the @kbd{s x} prompt. The
28317 command @kbd{s x a=6} takes no values from the stack; instead, it
28318 pushes the old value of @samp{a} on the stack and stores @samp{a = 6}.
28321 @pindex calc-unstore
28322 @cindex Void variables
28323 @cindex Un-storing variables
28324 Until you store something in them, most variables are ``void,'' that is,
28325 they contain no value at all. If they appear in an algebraic formula
28326 they will be left alone even if you press @kbd{=} (@code{calc-evaluate}).
28327 The @kbd{s u} (@code{calc-unstore}) command returns a variable to the
28331 @pindex calc-copy-variable
28332 The @kbd{s c} (@code{calc-copy-variable}) command copies the stored
28333 value of one variable to another. One way it differs from a simple
28334 @kbd{s r} followed by an @kbd{s t} (aside from saving keystrokes) is
28335 that the value never goes on the stack and thus is never rounded,
28336 evaluated, or simplified in any way; it is not even rounded down to the
28339 The only variables with predefined values are the ``special constants''
28340 @code{pi}, @code{e}, @code{i}, @code{phi}, and @code{gamma}. You are free
28341 to unstore these variables or to store new values into them if you like,
28342 although some of the algebraic-manipulation functions may assume these
28343 variables represent their standard values. Calc displays a warning if
28344 you change the value of one of these variables, or of one of the other
28345 special variables @code{inf}, @code{uinf}, and @code{nan} (which are
28348 Note that @code{pi} doesn't actually have 3.14159265359 stored in it,
28349 but rather a special magic value that evaluates to @cpi{} at the current
28350 precision. Likewise @code{e}, @code{i}, and @code{phi} evaluate
28351 according to the current precision or polar mode. If you recall a value
28352 from @code{pi} and store it back, this magic property will be lost. The
28353 magic property is preserved, however, when a variable is copied with
28357 @pindex calc-copy-special-constant
28358 If one of the ``special constants'' is redefined (or undefined) so that
28359 it no longer has its magic property, the property can be restored with
28360 @kbd{s k} (@code{calc-copy-special-constant}). This command will prompt
28361 for a special constant and a variable to store it in, and so a special
28362 constant can be stored in any variable. Here, the special constant that
28363 you enter doesn't depend on the value of the corresponding variable;
28364 @code{pi} will represent 3.14159@dots{} regardless of what is currently
28365 stored in the Calc variable @code{pi}. If one of the other special
28366 variables, @code{inf}, @code{uinf} or @code{nan}, is given a value, its
28367 original behavior can be restored by voiding it with @kbd{s u}.
28369 @node Recalling Variables, Operations on Variables, Storing Variables, Store and Recall
28370 @section Recalling Variables
28374 @pindex calc-recall
28375 @cindex Recalling variables
28376 The most straightforward way to extract the stored value from a variable
28377 is to use the @kbd{s r} (@code{calc-recall}) command. This command prompts
28378 for a variable name (similarly to @code{calc-store}), looks up the value
28379 of the specified variable, and pushes that value onto the stack. It is
28380 an error to try to recall a void variable.
28382 It is also possible to recall the value from a variable by evaluating a
28383 formula containing that variable. For example, @kbd{' a @key{RET} =} is
28384 the same as @kbd{s r a @key{RET}} except that if the variable is void, the
28385 former will simply leave the formula @samp{a} on the stack whereas the
28386 latter will produce an error message.
28389 The @kbd{r} prefix may be followed by a digit, so that @kbd{r 9} is
28390 equivalent to @kbd{s r 9}.
28392 @node Operations on Variables, Let Command, Recalling Variables, Store and Recall
28393 @section Other Operations on Variables
28397 @pindex calc-edit-variable
28398 The @kbd{s e} (@code{calc-edit-variable}) command edits the stored
28399 value of a variable without ever putting that value on the stack
28400 or simplifying or evaluating the value. It prompts for the name of
28401 the variable to edit. If the variable has no stored value, the
28402 editing buffer will start out empty. If the editing buffer is
28403 empty when you press @kbd{C-c C-c} to finish, the variable will
28404 be made void. @xref{Editing Stack Entries}, for a general
28405 description of editing.
28407 The @kbd{s e} command is especially useful for creating and editing
28408 rewrite rules which are stored in variables. Sometimes these rules
28409 contain formulas which must not be evaluated until the rules are
28410 actually used. (For example, they may refer to @samp{deriv(x,y)},
28411 where @code{x} will someday become some expression involving @code{y};
28412 if you let Calc evaluate the rule while you are defining it, Calc will
28413 replace @samp{deriv(x,y)} with 0 because the formula @code{x} does
28414 not itself refer to @code{y}.) By contrast, recalling the variable,
28415 editing with @kbd{`}, and storing will evaluate the variable's value
28416 as a side effect of putting the value on the stack.
28464 @pindex calc-store-AlgSimpRules
28465 @pindex calc-store-Decls
28466 @pindex calc-store-EvalRules
28467 @pindex calc-store-FitRules
28468 @pindex calc-store-GenCount
28469 @pindex calc-store-Holidays
28470 @pindex calc-store-IntegLimit
28471 @pindex calc-store-LineStyles
28472 @pindex calc-store-PointStyles
28473 @pindex calc-store-PlotRejects
28474 @pindex calc-store-TimeZone
28475 @pindex calc-store-Units
28476 @pindex calc-store-ExtSimpRules
28477 There are several special-purpose variable-editing commands that
28478 use the @kbd{s} prefix followed by a shifted letter:
28482 Edit @code{AlgSimpRules}. @xref{Algebraic Simplifications}.
28484 Edit @code{Decls}. @xref{Declarations}.
28486 Edit @code{EvalRules}. @xref{Default Simplifications}.
28488 Edit @code{FitRules}. @xref{Curve Fitting}.
28490 Edit @code{GenCount}. @xref{Solving Equations}.
28492 Edit @code{Holidays}. @xref{Business Days}.
28494 Edit @code{IntegLimit}. @xref{Calculus}.
28496 Edit @code{LineStyles}. @xref{Graphics}.
28498 Edit @code{PointStyles}. @xref{Graphics}.
28500 Edit @code{PlotRejects}. @xref{Graphics}.
28502 Edit @code{TimeZone}. @xref{Time Zones}.
28504 Edit @code{Units}. @xref{User-Defined Units}.
28506 Edit @code{ExtSimpRules}. @xref{Unsafe Simplifications}.
28509 These commands are just versions of @kbd{s e} that use fixed variable
28510 names rather than prompting for the variable name.
28513 @pindex calc-permanent-variable
28514 @cindex Storing variables
28515 @cindex Permanent variables
28516 @cindex Calc init file, variables
28517 The @kbd{s p} (@code{calc-permanent-variable}) command saves a
28518 variable's value permanently in your Calc init file (the file given by
28519 the variable @code{calc-settings-file}, typically @file{~/.emacs.d/calc.el}), so
28520 that its value will still be available in future Emacs sessions. You
28521 can re-execute @w{@kbd{s p}} later on to update the saved value, but the
28522 only way to remove a saved variable is to edit your calc init file
28523 by hand. (@xref{General Mode Commands}, for a way to tell Calc to
28524 use a different file for the Calc init file.)
28526 If you do not specify the name of a variable to save (i.e.,
28527 @kbd{s p @key{RET}}), all Calc variables with defined values
28528 are saved except for the special constants @code{pi}, @code{e},
28529 @code{i}, @code{phi}, and @code{gamma}; the variables @code{TimeZone}
28530 and @code{PlotRejects};
28531 @code{FitRules}, @code{DistribRules}, and other built-in rewrite
28532 rules; and @code{PlotData@var{n}} variables generated
28533 by the graphics commands. (You can still save these variables by
28534 explicitly naming them in an @kbd{s p} command.)
28537 @pindex calc-insert-variables
28538 The @kbd{s i} (@code{calc-insert-variables}) command writes
28539 the values of all Calc variables into a specified buffer.
28540 The variables are written with the prefix @code{var-} in the form of
28541 Lisp @code{setq} commands
28542 which store the values in string form. You can place these commands
28543 in your Calc init file (or @file{.emacs}) if you wish, though in this case it
28544 would be easier to use @kbd{s p @key{RET}}. (Note that @kbd{s i}
28545 omits the same set of variables as @w{@kbd{s p @key{RET}}}; the difference
28546 is that @kbd{s i} will store the variables in any buffer, and it also
28547 stores in a more human-readable format.)
28549 @node Let Command, Evaluates-To Operator, Operations on Variables, Store and Recall
28550 @section The Let Command
28555 @cindex Variables, temporary assignment
28556 @cindex Temporary assignment to variables
28557 If you have an expression like @samp{a+b^2} on the stack and you wish to
28558 compute its value where @expr{b=3}, you can simply store 3 in @expr{b} and
28559 then press @kbd{=} to reevaluate the formula. This has the side-effect
28560 of leaving the stored value of 3 in @expr{b} for future operations.
28562 The @kbd{s l} (@code{calc-let}) command evaluates a formula under a
28563 @emph{temporary} assignment of a variable. It stores the value on the
28564 top of the stack into the specified variable, then evaluates the
28565 second-to-top stack entry, then restores the original value (or lack of one)
28566 in the variable. Thus after @kbd{'@w{ }a+b^2 @key{RET} 3 s l b @key{RET}},
28567 the stack will contain the formula @samp{a + 9}. The subsequent command
28568 @kbd{@w{5 s l a} @key{RET}} will replace this formula with the number 14.
28569 The variables @samp{a} and @samp{b} are not permanently affected in any way
28572 The value on the top of the stack may be an equation or assignment, or
28573 a vector of equations or assignments, in which case the default will be
28574 analogous to the case of @kbd{s t @key{RET}}. @xref{Storing Variables}.
28576 Also, you can answer the variable-name prompt with an equation or
28577 assignment: @kbd{s l b=3 @key{RET}} is the same as storing 3 on the stack
28578 and typing @kbd{s l b @key{RET}}.
28580 The @kbd{a b} (@code{calc-substitute}) command is another way to substitute
28581 a variable with a value in a formula. It does an actual substitution
28582 rather than temporarily assigning the variable and evaluating. For
28583 example, letting @expr{n=2} in @samp{f(n pi)} with @kbd{a b} will
28584 produce @samp{f(2 pi)}, whereas @kbd{s l} would give @samp{f(6.28)}
28585 since the evaluation step will also evaluate @code{pi}.
28587 @node Evaluates-To Operator, , Let Command, Store and Recall
28588 @section The Evaluates-To Operator
28593 @cindex Evaluates-to operator
28594 @cindex @samp{=>} operator
28595 The special algebraic symbol @samp{=>} is known as the @dfn{evaluates-to
28596 operator}. (It will show up as an @code{evalto} function call in
28597 other language modes like Pascal and La@TeX{}.) This is a binary
28598 operator, that is, it has a lefthand and a righthand argument,
28599 although it can be entered with the righthand argument omitted.
28601 A formula like @samp{@var{a} => @var{b}} is evaluated by Calc as
28602 follows: First, @var{a} is not simplified or modified in any
28603 way. The previous value of argument @var{b} is thrown away; the
28604 formula @var{a} is then copied and evaluated as if by the @kbd{=}
28605 command according to all current modes and stored variable values,
28606 and the result is installed as the new value of @var{b}.
28608 For example, suppose you enter the algebraic formula @samp{2 + 3 => 17}.
28609 The number 17 is ignored, and the lefthand argument is left in its
28610 unevaluated form; the result is the formula @samp{2 + 3 => 5}.
28613 @pindex calc-evalto
28614 You can enter an @samp{=>} formula either directly using algebraic
28615 entry (in which case the righthand side may be omitted since it is
28616 going to be replaced right away anyhow), or by using the @kbd{s =}
28617 (@code{calc-evalto}) command, which takes @var{a} from the stack
28618 and replaces it with @samp{@var{a} => @var{b}}.
28620 Calc keeps track of all @samp{=>} operators on the stack, and
28621 recomputes them whenever anything changes that might affect their
28622 values, i.e., a mode setting or variable value. This occurs only
28623 if the @samp{=>} operator is at the top level of the formula, or
28624 if it is part of a top-level vector. In other words, pushing
28625 @samp{2 + (a => 17)} will change the 17 to the actual value of
28626 @samp{a} when you enter the formula, but the result will not be
28627 dynamically updated when @samp{a} is changed later because the
28628 @samp{=>} operator is buried inside a sum. However, a vector
28629 of @samp{=>} operators will be recomputed, since it is convenient
28630 to push a vector like @samp{[a =>, b =>, c =>]} on the stack to
28631 make a concise display of all the variables in your problem.
28632 (Another way to do this would be to use @samp{[a, b, c] =>},
28633 which provides a slightly different format of display. You
28634 can use whichever you find easiest to read.)
28637 @pindex calc-auto-recompute
28638 The @kbd{m C} (@code{calc-auto-recompute}) command allows you to
28639 turn this automatic recomputation on or off. If you turn
28640 recomputation off, you must explicitly recompute an @samp{=>}
28641 operator on the stack in one of the usual ways, such as by
28642 pressing @kbd{=}. Turning recomputation off temporarily can save
28643 a lot of time if you will be changing several modes or variables
28644 before you look at the @samp{=>} entries again.
28646 Most commands are not especially useful with @samp{=>} operators
28647 as arguments. For example, given @samp{x + 2 => 17}, it won't
28648 work to type @kbd{1 +} to get @samp{x + 3 => 18}. If you want
28649 to operate on the lefthand side of the @samp{=>} operator on
28650 the top of the stack, type @kbd{j 1} (that's the digit ``one'')
28651 to select the lefthand side, execute your commands, then type
28652 @kbd{j u} to unselect.
28654 All current modes apply when an @samp{=>} operator is computed,
28655 including the current simplification mode. Recall that the
28656 formula @samp{x + y + x} is not handled by Calc's default
28657 simplifications, but the @kbd{a s} command will reduce it to
28658 the simpler form @samp{y + 2 x}. You can also type @kbd{m A}
28659 to enable an Algebraic Simplification mode in which the
28660 equivalent of @kbd{a s} is used on all of Calc's results.
28661 If you enter @samp{x + y + x =>} normally, the result will
28662 be @samp{x + y + x => x + y + x}. If you change to
28663 Algebraic Simplification mode, the result will be
28664 @samp{x + y + x => y + 2 x}. However, just pressing @kbd{a s}
28665 once will have no effect on @samp{x + y + x => x + y + x},
28666 because the righthand side depends only on the lefthand side
28667 and the current mode settings, and the lefthand side is not
28668 affected by commands like @kbd{a s}.
28670 The ``let'' command (@kbd{s l}) has an interesting interaction
28671 with the @samp{=>} operator. The @kbd{s l} command evaluates the
28672 second-to-top stack entry with the top stack entry supplying
28673 a temporary value for a given variable. As you might expect,
28674 if that stack entry is an @samp{=>} operator its righthand
28675 side will temporarily show this value for the variable. In
28676 fact, all @samp{=>}s on the stack will be updated if they refer
28677 to that variable. But this change is temporary in the sense
28678 that the next command that causes Calc to look at those stack
28679 entries will make them revert to the old variable value.
28683 2: a => a 2: a => 17 2: a => a
28684 1: a + 1 => a + 1 1: a + 1 => 18 1: a + 1 => a + 1
28687 17 s l a @key{RET} p 8 @key{RET}
28691 Here the @kbd{p 8} command changes the current precision,
28692 thus causing the @samp{=>} forms to be recomputed after the
28693 influence of the ``let'' is gone. The @kbd{d @key{SPC}} command
28694 (@code{calc-refresh}) is a handy way to force the @samp{=>}
28695 operators on the stack to be recomputed without any other
28699 @pindex calc-assign
28702 Embedded mode also uses @samp{=>} operators. In Embedded mode,
28703 the lefthand side of an @samp{=>} operator can refer to variables
28704 assigned elsewhere in the file by @samp{:=} operators. The
28705 assignment operator @samp{a := 17} does not actually do anything
28706 by itself. But Embedded mode recognizes it and marks it as a sort
28707 of file-local definition of the variable. You can enter @samp{:=}
28708 operators in Algebraic mode, or by using the @kbd{s :}
28709 (@code{calc-assign}) [@code{assign}] command which takes a variable
28710 and value from the stack and replaces them with an assignment.
28712 @xref{TeX and LaTeX Language Modes}, for the way @samp{=>} appears in
28713 @TeX{} language output. The @dfn{eqn} mode gives similar
28714 treatment to @samp{=>}.
28716 @node Graphics, Kill and Yank, Store and Recall, Top
28720 The commands for graphing data begin with the @kbd{g} prefix key. Calc
28721 uses GNUPLOT 2.0 or later to do graphics. These commands will only work
28722 if GNUPLOT is available on your system. (While GNUPLOT sounds like
28723 a relative of GNU Emacs, it is actually completely unrelated.
28724 However, it is free software. It can be obtained from
28725 @samp{http://www.gnuplot.info}.)
28727 @vindex calc-gnuplot-name
28728 If you have GNUPLOT installed on your system but Calc is unable to
28729 find it, you may need to set the @code{calc-gnuplot-name} variable in
28730 your Calc init file or @file{.emacs}. You may also need to set some
28731 Lisp variables to show Calc how to run GNUPLOT on your system; these
28732 are described under @kbd{g D} and @kbd{g O} below. If you are using
28733 the X window system or MS-Windows, Calc will configure GNUPLOT for you
28734 automatically. If you have GNUPLOT 3.0 or later and you are using a
28735 Unix or GNU system without X, Calc will configure GNUPLOT to display
28736 graphs using simple character graphics that will work on any
28737 Posix-compatible terminal.
28741 * Three Dimensional Graphics::
28742 * Managing Curves::
28743 * Graphics Options::
28747 @node Basic Graphics, Three Dimensional Graphics, Graphics, Graphics
28748 @section Basic Graphics
28752 @pindex calc-graph-fast
28753 The easiest graphics command is @kbd{g f} (@code{calc-graph-fast}).
28754 This command takes two vectors of equal length from the stack.
28755 The vector at the top of the stack represents the ``y'' values of
28756 the various data points. The vector in the second-to-top position
28757 represents the corresponding ``x'' values. This command runs
28758 GNUPLOT (if it has not already been started by previous graphing
28759 commands) and displays the set of data points. The points will
28760 be connected by lines, and there will also be some kind of symbol
28761 to indicate the points themselves.
28763 The ``x'' entry may instead be an interval form, in which case suitable
28764 ``x'' values are interpolated between the minimum and maximum values of
28765 the interval (whether the interval is open or closed is ignored).
28767 The ``x'' entry may also be a number, in which case Calc uses the
28768 sequence of ``x'' values @expr{x}, @expr{x+1}, @expr{x+2}, etc.
28769 (Generally the number 0 or 1 would be used for @expr{x} in this case.)
28771 The ``y'' entry may be any formula instead of a vector. Calc effectively
28772 uses @kbd{N} (@code{calc-eval-num}) to evaluate variables in the formula;
28773 the result of this must be a formula in a single (unassigned) variable.
28774 The formula is plotted with this variable taking on the various ``x''
28775 values. Graphs of formulas by default use lines without symbols at the
28776 computed data points. Note that if neither ``x'' nor ``y'' is a vector,
28777 Calc guesses at a reasonable number of data points to use. See the
28778 @kbd{g N} command below. (The ``x'' values must be either a vector
28779 or an interval if ``y'' is a formula.)
28785 If ``y'' is (or evaluates to) a formula of the form
28786 @samp{xy(@var{x}, @var{y})} then the result is a
28787 parametric plot. The two arguments of the fictitious @code{xy} function
28788 are used as the ``x'' and ``y'' coordinates of the curve, respectively.
28789 In this case the ``x'' vector or interval you specified is not directly
28790 visible in the graph. For example, if ``x'' is the interval @samp{[0..360]}
28791 and ``y'' is the formula @samp{xy(sin(t), cos(t))}, the resulting graph
28794 Also, ``x'' and ``y'' may each be variable names, in which case Calc
28795 looks for suitable vectors, intervals, or formulas stored in those
28798 The ``x'' and ``y'' values for the data points (as pulled from the vectors,
28799 calculated from the formulas, or interpolated from the intervals) should
28800 be real numbers (integers, fractions, or floats). One exception to this
28801 is that the ``y'' entry can consist of a vector of numbers combined with
28802 error forms, in which case the points will be plotted with the
28803 appropriate error bars. Other than this, if either the ``x''
28804 value or the ``y'' value of a given data point is not a real number, that
28805 data point will be omitted from the graph. The points on either side
28806 of the invalid point will @emph{not} be connected by a line.
28808 See the documentation for @kbd{g a} below for a description of the way
28809 numeric prefix arguments affect @kbd{g f}.
28811 @cindex @code{PlotRejects} variable
28812 @vindex PlotRejects
28813 If you store an empty vector in the variable @code{PlotRejects}
28814 (i.e., @kbd{[ ] s t PlotRejects}), Calc will append information to
28815 this vector for every data point which was rejected because its
28816 ``x'' or ``y'' values were not real numbers. The result will be
28817 a matrix where each row holds the curve number, data point number,
28818 ``x'' value, and ``y'' value for a rejected data point.
28819 @xref{Evaluates-To Operator}, for a handy way to keep tabs on the
28820 current value of @code{PlotRejects}. @xref{Operations on Variables},
28821 for the @kbd{s R} command which is another easy way to examine
28822 @code{PlotRejects}.
28825 @pindex calc-graph-clear
28826 To clear the graphics display, type @kbd{g c} (@code{calc-graph-clear}).
28827 If the GNUPLOT output device is an X window, the window will go away.
28828 Effects on other kinds of output devices will vary. You don't need
28829 to use @kbd{g c} if you don't want to---if you give another @kbd{g f}
28830 or @kbd{g p} command later on, it will reuse the existing graphics
28831 window if there is one.
28833 @node Three Dimensional Graphics, Managing Curves, Basic Graphics, Graphics
28834 @section Three-Dimensional Graphics
28837 @pindex calc-graph-fast-3d
28838 The @kbd{g F} (@code{calc-graph-fast-3d}) command makes a three-dimensional
28839 graph. It works only if you have GNUPLOT 3.0 or later; with GNUPLOT 2.0,
28840 you will see a GNUPLOT error message if you try this command.
28842 The @kbd{g F} command takes three values from the stack, called ``x'',
28843 ``y'', and ``z'', respectively. As was the case for 2D graphs, there
28844 are several options for these values.
28846 In the first case, ``x'' and ``y'' are each vectors (not necessarily of
28847 the same length); either or both may instead be interval forms. The
28848 ``z'' value must be a matrix with the same number of rows as elements
28849 in ``x'', and the same number of columns as elements in ``y''. The
28850 result is a surface plot where
28851 @texline @math{z_{ij}}
28852 @infoline @expr{z_ij}
28853 is the height of the point
28854 at coordinate @expr{(x_i, y_j)} on the surface. The 3D graph will
28855 be displayed from a certain default viewpoint; you can change this
28856 viewpoint by adding a @samp{set view} to the @samp{*Gnuplot Commands*}
28857 buffer as described later. See the GNUPLOT documentation for a
28858 description of the @samp{set view} command.
28860 Each point in the matrix will be displayed as a dot in the graph,
28861 and these points will be connected by a grid of lines (@dfn{isolines}).
28863 In the second case, ``x'', ``y'', and ``z'' are all vectors of equal
28864 length. The resulting graph displays a 3D line instead of a surface,
28865 where the coordinates of points along the line are successive triplets
28866 of values from the input vectors.
28868 In the third case, ``x'' and ``y'' are vectors or interval forms, and
28869 ``z'' is any formula involving two variables (not counting variables
28870 with assigned values). These variables are sorted into alphabetical
28871 order; the first takes on values from ``x'' and the second takes on
28872 values from ``y'' to form a matrix of results that are graphed as a
28879 If the ``z'' formula evaluates to a call to the fictitious function
28880 @samp{xyz(@var{x}, @var{y}, @var{z})}, then the result is a
28881 ``parametric surface.'' In this case, the axes of the graph are
28882 taken from the @var{x} and @var{y} values in these calls, and the
28883 ``x'' and ``y'' values from the input vectors or intervals are used only
28884 to specify the range of inputs to the formula. For example, plotting
28885 @samp{[0..360], [0..180], xyz(sin(x)*sin(y), cos(x)*sin(y), cos(y))}
28886 will draw a sphere. (Since the default resolution for 3D plots is
28887 5 steps in each of ``x'' and ``y'', this will draw a very crude
28888 sphere. You could use the @kbd{g N} command, described below, to
28889 increase this resolution, or specify the ``x'' and ``y'' values as
28890 vectors with more than 5 elements.
28892 It is also possible to have a function in a regular @kbd{g f} plot
28893 evaluate to an @code{xyz} call. Since @kbd{g f} plots a line, not
28894 a surface, the result will be a 3D parametric line. For example,
28895 @samp{[[0..720], xyz(sin(x), cos(x), x)]} will plot two turns of a
28896 helix (a three-dimensional spiral).
28898 As for @kbd{g f}, each of ``x'', ``y'', and ``z'' may instead be
28899 variables containing the relevant data.
28901 @node Managing Curves, Graphics Options, Three Dimensional Graphics, Graphics
28902 @section Managing Curves
28905 The @kbd{g f} command is really shorthand for the following commands:
28906 @kbd{C-u g d g a g p}. Likewise, @w{@kbd{g F}} is shorthand for
28907 @kbd{C-u g d g A g p}. You can gain more control over your graph
28908 by using these commands directly.
28911 @pindex calc-graph-add
28912 The @kbd{g a} (@code{calc-graph-add}) command adds the ``curve''
28913 represented by the two values on the top of the stack to the current
28914 graph. You can have any number of curves in the same graph. When
28915 you give the @kbd{g p} command, all the curves will be drawn superimposed
28918 The @kbd{g a} command (and many others that affect the current graph)
28919 will cause a special buffer, @samp{*Gnuplot Commands*}, to be displayed
28920 in another window. This buffer is a template of the commands that will
28921 be sent to GNUPLOT when it is time to draw the graph. The first
28922 @kbd{g a} command adds a @code{plot} command to this buffer. Succeeding
28923 @kbd{g a} commands add extra curves onto that @code{plot} command.
28924 Other graph-related commands put other GNUPLOT commands into this
28925 buffer. In normal usage you never need to work with this buffer
28926 directly, but you can if you wish. The only constraint is that there
28927 must be only one @code{plot} command, and it must be the last command
28928 in the buffer. If you want to save and later restore a complete graph
28929 configuration, you can use regular Emacs commands to save and restore
28930 the contents of the @samp{*Gnuplot Commands*} buffer.
28934 If the values on the stack are not variable names, @kbd{g a} will invent
28935 variable names for them (of the form @samp{PlotData@var{n}}) and store
28936 the values in those variables. The ``x'' and ``y'' variables are what
28937 go into the @code{plot} command in the template. If you add a curve
28938 that uses a certain variable and then later change that variable, you
28939 can replot the graph without having to delete and re-add the curve.
28940 That's because the variable name, not the vector, interval or formula
28941 itself, is what was added by @kbd{g a}.
28943 A numeric prefix argument on @kbd{g a} or @kbd{g f} changes the way
28944 stack entries are interpreted as curves. With a positive prefix
28945 argument @expr{n}, the top @expr{n} stack entries are ``y'' values
28946 for @expr{n} different curves which share a common ``x'' value in
28947 the @expr{n+1}st stack entry. (Thus @kbd{g a} with no prefix
28948 argument is equivalent to @kbd{C-u 1 g a}.)
28950 A prefix of zero or plain @kbd{C-u} means to take two stack entries,
28951 ``x'' and ``y'' as usual, but to interpret ``y'' as a vector of
28952 ``y'' values for several curves that share a common ``x''.
28954 A negative prefix argument tells Calc to read @expr{n} vectors from
28955 the stack; each vector @expr{[x, y]} describes an independent curve.
28956 This is the only form of @kbd{g a} that creates several curves at once
28957 that don't have common ``x'' values. (Of course, the range of ``x''
28958 values covered by all the curves ought to be roughly the same if
28959 they are to look nice on the same graph.)
28961 For example, to plot
28962 @texline @math{\sin n x}
28963 @infoline @expr{sin(n x)}
28964 for integers @expr{n}
28965 from 1 to 5, you could use @kbd{v x} to create a vector of integers
28966 (@expr{n}), then @kbd{V M '} or @kbd{V M $} to map @samp{sin(n x)}
28967 across this vector. The resulting vector of formulas is suitable
28968 for use as the ``y'' argument to a @kbd{C-u g a} or @kbd{C-u g f}
28972 @pindex calc-graph-add-3d
28973 The @kbd{g A} (@code{calc-graph-add-3d}) command adds a 3D curve
28974 to the graph. It is not valid to intermix 2D and 3D curves in a
28975 single graph. This command takes three arguments, ``x'', ``y'',
28976 and ``z'', from the stack. With a positive prefix @expr{n}, it
28977 takes @expr{n+2} arguments (common ``x'' and ``y'', plus @expr{n}
28978 separate ``z''s). With a zero prefix, it takes three stack entries
28979 but the ``z'' entry is a vector of curve values. With a negative
28980 prefix @expr{-n}, it takes @expr{n} vectors of the form @expr{[x, y, z]}.
28981 The @kbd{g A} command works by adding a @code{splot} (surface-plot)
28982 command to the @samp{*Gnuplot Commands*} buffer.
28984 (Although @kbd{g a} adds a 2D @code{plot} command to the
28985 @samp{*Gnuplot Commands*} buffer, Calc changes this to @code{splot}
28986 before sending it to GNUPLOT if it notices that the data points are
28987 evaluating to @code{xyz} calls. It will not work to mix 2D and 3D
28988 @kbd{g a} curves in a single graph, although Calc does not currently
28992 @pindex calc-graph-delete
28993 The @kbd{g d} (@code{calc-graph-delete}) command deletes the most
28994 recently added curve from the graph. It has no effect if there are
28995 no curves in the graph. With a numeric prefix argument of any kind,
28996 it deletes all of the curves from the graph.
28999 @pindex calc-graph-hide
29000 The @kbd{g H} (@code{calc-graph-hide}) command ``hides'' or ``unhides''
29001 the most recently added curve. A hidden curve will not appear in
29002 the actual plot, but information about it such as its name and line and
29003 point styles will be retained.
29006 @pindex calc-graph-juggle
29007 The @kbd{g j} (@code{calc-graph-juggle}) command moves the curve
29008 at the end of the list (the ``most recently added curve'') to the
29009 front of the list. The next-most-recent curve is thus exposed for
29010 @w{@kbd{g d}} or similar commands to use. With @kbd{g j} you can work
29011 with any curve in the graph even though curve-related commands only
29012 affect the last curve in the list.
29015 @pindex calc-graph-plot
29016 The @kbd{g p} (@code{calc-graph-plot}) command uses GNUPLOT to draw
29017 the graph described in the @samp{*Gnuplot Commands*} buffer. Any
29018 GNUPLOT parameters which are not defined by commands in this buffer
29019 are reset to their default values. The variables named in the @code{plot}
29020 command are written to a temporary data file and the variable names
29021 are then replaced by the file name in the template. The resulting
29022 plotting commands are fed to the GNUPLOT program. See the documentation
29023 for the GNUPLOT program for more specific information. All temporary
29024 files are removed when Emacs or GNUPLOT exits.
29026 If you give a formula for ``y'', Calc will remember all the values that
29027 it calculates for the formula so that later plots can reuse these values.
29028 Calc throws out these saved values when you change any circumstances
29029 that may affect the data, such as switching from Degrees to Radians
29030 mode, or changing the value of a parameter in the formula. You can
29031 force Calc to recompute the data from scratch by giving a negative
29032 numeric prefix argument to @kbd{g p}.
29034 Calc uses a fairly rough step size when graphing formulas over intervals.
29035 This is to ensure quick response. You can ``refine'' a plot by giving
29036 a positive numeric prefix argument to @kbd{g p}. Calc goes through
29037 the data points it has computed and saved from previous plots of the
29038 function, and computes and inserts a new data point midway between
29039 each of the existing points. You can refine a plot any number of times,
29040 but beware that the amount of calculation involved doubles each time.
29042 Calc does not remember computed values for 3D graphs. This means the
29043 numerix prefix argument, if any, to @kbd{g p} is effectively ignored if
29044 the current graph is three-dimensional.
29047 @pindex calc-graph-print
29048 The @kbd{g P} (@code{calc-graph-print}) command is like @kbd{g p},
29049 except that it sends the output to a printer instead of to the
29050 screen. More precisely, @kbd{g p} looks for @samp{set terminal}
29051 or @samp{set output} commands in the @samp{*Gnuplot Commands*} buffer;
29052 lacking these it uses the default settings. However, @kbd{g P}
29053 ignores @samp{set terminal} and @samp{set output} commands and
29054 uses a different set of default values. All of these values are
29055 controlled by the @kbd{g D} and @kbd{g O} commands discussed below.
29056 Provided everything is set up properly, @kbd{g p} will plot to
29057 the screen unless you have specified otherwise and @kbd{g P} will
29058 always plot to the printer.
29060 @node Graphics Options, Devices, Managing Curves, Graphics
29061 @section Graphics Options
29065 @pindex calc-graph-grid
29066 The @kbd{g g} (@code{calc-graph-grid}) command turns the ``grid''
29067 on and off. It is off by default; tick marks appear only at the
29068 edges of the graph. With the grid turned on, dotted lines appear
29069 across the graph at each tick mark. Note that this command only
29070 changes the setting in @samp{*Gnuplot Commands*}; to see the effects
29071 of the change you must give another @kbd{g p} command.
29074 @pindex calc-graph-border
29075 The @kbd{g b} (@code{calc-graph-border}) command turns the border
29076 (the box that surrounds the graph) on and off. It is on by default.
29077 This command will only work with GNUPLOT 3.0 and later versions.
29080 @pindex calc-graph-key
29081 The @kbd{g k} (@code{calc-graph-key}) command turns the ``key''
29082 on and off. The key is a chart in the corner of the graph that
29083 shows the correspondence between curves and line styles. It is
29084 off by default, and is only really useful if you have several
29085 curves on the same graph.
29088 @pindex calc-graph-num-points
29089 The @kbd{g N} (@code{calc-graph-num-points}) command allows you
29090 to select the number of data points in the graph. This only affects
29091 curves where neither ``x'' nor ``y'' is specified as a vector.
29092 Enter a blank line to revert to the default value (initially 15).
29093 With no prefix argument, this command affects only the current graph.
29094 With a positive prefix argument this command changes or, if you enter
29095 a blank line, displays the default number of points used for all
29096 graphs created by @kbd{g a} that don't specify the resolution explicitly.
29097 With a negative prefix argument, this command changes or displays
29098 the default value (initially 5) used for 3D graphs created by @kbd{g A}.
29099 Note that a 3D setting of 5 means that a total of @expr{5^2 = 25} points
29100 will be computed for the surface.
29102 Data values in the graph of a function are normally computed to a
29103 precision of five digits, regardless of the current precision at the
29104 time. This is usually more than adequate, but there are cases where
29105 it will not be. For example, plotting @expr{1 + x} with @expr{x} in the
29106 interval @samp{[0 ..@: 1e-6]} will round all the data points down
29107 to 1.0! Putting the command @samp{set precision @var{n}} in the
29108 @samp{*Gnuplot Commands*} buffer will cause the data to be computed
29109 at precision @var{n} instead of 5. Since this is such a rare case,
29110 there is no keystroke-based command to set the precision.
29113 @pindex calc-graph-header
29114 The @kbd{g h} (@code{calc-graph-header}) command sets the title
29115 for the graph. This will show up centered above the graph.
29116 The default title is blank (no title).
29119 @pindex calc-graph-name
29120 The @kbd{g n} (@code{calc-graph-name}) command sets the title of an
29121 individual curve. Like the other curve-manipulating commands, it
29122 affects the most recently added curve, i.e., the last curve on the
29123 list in the @samp{*Gnuplot Commands*} buffer. To set the title of
29124 the other curves you must first juggle them to the end of the list
29125 with @kbd{g j}, or edit the @samp{*Gnuplot Commands*} buffer by hand.
29126 Curve titles appear in the key; if the key is turned off they are
29131 @pindex calc-graph-title-x
29132 @pindex calc-graph-title-y
29133 The @kbd{g t} (@code{calc-graph-title-x}) and @kbd{g T}
29134 (@code{calc-graph-title-y}) commands set the titles on the ``x''
29135 and ``y'' axes, respectively. These titles appear next to the
29136 tick marks on the left and bottom edges of the graph, respectively.
29137 Calc does not have commands to control the tick marks themselves,
29138 but you can edit them into the @samp{*Gnuplot Commands*} buffer if
29139 you wish. See the GNUPLOT documentation for details.
29143 @pindex calc-graph-range-x
29144 @pindex calc-graph-range-y
29145 The @kbd{g r} (@code{calc-graph-range-x}) and @kbd{g R}
29146 (@code{calc-graph-range-y}) commands set the range of values on the
29147 ``x'' and ``y'' axes, respectively. You are prompted to enter a
29148 suitable range. This should be either a pair of numbers of the
29149 form, @samp{@var{min}:@var{max}}, or a blank line to revert to the
29150 default behavior of setting the range based on the range of values
29151 in the data, or @samp{$} to take the range from the top of the stack.
29152 Ranges on the stack can be represented as either interval forms or
29153 vectors: @samp{[@var{min} ..@: @var{max}]} or @samp{[@var{min}, @var{max}]}.
29157 @pindex calc-graph-log-x
29158 @pindex calc-graph-log-y
29159 The @kbd{g l} (@code{calc-graph-log-x}) and @kbd{g L} (@code{calc-graph-log-y})
29160 commands allow you to set either or both of the axes of the graph to
29161 be logarithmic instead of linear.
29166 @pindex calc-graph-log-z
29167 @pindex calc-graph-range-z
29168 @pindex calc-graph-title-z
29169 For 3D plots, @kbd{g C-t}, @kbd{g C-r}, and @kbd{g C-l} (those are
29170 letters with the Control key held down) are the corresponding commands
29171 for the ``z'' axis.
29175 @pindex calc-graph-zero-x
29176 @pindex calc-graph-zero-y
29177 The @kbd{g z} (@code{calc-graph-zero-x}) and @kbd{g Z}
29178 (@code{calc-graph-zero-y}) commands control whether a dotted line is
29179 drawn to indicate the ``x'' and/or ``y'' zero axes. (These are the same
29180 dotted lines that would be drawn there anyway if you used @kbd{g g} to
29181 turn the ``grid'' feature on.) Zero-axis lines are on by default, and
29182 may be turned off only in GNUPLOT 3.0 and later versions. They are
29183 not available for 3D plots.
29186 @pindex calc-graph-line-style
29187 The @kbd{g s} (@code{calc-graph-line-style}) command turns the connecting
29188 lines on or off for the most recently added curve, and optionally selects
29189 the style of lines to be used for that curve. Plain @kbd{g s} simply
29190 toggles the lines on and off. With a numeric prefix argument, @kbd{g s}
29191 turns lines on and sets a particular line style. Line style numbers
29192 start at one and their meanings vary depending on the output device.
29193 GNUPLOT guarantees that there will be at least six different line styles
29194 available for any device.
29197 @pindex calc-graph-point-style
29198 The @kbd{g S} (@code{calc-graph-point-style}) command similarly turns
29199 the symbols at the data points on or off, or sets the point style.
29200 If you turn both lines and points off, the data points will show as
29201 tiny dots. If the ``y'' values being plotted contain error forms and
29202 the connecting lines are turned off, then this command will also turn
29203 the error bars on or off.
29205 @cindex @code{LineStyles} variable
29206 @cindex @code{PointStyles} variable
29208 @vindex PointStyles
29209 Another way to specify curve styles is with the @code{LineStyles} and
29210 @code{PointStyles} variables. These variables initially have no stored
29211 values, but if you store a vector of integers in one of these variables,
29212 the @kbd{g a} and @kbd{g f} commands will use those style numbers
29213 instead of the defaults for new curves that are added to the graph.
29214 An entry should be a positive integer for a specific style, or 0 to let
29215 the style be chosen automatically, or @mathit{-1} to turn off lines or points
29216 altogether. If there are more curves than elements in the vector, the
29217 last few curves will continue to have the default styles. Of course,
29218 you can later use @kbd{g s} and @kbd{g S} to change any of these styles.
29220 For example, @kbd{'[2 -1 3] @key{RET} s t LineStyles} causes the first curve
29221 to have lines in style number 2, the second curve to have no connecting
29222 lines, and the third curve to have lines in style 3. Point styles will
29223 still be assigned automatically, but you could store another vector in
29224 @code{PointStyles} to define them, too.
29226 @node Devices, , Graphics Options, Graphics
29227 @section Graphical Devices
29231 @pindex calc-graph-device
29232 The @kbd{g D} (@code{calc-graph-device}) command sets the device name
29233 (or ``terminal name'' in GNUPLOT lingo) to be used by @kbd{g p} commands
29234 on this graph. It does not affect the permanent default device name.
29235 If you enter a blank name, the device name reverts to the default.
29236 Enter @samp{?} to see a list of supported devices.
29238 With a positive numeric prefix argument, @kbd{g D} instead sets
29239 the default device name, used by all plots in the future which do
29240 not override it with a plain @kbd{g D} command. If you enter a
29241 blank line this command shows you the current default. The special
29242 name @code{default} signifies that Calc should choose @code{x11} if
29243 the X window system is in use (as indicated by the presence of a
29244 @code{DISPLAY} environment variable), @code{windows} on MS-Windows, or
29245 otherwise @code{dumb} under GNUPLOT 3.0 and later, or
29246 @code{postscript} under GNUPLOT 2.0. This is the initial default
29249 The @code{dumb} device is an interface to ``dumb terminals,'' i.e.,
29250 terminals with no special graphics facilities. It writes a crude
29251 picture of the graph composed of characters like @code{-} and @code{|}
29252 to a buffer called @samp{*Gnuplot Trail*}, which Calc then displays.
29253 The graph is made the same size as the Emacs screen, which on most
29254 dumb terminals will be
29255 @texline @math{80\times24}
29257 characters. The graph is displayed in
29258 an Emacs ``recursive edit''; type @kbd{q} or @kbd{C-c C-c} to exit
29259 the recursive edit and return to Calc. Note that the @code{dumb}
29260 device is present only in GNUPLOT 3.0 and later versions.
29262 The word @code{dumb} may be followed by two numbers separated by
29263 spaces. These are the desired width and height of the graph in
29264 characters. Also, the device name @code{big} is like @code{dumb}
29265 but creates a graph four times the width and height of the Emacs
29266 screen. You will then have to scroll around to view the entire
29267 graph. In the @samp{*Gnuplot Trail*} buffer, @key{SPC}, @key{DEL},
29268 @kbd{<}, and @kbd{>} are defined to scroll by one screenful in each
29269 of the four directions.
29271 With a negative numeric prefix argument, @kbd{g D} sets or displays
29272 the device name used by @kbd{g P} (@code{calc-graph-print}). This
29273 is initially @code{postscript}. If you don't have a PostScript
29274 printer, you may decide once again to use @code{dumb} to create a
29275 plot on any text-only printer.
29278 @pindex calc-graph-output
29279 The @kbd{g O} (@code{calc-graph-output}) command sets the name of the
29280 output file used by GNUPLOT. For some devices, notably @code{x11} and
29281 @code{windows}, there is no output file and this information is not
29282 used. Many other ``devices'' are really file formats like
29283 @code{postscript}; in these cases the output in the desired format
29284 goes into the file you name with @kbd{g O}. Type @kbd{g O stdout
29285 @key{RET}} to set GNUPLOT to write to its standard output stream,
29286 i.e., to @samp{*Gnuplot Trail*}. This is the default setting.
29288 Another special output name is @code{tty}, which means that GNUPLOT
29289 is going to write graphics commands directly to its standard output,
29290 which you wish Emacs to pass through to your terminal. Tektronix
29291 graphics terminals, among other devices, operate this way. Calc does
29292 this by telling GNUPLOT to write to a temporary file, then running a
29293 sub-shell executing the command @samp{cat tempfile >/dev/tty}. On
29294 typical Unix systems, this will copy the temporary file directly to
29295 the terminal, bypassing Emacs entirely. You will have to type @kbd{C-l}
29296 to Emacs afterwards to refresh the screen.
29298 Once again, @kbd{g O} with a positive or negative prefix argument
29299 sets the default or printer output file names, respectively. In each
29300 case you can specify @code{auto}, which causes Calc to invent a temporary
29301 file name for each @kbd{g p} (or @kbd{g P}) command. This temporary file
29302 will be deleted once it has been displayed or printed. If the output file
29303 name is not @code{auto}, the file is not automatically deleted.
29305 The default and printer devices and output files can be saved
29306 permanently by the @kbd{m m} (@code{calc-save-modes}) command. The
29307 default number of data points (see @kbd{g N}) and the X geometry
29308 (see @kbd{g X}) are also saved. Other graph information is @emph{not}
29309 saved; you can save a graph's configuration simply by saving the contents
29310 of the @samp{*Gnuplot Commands*} buffer.
29312 @vindex calc-gnuplot-plot-command
29313 @vindex calc-gnuplot-default-device
29314 @vindex calc-gnuplot-default-output
29315 @vindex calc-gnuplot-print-command
29316 @vindex calc-gnuplot-print-device
29317 @vindex calc-gnuplot-print-output
29318 You may wish to configure the default and
29319 printer devices and output files for the whole system. The relevant
29320 Lisp variables are @code{calc-gnuplot-default-device} and @code{-output},
29321 and @code{calc-gnuplot-print-device} and @code{-output}. The output
29322 file names must be either strings as described above, or Lisp
29323 expressions which are evaluated on the fly to get the output file names.
29325 Other important Lisp variables are @code{calc-gnuplot-plot-command} and
29326 @code{calc-gnuplot-print-command}, which give the system commands to
29327 display or print the output of GNUPLOT, respectively. These may be
29328 @code{nil} if no command is necessary, or strings which can include
29329 @samp{%s} to signify the name of the file to be displayed or printed.
29330 Or, these variables may contain Lisp expressions which are evaluated
29331 to display or print the output. These variables are customizable
29332 (@pxref{Customizing Calc}).
29335 @pindex calc-graph-display
29336 The @kbd{g x} (@code{calc-graph-display}) command lets you specify
29337 on which X window system display your graphs should be drawn. Enter
29338 a blank line to see the current display name. This command has no
29339 effect unless the current device is @code{x11}.
29342 @pindex calc-graph-geometry
29343 The @kbd{g X} (@code{calc-graph-geometry}) command is a similar
29344 command for specifying the position and size of the X window.
29345 The normal value is @code{default}, which generally means your
29346 window manager will let you place the window interactively.
29347 Entering @samp{800x500+0+0} would create an 800-by-500 pixel
29348 window in the upper-left corner of the screen. This command has no
29349 effect if the current device is @code{windows}.
29351 The buffer called @samp{*Gnuplot Trail*} holds a transcript of the
29352 session with GNUPLOT. This shows the commands Calc has ``typed'' to
29353 GNUPLOT and the responses it has received. Calc tries to notice when an
29354 error message has appeared here and display the buffer for you when
29355 this happens. You can check this buffer yourself if you suspect
29356 something has gone wrong@footnote{
29357 On MS-Windows, due to the peculiarities of how the Windows version of
29358 GNUPLOT (called @command{wgnuplot}) works, the GNUPLOT responses are
29359 not communicated back to Calc. Instead, you need to look them up in
29360 the GNUPLOT command window that is displayed as in normal interactive
29365 @pindex calc-graph-command
29366 The @kbd{g C} (@code{calc-graph-command}) command prompts you to
29367 enter any line of text, then simply sends that line to the current
29368 GNUPLOT process. The @samp{*Gnuplot Trail*} buffer looks deceptively
29369 like a Shell buffer but you can't type commands in it yourself.
29370 Instead, you must use @kbd{g C} for this purpose.
29374 @pindex calc-graph-view-commands
29375 @pindex calc-graph-view-trail
29376 The @kbd{g v} (@code{calc-graph-view-commands}) and @kbd{g V}
29377 (@code{calc-graph-view-trail}) commands display the @samp{*Gnuplot Commands*}
29378 and @samp{*Gnuplot Trail*} buffers, respectively, in another window.
29379 This happens automatically when Calc thinks there is something you
29380 will want to see in either of these buffers. If you type @kbd{g v}
29381 or @kbd{g V} when the relevant buffer is already displayed, the
29382 buffer is hidden again. (Note that on MS-Windows, the @samp{*Gnuplot
29383 Trail*} buffer will usually show nothing of interest, because
29384 GNUPLOT's responses are not communicated back to Calc.)
29386 One reason to use @kbd{g v} is to add your own commands to the
29387 @samp{*Gnuplot Commands*} buffer. Press @kbd{g v}, then use
29388 @kbd{C-x o} to switch into that window. For example, GNUPLOT has
29389 @samp{set label} and @samp{set arrow} commands that allow you to
29390 annotate your plots. Since Calc doesn't understand these commands,
29391 you have to add them to the @samp{*Gnuplot Commands*} buffer
29392 yourself, then use @w{@kbd{g p}} to replot using these new commands. Note
29393 that your commands must appear @emph{before} the @code{plot} command.
29394 To get help on any GNUPLOT feature, type, e.g., @kbd{g C help set label}.
29395 You may have to type @kbd{g C @key{RET}} a few times to clear the
29396 ``press return for more'' or ``subtopic of @dots{}'' requests.
29397 Note that Calc always sends commands (like @samp{set nolabel}) to
29398 reset all plotting parameters to the defaults before each plot, so
29399 to delete a label all you need to do is delete the @samp{set label}
29400 line you added (or comment it out with @samp{#}) and then replot
29404 @pindex calc-graph-quit
29405 You can use @kbd{g q} (@code{calc-graph-quit}) to kill the GNUPLOT
29406 process that is running. The next graphing command you give will
29407 start a fresh GNUPLOT process. The word @samp{Graph} appears in
29408 the Calc window's mode line whenever a GNUPLOT process is currently
29409 running. The GNUPLOT process is automatically killed when you
29410 exit Emacs if you haven't killed it manually by then.
29413 @pindex calc-graph-kill
29414 The @kbd{g K} (@code{calc-graph-kill}) command is like @kbd{g q}
29415 except that it also views the @samp{*Gnuplot Trail*} buffer so that
29416 you can see the process being killed. This is better if you are
29417 killing GNUPLOT because you think it has gotten stuck.
29419 @node Kill and Yank, Keypad Mode, Graphics, Top
29420 @chapter Kill and Yank Functions
29423 The commands in this chapter move information between the Calculator and
29424 other Emacs editing buffers.
29426 In many cases Embedded mode is an easier and more natural way to
29427 work with Calc from a regular editing buffer. @xref{Embedded Mode}.
29430 * Killing From Stack::
29431 * Yanking Into Stack::
29432 * Saving Into Registers::
29433 * Inserting From Registers::
29434 * Grabbing From Buffers::
29435 * Yanking Into Buffers::
29436 * X Cut and Paste::
29439 @node Killing From Stack, Yanking Into Stack, Kill and Yank, Kill and Yank
29440 @section Killing from the Stack
29446 @pindex calc-copy-as-kill
29448 @pindex calc-kill-region
29450 @pindex calc-copy-region-as-kill
29453 @dfn{Kill} commands are Emacs commands that insert text into the ``kill
29454 ring,'' from which it can later be ``yanked'' by a @kbd{C-y} command.
29455 Three common kill commands in normal Emacs are @kbd{C-k}, which kills
29456 one line, @kbd{C-w}, which kills the region between mark and point, and
29457 @kbd{M-w}, which puts the region into the kill ring without actually
29458 deleting it. All of these commands work in the Calculator, too,
29459 although in the Calculator they operate on whole stack entries, so they
29460 ``round up'' the specified region to encompass full lines. (To copy
29461 only parts of lines, the @kbd{M-C-w} command in the Calculator will copy
29462 the region to the kill ring without any ``rounding up'', just like the
29463 @kbd{M-w} command in normal Emacs.) Also, @kbd{M-k} has been provided
29464 to complete the set; it puts the current line into the kill ring without
29467 The kill commands are unusual in that they pay attention to the location
29468 of the cursor in the Calculator buffer. If the cursor is on or below
29469 the bottom line, the kill commands operate on the top of the stack.
29470 Otherwise, they operate on whatever stack element the cursor is on. The
29471 text is copied into the kill ring exactly as it appears on the screen,
29472 including line numbers if they are enabled.
29474 A numeric prefix argument to @kbd{C-k} or @kbd{M-k} affects the number
29475 of lines killed. A positive argument kills the current line and @expr{n-1}
29476 lines below it. A negative argument kills the @expr{-n} lines above the
29477 current line. Again this mirrors the behavior of the standard Emacs
29478 @kbd{C-k} command. Although a whole line is always deleted, @kbd{C-k}
29479 with no argument copies only the number itself into the kill ring, whereas
29480 @kbd{C-k} with a prefix argument of 1 copies the number with its trailing
29483 @node Yanking Into Stack, Saving Into Registers, Killing From Stack, Kill and Yank
29484 @section Yanking into the Stack
29489 The @kbd{C-y} command yanks the most recently killed text back into the
29490 Calculator. It pushes this value onto the top of the stack regardless of
29491 the cursor position. In general it re-parses the killed text as a number
29492 or formula (or a list of these separated by commas or newlines). However if
29493 the thing being yanked is something that was just killed from the Calculator
29494 itself, its full internal structure is yanked. For example, if you have
29495 set the floating-point display mode to show only four significant digits,
29496 then killing and re-yanking 3.14159 (which displays as 3.142) will yank the
29497 full 3.14159, even though yanking it into any other buffer would yank the
29498 number in its displayed form, 3.142. (Since the default display modes
29499 show all objects to their full precision, this feature normally makes no
29502 @node Saving Into Registers, Inserting From Registers, Yanking Into Stack, Kill and Yank
29503 @section Saving into Registers
29507 @pindex calc-copy-to-register
29508 @pindex calc-prepend-to-register
29509 @pindex calc-append-to-register
29511 An alternative to killing and yanking stack entries is using
29512 registers in Calc. Saving stack entries in registers is like
29513 saving text in normal Emacs registers; although, like Calc's kill
29514 commands, register commands always operate on whole stack
29517 Registers in Calc are places to store stack entries for later use;
29518 each register is indexed by a single character. To store the current
29519 region (rounded up, of course, to include full stack entries) into a
29520 register, use the command @kbd{r s} (@code{calc-copy-to-register}).
29521 You will then be prompted for a register to use, the next character
29522 you type will be the index for the register. To store the region in
29523 register @var{r}, the full command will be @kbd{r s @var{r}}. With an
29524 argument, @kbd{C-u r s @var{r}}, the region being copied to the
29525 register will be deleted from the Calc buffer.
29527 It is possible to add additional stack entries to a register. The
29528 command @kbd{M-x calc-append-to-register} will prompt for a register,
29529 then add the stack entries in the region to the end of the register
29530 contents. The command @kbd{M-x calc-prepend-to-register} will
29531 similarly prompt for a register and add the stack entries in the
29532 region to the beginning of the register contents. Both commands take
29533 @kbd{C-u} arguments, which will cause the region to be deleted after being
29534 added to the register.
29536 @node Inserting From Registers, Grabbing From Buffers, Saving Into Registers, Kill and Yank
29537 @section Inserting from Registers
29540 @pindex calc-insert-register
29541 The command @kbd{r i} (@code{calc-insert-register}) will prompt for a
29542 register, then insert the contents of that register into the
29543 Calculator. If the contents of the register were placed there from
29544 within Calc, then the full internal structure of the contents will be
29545 inserted into the Calculator, otherwise whatever text is in the
29546 register is reparsed and then inserted into the Calculator.
29548 @node Grabbing From Buffers, Yanking Into Buffers, Inserting From Registers, Kill and Yank
29549 @section Grabbing from Other Buffers
29553 @pindex calc-grab-region
29554 The @kbd{C-x * g} (@code{calc-grab-region}) command takes the text between
29555 point and mark in the current buffer and attempts to parse it as a
29556 vector of values. Basically, it wraps the text in vector brackets
29557 @samp{[ ]} unless the text already is enclosed in vector brackets,
29558 then reads the text as if it were an algebraic entry. The contents
29559 of the vector may be numbers, formulas, or any other Calc objects.
29560 If the @kbd{C-x * g} command works successfully, it does an automatic
29561 @kbd{C-x * c} to enter the Calculator buffer.
29563 A numeric prefix argument grabs the specified number of lines around
29564 point, ignoring the mark. A positive prefix grabs from point to the
29565 @expr{n}th following newline (so that @kbd{M-1 C-x * g} grabs from point
29566 to the end of the current line); a negative prefix grabs from point
29567 back to the @expr{n+1}st preceding newline. In these cases the text
29568 that is grabbed is exactly the same as the text that @kbd{C-k} would
29569 delete given that prefix argument.
29571 A prefix of zero grabs the current line; point may be anywhere on the
29574 A plain @kbd{C-u} prefix interprets the region between point and mark
29575 as a single number or formula rather than a vector. For example,
29576 @kbd{C-x * g} on the text @samp{2 a b} produces the vector of three
29577 values @samp{[2, a, b]}, but @kbd{C-u C-x * g} on the same region
29578 reads a formula which is a product of three things: @samp{2 a b}.
29579 (The text @samp{a + b}, on the other hand, will be grabbed as a
29580 vector of one element by plain @kbd{C-x * g} because the interpretation
29581 @samp{[a, +, b]} would be a syntax error.)
29583 If a different language has been specified (@pxref{Language Modes}),
29584 the grabbed text will be interpreted according to that language.
29587 @pindex calc-grab-rectangle
29588 The @kbd{C-x * r} (@code{calc-grab-rectangle}) command takes the text between
29589 point and mark and attempts to parse it as a matrix. If point and mark
29590 are both in the leftmost column, the lines in between are parsed in their
29591 entirety. Otherwise, point and mark define the corners of a rectangle
29592 whose contents are parsed.
29594 Each line of the grabbed area becomes a row of the matrix. The result
29595 will actually be a vector of vectors, which Calc will treat as a matrix
29596 only if every row contains the same number of values.
29598 If a line contains a portion surrounded by square brackets (or curly
29599 braces), that portion is interpreted as a vector which becomes a row
29600 of the matrix. Any text surrounding the bracketed portion on the line
29603 Otherwise, the entire line is interpreted as a row vector as if it
29604 were surrounded by square brackets. Leading line numbers (in the
29605 format used in the Calc stack buffer) are ignored. If you wish to
29606 force this interpretation (even if the line contains bracketed
29607 portions), give a negative numeric prefix argument to the
29608 @kbd{C-x * r} command.
29610 If you give a numeric prefix argument of zero or plain @kbd{C-u}, each
29611 line is instead interpreted as a single formula which is converted into
29612 a one-element vector. Thus the result of @kbd{C-u C-x * r} will be a
29613 one-column matrix. For example, suppose one line of the data is the
29614 expression @samp{2 a}. A plain @w{@kbd{C-x * r}} will interpret this as
29615 @samp{[2 a]}, which in turn is read as a two-element vector that forms
29616 one row of the matrix. But a @kbd{C-u C-x * r} will interpret this row
29619 If you give a positive numeric prefix argument @var{n}, then each line
29620 will be split up into columns of width @var{n}; each column is parsed
29621 separately as a matrix element. If a line contained
29622 @w{@samp{2 +/- 3 4 +/- 5}}, then grabbing with a prefix argument of 8
29623 would correctly split the line into two error forms.
29625 @xref{Matrix Functions}, to see how to pull the matrix apart into its
29626 constituent rows and columns. (If it is a
29627 @texline @math{1\times1}
29629 matrix, just hit @kbd{v u} (@code{calc-unpack}) twice.)
29633 @pindex calc-grab-sum-across
29634 @pindex calc-grab-sum-down
29635 @cindex Summing rows and columns of data
29636 The @kbd{C-x * :} (@code{calc-grab-sum-down}) command is a handy way to
29637 grab a rectangle of data and sum its columns. It is equivalent to
29638 typing @kbd{C-x * r}, followed by @kbd{V R : +} (the vector reduction
29639 command that sums the columns of a matrix; @pxref{Reducing}). The
29640 result of the command will be a vector of numbers, one for each column
29641 in the input data. The @kbd{C-x * _} (@code{calc-grab-sum-across}) command
29642 similarly grabs a rectangle and sums its rows by executing @w{@kbd{V R _ +}}.
29644 As well as being more convenient, @kbd{C-x * :} and @kbd{C-x * _} are also
29645 much faster because they don't actually place the grabbed vector on
29646 the stack. In a @kbd{C-x * r V R : +} sequence, formatting the vector
29647 for display on the stack takes a large fraction of the total time
29648 (unless you have planned ahead and used @kbd{v .} and @kbd{t .} modes).
29650 For example, suppose we have a column of numbers in a file which we
29651 wish to sum. Go to one corner of the column and press @kbd{C-@@} to
29652 set the mark; go to the other corner and type @kbd{C-x * :}. Since there
29653 is only one column, the result will be a vector of one number, the sum.
29654 (You can type @kbd{v u} to unpack this vector into a plain number if
29655 you want to do further arithmetic with it.)
29657 To compute the product of the column of numbers, we would have to do
29658 it ``by hand'' since there's no special grab-and-multiply command.
29659 Use @kbd{C-x * r} to grab the column of numbers into the calculator in
29660 the form of a column matrix. The statistics command @kbd{u *} is a
29661 handy way to find the product of a vector or matrix of numbers.
29662 @xref{Statistical Operations}. Another approach would be to use
29663 an explicit column reduction command, @kbd{V R : *}.
29665 @node Yanking Into Buffers, X Cut and Paste, Grabbing From Buffers, Kill and Yank
29666 @section Yanking into Other Buffers
29670 @pindex calc-copy-to-buffer
29671 The plain @kbd{y} (@code{calc-copy-to-buffer}) command inserts the number
29672 at the top of the stack into the most recently used normal editing buffer.
29673 (More specifically, this is the most recently used buffer which is displayed
29674 in a window and whose name does not begin with @samp{*}. If there is no
29675 such buffer, this is the most recently used buffer except for Calculator
29676 and Calc Trail buffers.) The number is inserted exactly as it appears and
29677 without a newline. (If line-numbering is enabled, the line number is
29678 normally not included.) The number is @emph{not} removed from the stack.
29680 With a prefix argument, @kbd{y} inserts several numbers, one per line.
29681 A positive argument inserts the specified number of values from the top
29682 of the stack. A negative argument inserts the @expr{n}th value from the
29683 top of the stack. An argument of zero inserts the entire stack. Note
29684 that @kbd{y} with an argument of 1 is slightly different from @kbd{y}
29685 with no argument; the former always copies full lines, whereas the
29686 latter strips off the trailing newline.
29688 With a lone @kbd{C-u} as a prefix argument, @kbd{y} @emph{replaces} the
29689 region in the other buffer with the yanked text, then quits the
29690 Calculator, leaving you in that buffer. A typical use would be to use
29691 @kbd{C-x * g} to read a region of data into the Calculator, operate on the
29692 data to produce a new matrix, then type @kbd{C-u y} to replace the
29693 original data with the new data. One might wish to alter the matrix
29694 display style (@pxref{Vector and Matrix Formats}) or change the current
29695 display language (@pxref{Language Modes}) before doing this. Also, note
29696 that this command replaces a linear region of text (as grabbed by
29697 @kbd{C-x * g}), not a rectangle (as grabbed by @kbd{C-x * r}).
29699 If the editing buffer is in overwrite (as opposed to insert) mode,
29700 and the @kbd{C-u} prefix was not used, then the yanked number will
29701 overwrite the characters following point rather than being inserted
29702 before those characters. The usual conventions of overwrite mode
29703 are observed; for example, characters will be inserted at the end of
29704 a line rather than overflowing onto the next line. Yanking a multi-line
29705 object such as a matrix in overwrite mode overwrites the next @var{n}
29706 lines in the buffer, lengthening or shortening each line as necessary.
29707 Finally, if the thing being yanked is a simple integer or floating-point
29708 number (like @samp{-1.2345e-3}) and the characters following point also
29709 make up such a number, then Calc will replace that number with the new
29710 number, lengthening or shortening as necessary. The concept of
29711 ``overwrite mode'' has thus been generalized from overwriting characters
29712 to overwriting one complete number with another.
29715 The @kbd{C-x * y} key sequence is equivalent to @kbd{y} except that
29716 it can be typed anywhere, not just in Calc. This provides an easy
29717 way to guarantee that Calc knows which editing buffer you want to use!
29719 @node X Cut and Paste, , Yanking Into Buffers, Kill and Yank
29720 @section X Cut and Paste
29723 If you are using Emacs with the X window system, there is an easier
29724 way to move small amounts of data into and out of the calculator:
29725 Use the mouse-oriented cut and paste facilities of X.
29727 The default bindings for a three-button mouse cause the left button
29728 to move the Emacs cursor to the given place, the right button to
29729 select the text between the cursor and the clicked location, and
29730 the middle button to yank the selection into the buffer at the
29731 clicked location. So, if you have a Calc window and an editing
29732 window on your Emacs screen, you can use left-click/right-click
29733 to select a number, vector, or formula from one window, then
29734 middle-click to paste that value into the other window. When you
29735 paste text into the Calc window, Calc interprets it as an algebraic
29736 entry. It doesn't matter where you click in the Calc window; the
29737 new value is always pushed onto the top of the stack.
29739 The @code{xterm} program that is typically used for general-purpose
29740 shell windows in X interprets the mouse buttons in the same way.
29741 So you can use the mouse to move data between Calc and any other
29742 Unix program. One nice feature of @code{xterm} is that a double
29743 left-click selects one word, and a triple left-click selects a
29744 whole line. So you can usually transfer a single number into Calc
29745 just by double-clicking on it in the shell, then middle-clicking
29746 in the Calc window.
29748 @node Keypad Mode, Embedded Mode, Kill and Yank, Top
29749 @chapter Keypad Mode
29753 @pindex calc-keypad
29754 The @kbd{C-x * k} (@code{calc-keypad}) command starts the Calculator
29755 and displays a picture of a calculator-style keypad. If you are using
29756 the X window system, you can click on any of the ``keys'' in the
29757 keypad using the left mouse button to operate the calculator.
29758 The original window remains the selected window; in Keypad mode
29759 you can type in your file while simultaneously performing
29760 calculations with the mouse.
29762 @pindex full-calc-keypad
29763 If you have used @kbd{C-x * b} first, @kbd{C-x * k} instead invokes
29764 the @code{full-calc-keypad} command, which takes over the whole
29765 Emacs screen and displays the keypad, the Calc stack, and the Calc
29766 trail all at once. This mode would normally be used when running
29767 Calc standalone (@pxref{Standalone Operation}).
29769 If you aren't using the X window system, you must switch into
29770 the @samp{*Calc Keypad*} window, place the cursor on the desired
29771 ``key,'' and type @key{SPC} or @key{RET}. If you think this
29772 is easier than using Calc normally, go right ahead.
29774 Calc commands are more or less the same in Keypad mode. Certain
29775 keypad keys differ slightly from the corresponding normal Calc
29776 keystrokes; all such deviations are described below.
29778 Keypad mode includes many more commands than will fit on the keypad
29779 at once. Click the right mouse button [@code{calc-keypad-menu}]
29780 to switch to the next menu. The bottom five rows of the keypad
29781 stay the same; the top three rows change to a new set of commands.
29782 To return to earlier menus, click the middle mouse button
29783 [@code{calc-keypad-menu-back}] or simply advance through the menus
29784 until you wrap around. Typing @key{TAB} inside the keypad window
29785 is equivalent to clicking the right mouse button there.
29787 You can always click the @key{EXEC} button and type any normal
29788 Calc key sequence. This is equivalent to switching into the
29789 Calc buffer, typing the keys, then switching back to your
29793 * Keypad Main Menu::
29794 * Keypad Functions Menu::
29795 * Keypad Binary Menu::
29796 * Keypad Vectors Menu::
29797 * Keypad Modes Menu::
29800 @node Keypad Main Menu, Keypad Functions Menu, Keypad Mode, Keypad Mode
29805 |----+----+--Calc---+----+----1
29806 |FLR |CEIL|RND |TRNC|CLN2|FLT |
29807 |----+----+----+----+----+----|
29808 | LN |EXP | |ABS |IDIV|MOD |
29809 |----+----+----+----+----+----|
29810 |SIN |COS |TAN |SQRT|y^x |1/x |
29811 |----+----+----+----+----+----|
29812 | ENTER |+/- |EEX |UNDO| <- |
29813 |-----+---+-+--+--+-+---++----|
29814 | INV | 7 | 8 | 9 | / |
29815 |-----+-----+-----+-----+-----|
29816 | HYP | 4 | 5 | 6 | * |
29817 |-----+-----+-----+-----+-----|
29818 |EXEC | 1 | 2 | 3 | - |
29819 |-----+-----+-----+-----+-----|
29820 | OFF | 0 | . | PI | + |
29821 |-----+-----+-----+-----+-----+
29826 This is the menu that appears the first time you start Keypad mode.
29827 It will show up in a vertical window on the right side of your screen.
29828 Above this menu is the traditional Calc stack display. On a 24-line
29829 screen you will be able to see the top three stack entries.
29831 The ten digit keys, decimal point, and @key{EEX} key are used for
29832 entering numbers in the obvious way. @key{EEX} begins entry of an
29833 exponent in scientific notation. Just as with regular Calc, the
29834 number is pushed onto the stack as soon as you press @key{ENTER}
29835 or any other function key.
29837 The @key{+/-} key corresponds to normal Calc's @kbd{n} key. During
29838 numeric entry it changes the sign of the number or of the exponent.
29839 At other times it changes the sign of the number on the top of the
29842 The @key{INV} and @key{HYP} keys modify other keys. As well as
29843 having the effects described elsewhere in this manual, Keypad mode
29844 defines several other ``inverse'' operations. These are described
29845 below and in the following sections.
29847 The @key{ENTER} key finishes the current numeric entry, or otherwise
29848 duplicates the top entry on the stack.
29850 The @key{UNDO} key undoes the most recent Calc operation.
29851 @kbd{INV UNDO} is the ``redo'' command, and @kbd{HYP UNDO} is
29852 ``last arguments'' (@kbd{M-@key{RET}}).
29854 The @key{<-} key acts as a ``backspace'' during numeric entry.
29855 At other times it removes the top stack entry. @kbd{INV <-}
29856 clears the entire stack. @kbd{HYP <-} takes an integer from
29857 the stack, then removes that many additional stack elements.
29859 The @key{EXEC} key prompts you to enter any keystroke sequence
29860 that would normally work in Calc mode. This can include a
29861 numeric prefix if you wish. It is also possible simply to
29862 switch into the Calc window and type commands in it; there is
29863 nothing ``magic'' about this window when Keypad mode is active.
29865 The other keys in this display perform their obvious calculator
29866 functions. @key{CLN2} rounds the top-of-stack by temporarily
29867 reducing the precision by 2 digits. @key{FLT} converts an
29868 integer or fraction on the top of the stack to floating-point.
29870 The @key{INV} and @key{HYP} keys combined with several of these keys
29871 give you access to some common functions even if the appropriate menu
29872 is not displayed. Obviously you don't need to learn these keys
29873 unless you find yourself wasting time switching among the menus.
29877 is the same as @key{1/x}.
29879 is the same as @key{SQRT}.
29881 is the same as @key{CONJ}.
29883 is the same as @key{y^x}.
29885 is the same as @key{INV y^x} (the @expr{x}th root of @expr{y}).
29887 are the same as @key{SIN} / @kbd{INV SIN}.
29889 are the same as @key{COS} / @kbd{INV COS}.
29891 are the same as @key{TAN} / @kbd{INV TAN}.
29893 are the same as @key{LN} / @kbd{HYP LN}.
29895 are the same as @key{EXP} / @kbd{HYP EXP}.
29897 is the same as @key{ABS}.
29899 is the same as @key{RND} (@code{calc-round}).
29901 is the same as @key{CLN2}.
29903 is the same as @key{FLT} (@code{calc-float}).
29905 is the same as @key{IMAG}.
29907 is the same as @key{PREC}.
29909 is the same as @key{SWAP}.
29911 is the same as @key{RLL3}.
29912 @item INV HYP ENTER
29913 is the same as @key{OVER}.
29915 packs the top two stack entries as an error form.
29917 packs the top two stack entries as a modulo form.
29919 creates an interval form; this removes an integer which is one
29920 of 0 @samp{[]}, 1 @samp{[)}, 2 @samp{(]} or 3 @samp{()}, followed
29921 by the two limits of the interval.
29924 The @kbd{OFF} key turns Calc off; typing @kbd{C-x * k} or @kbd{C-x * *}
29925 again has the same effect. This is analogous to typing @kbd{q} or
29926 hitting @kbd{C-x * c} again in the normal calculator. If Calc is
29927 running standalone (the @code{full-calc-keypad} command appeared in the
29928 command line that started Emacs), then @kbd{OFF} is replaced with
29929 @kbd{EXIT}; clicking on this actually exits Emacs itself.
29931 @node Keypad Functions Menu, Keypad Binary Menu, Keypad Main Menu, Keypad Mode
29932 @section Functions Menu
29936 |----+----+----+----+----+----2
29937 |IGAM|BETA|IBET|ERF |BESJ|BESY|
29938 |----+----+----+----+----+----|
29939 |IMAG|CONJ| RE |ATN2|RAND|RAGN|
29940 |----+----+----+----+----+----|
29941 |GCD |FACT|DFCT|BNOM|PERM|NXTP|
29942 |----+----+----+----+----+----|
29947 This menu provides various operations from the @kbd{f} and @kbd{k}
29950 @key{IMAG} multiplies the number on the stack by the imaginary
29951 number @expr{i = (0, 1)}.
29953 @key{RE} extracts the real part a complex number. @kbd{INV RE}
29954 extracts the imaginary part.
29956 @key{RAND} takes a number from the top of the stack and computes
29957 a random number greater than or equal to zero but less than that
29958 number. (@xref{Random Numbers}.) @key{RAGN} is the ``random
29959 again'' command; it computes another random number using the
29960 same limit as last time.
29962 @key{INV GCD} computes the LCM (least common multiple) function.
29964 @key{INV FACT} is the gamma function.
29965 @texline @math{\Gamma(x) = (x-1)!}.
29966 @infoline @expr{gamma(x) = (x-1)!}.
29968 @key{PERM} is the number-of-permutations function, which is on the
29969 @kbd{H k c} key in normal Calc.
29971 @key{NXTP} finds the next prime after a number. @kbd{INV NXTP}
29972 finds the previous prime.
29974 @node Keypad Binary Menu, Keypad Vectors Menu, Keypad Functions Menu, Keypad Mode
29975 @section Binary Menu
29979 |----+----+----+----+----+----3
29980 |AND | OR |XOR |NOT |LSH |RSH |
29981 |----+----+----+----+----+----|
29982 |DEC |HEX |OCT |BIN |WSIZ|ARSH|
29983 |----+----+----+----+----+----|
29984 | A | B | C | D | E | F |
29985 |----+----+----+----+----+----|
29990 The keys in this menu perform operations on binary integers.
29991 Note that both logical and arithmetic right-shifts are provided.
29992 @key{INV LSH} rotates one bit to the left.
29994 The ``difference'' function (normally on @kbd{b d}) is on @key{INV AND}.
29995 The ``clip'' function (normally on @w{@kbd{b c}}) is on @key{INV NOT}.
29997 The @key{DEC}, @key{HEX}, @key{OCT}, and @key{BIN} keys select the
29998 current radix for display and entry of numbers: Decimal, hexadecimal,
29999 octal, or binary. The six letter keys @key{A} through @key{F} are used
30000 for entering hexadecimal numbers.
30002 The @key{WSIZ} key displays the current word size for binary operations
30003 and allows you to enter a new word size. You can respond to the prompt
30004 using either the keyboard or the digits and @key{ENTER} from the keypad.
30005 The initial word size is 32 bits.
30007 @node Keypad Vectors Menu, Keypad Modes Menu, Keypad Binary Menu, Keypad Mode
30008 @section Vectors Menu
30012 |----+----+----+----+----+----4
30013 |SUM |PROD|MAX |MAP*|MAP^|MAP$|
30014 |----+----+----+----+----+----|
30015 |MINV|MDET|MTRN|IDNT|CRSS|"x" |
30016 |----+----+----+----+----+----|
30017 |PACK|UNPK|INDX|BLD |LEN |... |
30018 |----+----+----+----+----+----|
30023 The keys in this menu operate on vectors and matrices.
30025 @key{PACK} removes an integer @var{n} from the top of the stack;
30026 the next @var{n} stack elements are removed and packed into a vector,
30027 which is replaced onto the stack. Thus the sequence
30028 @kbd{1 ENTER 3 ENTER 5 ENTER 3 PACK} enters the vector
30029 @samp{[1, 3, 5]} onto the stack. To enter a matrix, build each row
30030 on the stack as a vector, then use a final @key{PACK} to collect the
30031 rows into a matrix.
30033 @key{UNPK} unpacks the vector on the stack, pushing each of its
30034 components separately.
30036 @key{INDX} removes an integer @var{n}, then builds a vector of
30037 integers from 1 to @var{n}. @kbd{INV INDX} takes three numbers
30038 from the stack: The vector size @var{n}, the starting number,
30039 and the increment. @kbd{BLD} takes an integer @var{n} and any
30040 value @var{x} and builds a vector of @var{n} copies of @var{x}.
30042 @key{IDNT} removes an integer @var{n}, then builds an @var{n}-by-@var{n}
30045 @key{LEN} replaces a vector by its length, an integer.
30047 @key{...} turns on or off ``abbreviated'' display mode for large vectors.
30049 @key{MINV}, @key{MDET}, @key{MTRN}, and @key{CROSS} are the matrix
30050 inverse, determinant, and transpose, and vector cross product.
30052 @key{SUM} replaces a vector by the sum of its elements. It is
30053 equivalent to @kbd{u +} in normal Calc (@pxref{Statistical Operations}).
30054 @key{PROD} computes the product of the elements of a vector, and
30055 @key{MAX} computes the maximum of all the elements of a vector.
30057 @key{INV SUM} computes the alternating sum of the first element
30058 minus the second, plus the third, minus the fourth, and so on.
30059 @key{INV MAX} computes the minimum of the vector elements.
30061 @key{HYP SUM} computes the mean of the vector elements.
30062 @key{HYP PROD} computes the sample standard deviation.
30063 @key{HYP MAX} computes the median.
30065 @key{MAP*} multiplies two vectors elementwise. It is equivalent
30066 to the @kbd{V M *} command. @key{MAP^} computes powers elementwise.
30067 The arguments must be vectors of equal length, or one must be a vector
30068 and the other must be a plain number. For example, @kbd{2 MAP^} squares
30069 all the elements of a vector.
30071 @key{MAP$} maps the formula on the top of the stack across the
30072 vector in the second-to-top position. If the formula contains
30073 several variables, Calc takes that many vectors starting at the
30074 second-to-top position and matches them to the variables in
30075 alphabetical order. The result is a vector of the same size as
30076 the input vectors, whose elements are the formula evaluated with
30077 the variables set to the various sets of numbers in those vectors.
30078 For example, you could simulate @key{MAP^} using @key{MAP$} with
30079 the formula @samp{x^y}.
30081 The @kbd{"x"} key pushes the variable name @expr{x} onto the
30082 stack. To build the formula @expr{x^2 + 6}, you would use the
30083 key sequence @kbd{"x" 2 y^x 6 +}. This formula would then be
30084 suitable for use with the @key{MAP$} key described above.
30085 With @key{INV}, @key{HYP}, or @key{INV} and @key{HYP}, the
30086 @kbd{"x"} key pushes the variable names @expr{y}, @expr{z}, and
30087 @expr{t}, respectively.
30089 @node Keypad Modes Menu, , Keypad Vectors Menu, Keypad Mode
30090 @section Modes Menu
30094 |----+----+----+----+----+----5
30095 |FLT |FIX |SCI |ENG |GRP | |
30096 |----+----+----+----+----+----|
30097 |RAD |DEG |FRAC|POLR|SYMB|PREC|
30098 |----+----+----+----+----+----|
30099 |SWAP|RLL3|RLL4|OVER|STO |RCL |
30100 |----+----+----+----+----+----|
30105 The keys in this menu manipulate modes, variables, and the stack.
30107 The @key{FLT}, @key{FIX}, @key{SCI}, and @key{ENG} keys select
30108 floating-point, fixed-point, scientific, or engineering notation.
30109 @key{FIX} displays two digits after the decimal by default; the
30110 others display full precision. With the @key{INV} prefix, these
30111 keys pop a number-of-digits argument from the stack.
30113 The @key{GRP} key turns grouping of digits with commas on or off.
30114 @kbd{INV GRP} enables grouping to the right of the decimal point as
30115 well as to the left.
30117 The @key{RAD} and @key{DEG} keys switch between radians and degrees
30118 for trigonometric functions.
30120 The @key{FRAC} key turns Fraction mode on or off. This affects
30121 whether commands like @kbd{/} with integer arguments produce
30122 fractional or floating-point results.
30124 The @key{POLR} key turns Polar mode on or off, determining whether
30125 polar or rectangular complex numbers are used by default.
30127 The @key{SYMB} key turns Symbolic mode on or off, in which
30128 operations that would produce inexact floating-point results
30129 are left unevaluated as algebraic formulas.
30131 The @key{PREC} key selects the current precision. Answer with
30132 the keyboard or with the keypad digit and @key{ENTER} keys.
30134 The @key{SWAP} key exchanges the top two stack elements.
30135 The @key{RLL3} key rotates the top three stack elements upwards.
30136 The @key{RLL4} key rotates the top four stack elements upwards.
30137 The @key{OVER} key duplicates the second-to-top stack element.
30139 The @key{STO} and @key{RCL} keys are analogous to @kbd{s t} and
30140 @kbd{s r} in regular Calc. @xref{Store and Recall}. Click the
30141 @key{STO} or @key{RCL} key, then one of the ten digits. (Named
30142 variables are not available in Keypad mode.) You can also use,
30143 for example, @kbd{STO + 3} to add to register 3.
30145 @node Embedded Mode, Programming, Keypad Mode, Top
30146 @chapter Embedded Mode
30149 Embedded mode in Calc provides an alternative to copying numbers
30150 and formulas back and forth between editing buffers and the Calc
30151 stack. In Embedded mode, your editing buffer becomes temporarily
30152 linked to the stack and this copying is taken care of automatically.
30155 * Basic Embedded Mode::
30156 * More About Embedded Mode::
30157 * Assignments in Embedded Mode::
30158 * Mode Settings in Embedded Mode::
30159 * Customizing Embedded Mode::
30162 @node Basic Embedded Mode, More About Embedded Mode, Embedded Mode, Embedded Mode
30163 @section Basic Embedded Mode
30167 @pindex calc-embedded
30168 To enter Embedded mode, position the Emacs point (cursor) on a
30169 formula in any buffer and press @kbd{C-x * e} (@code{calc-embedded}).
30170 Note that @kbd{C-x * e} is not to be used in the Calc stack buffer
30171 like most Calc commands, but rather in regular editing buffers that
30172 are visiting your own files.
30174 Calc will try to guess an appropriate language based on the major mode
30175 of the editing buffer. (@xref{Language Modes}.) If the current buffer is
30176 in @code{latex-mode}, for example, Calc will set its language to La@TeX{}.
30177 Similarly, Calc will use @TeX{} language for @code{tex-mode},
30178 @code{plain-tex-mode} and @code{context-mode}, C language for
30179 @code{c-mode} and @code{c++-mode}, FORTRAN language for
30180 @code{fortran-mode} and @code{f90-mode}, Pascal for @code{pascal-mode},
30181 and eqn for @code{nroff-mode} (@pxref{Customizing Calc}).
30182 These can be overridden with Calc's mode
30183 changing commands (@pxref{Mode Settings in Embedded Mode}). If no
30184 suitable language is available, Calc will continue with its current language.
30186 Calc normally scans backward and forward in the buffer for the
30187 nearest opening and closing @dfn{formula delimiters}. The simplest
30188 delimiters are blank lines. Other delimiters that Embedded mode
30193 The @TeX{} and La@TeX{} math delimiters @samp{$ $}, @samp{$$ $$},
30194 @samp{\[ \]}, and @samp{\( \)};
30196 Lines beginning with @samp{\begin} and @samp{\end} (except matrix delimiters);
30198 Lines beginning with @samp{@@} (Texinfo delimiters).
30200 Lines beginning with @samp{.EQ} and @samp{.EN} (@dfn{eqn} delimiters);
30202 Lines containing a single @samp{%} or @samp{.\"} symbol and nothing else.
30205 @xref{Customizing Embedded Mode}, to see how to make Calc recognize
30206 your own favorite delimiters. Delimiters like @samp{$ $} can appear
30207 on their own separate lines or in-line with the formula.
30209 If you give a positive or negative numeric prefix argument, Calc
30210 instead uses the current point as one end of the formula, and includes
30211 that many lines forward or backward (respectively, including the current
30212 line). Explicit delimiters are not necessary in this case.
30214 With a prefix argument of zero, Calc uses the current region (delimited
30215 by point and mark) instead of formula delimiters. With a prefix
30216 argument of @kbd{C-u} only, Calc uses the current line as the formula.
30219 @pindex calc-embedded-word
30220 The @kbd{C-x * w} (@code{calc-embedded-word}) command will start Embedded
30221 mode on the current ``word''; in this case Calc will scan for the first
30222 non-numeric character (i.e., the first character that is not a digit,
30223 sign, decimal point, or upper- or lower-case @samp{e}) forward and
30224 backward to delimit the formula.
30226 When you enable Embedded mode for a formula, Calc reads the text
30227 between the delimiters and tries to interpret it as a Calc formula.
30228 Calc can generally identify @TeX{} formulas and
30229 Big-style formulas even if the language mode is wrong. If Calc
30230 can't make sense of the formula, it beeps and refuses to enter
30231 Embedded mode. But if the current language is wrong, Calc can
30232 sometimes parse the formula successfully (but incorrectly);
30233 for example, the C expression @samp{atan(a[1])} can be parsed
30234 in Normal language mode, but the @code{atan} won't correspond to
30235 the built-in @code{arctan} function, and the @samp{a[1]} will be
30236 interpreted as @samp{a} times the vector @samp{[1]}!
30238 If you press @kbd{C-x * e} or @kbd{C-x * w} to activate an embedded
30239 formula which is blank, say with the cursor on the space between
30240 the two delimiters @samp{$ $}, Calc will immediately prompt for
30241 an algebraic entry.
30243 Only one formula in one buffer can be enabled at a time. If you
30244 move to another area of the current buffer and give Calc commands,
30245 Calc turns Embedded mode off for the old formula and then tries
30246 to restart Embedded mode at the new position. Other buffers are
30247 not affected by Embedded mode.
30249 When Embedded mode begins, Calc pushes the current formula onto
30250 the stack. No Calc stack window is created; however, Calc copies
30251 the top-of-stack position into the original buffer at all times.
30252 You can create a Calc window by hand with @kbd{C-x * o} if you
30253 find you need to see the entire stack.
30255 For example, typing @kbd{C-x * e} while somewhere in the formula
30256 @samp{n>2} in the following line enables Embedded mode on that
30260 We define $F_n = F_(n-1)+F_(n-2)$ for all $n>2$.
30264 The formula @expr{n>2} will be pushed onto the Calc stack, and
30265 the top of stack will be copied back into the editing buffer.
30266 This means that spaces will appear around the @samp{>} symbol
30267 to match Calc's usual display style:
30270 We define $F_n = F_(n-1)+F_(n-2)$ for all $n > 2$.
30274 No spaces have appeared around the @samp{+} sign because it's
30275 in a different formula, one which we have not yet touched with
30278 Now that Embedded mode is enabled, keys you type in this buffer
30279 are interpreted as Calc commands. At this point we might use
30280 the ``commute'' command @kbd{j C} to reverse the inequality.
30281 This is a selection-based command for which we first need to
30282 move the cursor onto the operator (@samp{>} in this case) that
30283 needs to be commuted.
30286 We define $F_n = F_(n-1)+F_(n-2)$ for all $2 < n$.
30289 The @kbd{C-x * o} command is a useful way to open a Calc window
30290 without actually selecting that window. Giving this command
30291 verifies that @samp{2 < n} is also on the Calc stack. Typing
30292 @kbd{17 @key{RET}} would produce:
30295 We define $F_n = F_(n-1)+F_(n-2)$ for all $17$.
30299 with @samp{2 < n} and @samp{17} on the stack; typing @key{TAB}
30300 at this point will exchange the two stack values and restore
30301 @samp{2 < n} to the embedded formula. Even though you can't
30302 normally see the stack in Embedded mode, it is still there and
30303 it still operates in the same way. But, as with old-fashioned
30304 RPN calculators, you can only see the value at the top of the
30305 stack at any given time (unless you use @kbd{C-x * o}).
30307 Typing @kbd{C-x * e} again turns Embedded mode off. The Calc
30308 window reveals that the formula @w{@samp{2 < n}} is automatically
30309 removed from the stack, but the @samp{17} is not. Entering
30310 Embedded mode always pushes one thing onto the stack, and
30311 leaving Embedded mode always removes one thing. Anything else
30312 that happens on the stack is entirely your business as far as
30313 Embedded mode is concerned.
30315 If you press @kbd{C-x * e} in the wrong place by accident, it is
30316 possible that Calc will be able to parse the nearby text as a
30317 formula and will mangle that text in an attempt to redisplay it
30318 ``properly'' in the current language mode. If this happens,
30319 press @kbd{C-x * e} again to exit Embedded mode, then give the
30320 regular Emacs ``undo'' command (@kbd{C-_} or @kbd{C-x u}) to put
30321 the text back the way it was before Calc edited it. Note that Calc's
30322 own Undo command (typed before you turn Embedded mode back off)
30323 will not do you any good, because as far as Calc is concerned
30324 you haven't done anything with this formula yet.
30326 @node More About Embedded Mode, Assignments in Embedded Mode, Basic Embedded Mode, Embedded Mode
30327 @section More About Embedded Mode
30330 When Embedded mode ``activates'' a formula, i.e., when it examines
30331 the formula for the first time since the buffer was created or
30332 loaded, Calc tries to sense the language in which the formula was
30333 written. If the formula contains any La@TeX{}-like @samp{\} sequences,
30334 it is parsed (i.e., read) in La@TeX{} mode. If the formula appears to
30335 be written in multi-line Big mode, it is parsed in Big mode. Otherwise,
30336 it is parsed according to the current language mode.
30338 Note that Calc does not change the current language mode according
30339 the formula it reads in. Even though it can read a La@TeX{} formula when
30340 not in La@TeX{} mode, it will immediately rewrite this formula using
30341 whatever language mode is in effect.
30348 @pindex calc-show-plain
30349 Calc's parser is unable to read certain kinds of formulas. For
30350 example, with @kbd{v ]} (@code{calc-matrix-brackets}) you can
30351 specify matrix display styles which the parser is unable to
30352 recognize as matrices. The @kbd{d p} (@code{calc-show-plain})
30353 command turns on a mode in which a ``plain'' version of a
30354 formula is placed in front of the fully-formatted version.
30355 When Calc reads a formula that has such a plain version in
30356 front, it reads the plain version and ignores the formatted
30359 Plain formulas are preceded and followed by @samp{%%%} signs
30360 by default. This notation has the advantage that the @samp{%}
30361 character begins a comment in @TeX{} and La@TeX{}, so if your formula is
30362 embedded in a @TeX{} or La@TeX{} document its plain version will be
30363 invisible in the final printed copy. Certain major modes have different
30364 delimiters to ensure that the ``plain'' version will be
30365 in a comment for those modes, also.
30366 See @ref{Customizing Embedded Mode} to see how to change the ``plain''
30367 formula delimiters.
30369 There are several notations which Calc's parser for ``big''
30370 formatted formulas can't yet recognize. In particular, it can't
30371 read the large symbols for @code{sum}, @code{prod}, and @code{integ},
30372 and it can't handle @samp{=>} with the righthand argument omitted.
30373 Also, Calc won't recognize special formats you have defined with
30374 the @kbd{Z C} command (@pxref{User-Defined Compositions}). In
30375 these cases it is important to use ``plain'' mode to make sure
30376 Calc will be able to read your formula later.
30378 Another example where ``plain'' mode is important is if you have
30379 specified a float mode with few digits of precision. Normally
30380 any digits that are computed but not displayed will simply be
30381 lost when you save and re-load your embedded buffer, but ``plain''
30382 mode allows you to make sure that the complete number is present
30383 in the file as well as the rounded-down number.
30389 Embedded buffers remember active formulas for as long as they
30390 exist in Emacs memory. Suppose you have an embedded formula
30391 which is @cpi{} to the normal 12 decimal places, and then
30392 type @w{@kbd{C-u 5 d n}} to display only five decimal places.
30393 If you then type @kbd{d n}, all 12 places reappear because the
30394 full number is still there on the Calc stack. More surprisingly,
30395 even if you exit Embedded mode and later re-enter it for that
30396 formula, typing @kbd{d n} will restore all 12 places because
30397 each buffer remembers all its active formulas. However, if you
30398 save the buffer in a file and reload it in a new Emacs session,
30399 all non-displayed digits will have been lost unless you used
30406 In some applications of Embedded mode, you will want to have a
30407 sequence of copies of a formula that show its evolution as you
30408 work on it. For example, you might want to have a sequence
30409 like this in your file (elaborating here on the example from
30410 the ``Getting Started'' chapter):
30419 @r{(the derivative of }ln(ln(x))@r{)}
30421 whose value at x = 2 is
30431 @pindex calc-embedded-duplicate
30432 The @kbd{C-x * d} (@code{calc-embedded-duplicate}) command is a
30433 handy way to make sequences like this. If you type @kbd{C-x * d},
30434 the formula under the cursor (which may or may not have Embedded
30435 mode enabled for it at the time) is copied immediately below and
30436 Embedded mode is then enabled for that copy.
30438 For this example, you would start with just
30447 and press @kbd{C-x * d} with the cursor on this formula. The result
30460 with the second copy of the formula enabled in Embedded mode.
30461 You can now press @kbd{a d x @key{RET}} to take the derivative, and
30462 @kbd{C-x * d C-x * d} to make two more copies of the derivative.
30463 To complete the computations, type @kbd{3 s l x @key{RET}} to evaluate
30464 the last formula, then move up to the second-to-last formula
30465 and type @kbd{2 s l x @key{RET}}.
30467 Finally, you would want to press @kbd{C-x * e} to exit Embedded
30468 mode, then go up and insert the necessary text in between the
30469 various formulas and numbers.
30477 @pindex calc-embedded-new-formula
30478 The @kbd{C-x * f} (@code{calc-embedded-new-formula}) command
30479 creates a new embedded formula at the current point. It inserts
30480 some default delimiters, which are usually just blank lines,
30481 and then does an algebraic entry to get the formula (which is
30482 then enabled for Embedded mode). This is just shorthand for
30483 typing the delimiters yourself, positioning the cursor between
30484 the new delimiters, and pressing @kbd{C-x * e}. The key sequence
30485 @kbd{C-x * '} is equivalent to @kbd{C-x * f}.
30489 @pindex calc-embedded-next
30490 @pindex calc-embedded-previous
30491 The @kbd{C-x * n} (@code{calc-embedded-next}) and @kbd{C-x * p}
30492 (@code{calc-embedded-previous}) commands move the cursor to the
30493 next or previous active embedded formula in the buffer. They
30494 can take positive or negative prefix arguments to move by several
30495 formulas. Note that these commands do not actually examine the
30496 text of the buffer looking for formulas; they only see formulas
30497 which have previously been activated in Embedded mode. In fact,
30498 @kbd{C-x * n} and @kbd{C-x * p} are a useful way to tell which
30499 embedded formulas are currently active. Also, note that these
30500 commands do not enable Embedded mode on the next or previous
30501 formula, they just move the cursor.
30504 @pindex calc-embedded-edit
30505 The @kbd{C-x * `} (@code{calc-embedded-edit}) command edits the
30506 embedded formula at the current point as if by @kbd{`} (@code{calc-edit}).
30507 Embedded mode does not have to be enabled for this to work. Press
30508 @kbd{C-c C-c} to finish the edit, or @kbd{C-x k} to cancel.
30510 @node Assignments in Embedded Mode, Mode Settings in Embedded Mode, More About Embedded Mode, Embedded Mode
30511 @section Assignments in Embedded Mode
30514 The @samp{:=} (assignment) and @samp{=>} (``evaluates-to'') operators
30515 are especially useful in Embedded mode. They allow you to make
30516 a definition in one formula, then refer to that definition in
30517 other formulas embedded in the same buffer.
30519 An embedded formula which is an assignment to a variable, as in
30526 records @expr{5} as the stored value of @code{foo} for the
30527 purposes of Embedded mode operations in the current buffer. It
30528 does @emph{not} actually store @expr{5} as the ``global'' value
30529 of @code{foo}, however. Regular Calc operations, and Embedded
30530 formulas in other buffers, will not see this assignment.
30532 One way to use this assigned value is simply to create an
30533 Embedded formula elsewhere that refers to @code{foo}, and to press
30534 @kbd{=} in that formula. However, this permanently replaces the
30535 @code{foo} in the formula with its current value. More interesting
30536 is to use @samp{=>} elsewhere:
30542 @xref{Evaluates-To Operator}, for a general discussion of @samp{=>}.
30544 If you move back and change the assignment to @code{foo}, any
30545 @samp{=>} formulas which refer to it are automatically updated.
30553 The obvious question then is, @emph{how} can one easily change the
30554 assignment to @code{foo}? If you simply select the formula in
30555 Embedded mode and type 17, the assignment itself will be replaced
30556 by the 17. The effect on the other formula will be that the
30557 variable @code{foo} becomes unassigned:
30565 The right thing to do is first to use a selection command (@kbd{j 2}
30566 will do the trick) to select the righthand side of the assignment.
30567 Then, @kbd{17 @key{TAB} @key{DEL}} will swap the 17 into place (@pxref{Selecting
30568 Subformulas}, to see how this works).
30571 @pindex calc-embedded-select
30572 The @kbd{C-x * j} (@code{calc-embedded-select}) command provides an
30573 easy way to operate on assignments. It is just like @kbd{C-x * e},
30574 except that if the enabled formula is an assignment, it uses
30575 @kbd{j 2} to select the righthand side. If the enabled formula
30576 is an evaluates-to, it uses @kbd{j 1} to select the lefthand side.
30577 A formula can also be a combination of both:
30580 bar := foo + 3 => 20
30584 in which case @kbd{C-x * j} will select the middle part (@samp{foo + 3}).
30586 The formula is automatically deselected when you leave Embedded
30590 @pindex calc-embedded-update-formula
30591 Another way to change the assignment to @code{foo} would simply be
30592 to edit the number using regular Emacs editing rather than Embedded
30593 mode. Then, we have to find a way to get Embedded mode to notice
30594 the change. The @kbd{C-x * u} (@code{calc-embedded-update-formula})
30595 command is a convenient way to do this.
30603 Pressing @kbd{C-x * u} is much like pressing @kbd{C-x * e = C-x * e}, that
30604 is, temporarily enabling Embedded mode for the formula under the
30605 cursor and then evaluating it with @kbd{=}. But @kbd{C-x * u} does
30606 not actually use @kbd{C-x * e}, and in fact another formula somewhere
30607 else can be enabled in Embedded mode while you use @kbd{C-x * u} and
30608 that formula will not be disturbed.
30610 With a numeric prefix argument, @kbd{C-x * u} updates all active
30611 @samp{=>} formulas in the buffer. Formulas which have not yet
30612 been activated in Embedded mode, and formulas which do not have
30613 @samp{=>} as their top-level operator, are not affected by this.
30614 (This is useful only if you have used @kbd{m C}; see below.)
30616 With a plain @kbd{C-u} prefix, @kbd{C-u C-x * u} updates only in the
30617 region between mark and point rather than in the whole buffer.
30619 @kbd{C-x * u} is also a handy way to activate a formula, such as an
30620 @samp{=>} formula that has freshly been typed in or loaded from a
30624 @pindex calc-embedded-activate
30625 The @kbd{C-x * a} (@code{calc-embedded-activate}) command scans
30626 through the current buffer and activates all embedded formulas
30627 that contain @samp{:=} or @samp{=>} symbols. This does not mean
30628 that Embedded mode is actually turned on, but only that the
30629 formulas' positions are registered with Embedded mode so that
30630 the @samp{=>} values can be properly updated as assignments are
30633 It is a good idea to type @kbd{C-x * a} right after loading a file
30634 that uses embedded @samp{=>} operators. Emacs includes a nifty
30635 ``buffer-local variables'' feature that you can use to do this
30636 automatically. The idea is to place near the end of your file
30637 a few lines that look like this:
30640 --- Local Variables: ---
30641 --- eval:(calc-embedded-activate) ---
30646 where the leading and trailing @samp{---} can be replaced by
30647 any suitable strings (which must be the same on all three lines)
30648 or omitted altogether; in a @TeX{} or La@TeX{} file, @samp{%} would be a good
30649 leading string and no trailing string would be necessary. In a
30650 C program, @samp{/*} and @samp{*/} would be good leading and
30653 When Emacs loads a file into memory, it checks for a Local Variables
30654 section like this one at the end of the file. If it finds this
30655 section, it does the specified things (in this case, running
30656 @kbd{C-x * a} automatically) before editing of the file begins.
30657 The Local Variables section must be within 3000 characters of the
30658 end of the file for Emacs to find it, and it must be in the last
30659 page of the file if the file has any page separators.
30660 @xref{File Variables, , Local Variables in Files, emacs, the
30663 Note that @kbd{C-x * a} does not update the formulas it finds.
30664 To do this, type, say, @kbd{M-1 C-x * u} after @w{@kbd{C-x * a}}.
30665 Generally this should not be a problem, though, because the
30666 formulas will have been up-to-date already when the file was
30669 Normally, @kbd{C-x * a} activates all the formulas it finds, but
30670 any previous active formulas remain active as well. With a
30671 positive numeric prefix argument, @kbd{C-x * a} first deactivates
30672 all current active formulas, then actives the ones it finds in
30673 its scan of the buffer. With a negative prefix argument,
30674 @kbd{C-x * a} simply deactivates all formulas.
30676 Embedded mode has two symbols, @samp{Active} and @samp{~Active},
30677 which it puts next to the major mode name in a buffer's mode line.
30678 It puts @samp{Active} if it has reason to believe that all
30679 formulas in the buffer are active, because you have typed @kbd{C-x * a}
30680 and Calc has not since had to deactivate any formulas (which can
30681 happen if Calc goes to update an @samp{=>} formula somewhere because
30682 a variable changed, and finds that the formula is no longer there
30683 due to some kind of editing outside of Embedded mode). Calc puts
30684 @samp{~Active} in the mode line if some, but probably not all,
30685 formulas in the buffer are active. This happens if you activate
30686 a few formulas one at a time but never use @kbd{C-x * a}, or if you
30687 used @kbd{C-x * a} but then Calc had to deactivate a formula
30688 because it lost track of it. If neither of these symbols appears
30689 in the mode line, no embedded formulas are active in the buffer
30690 (e.g., before Embedded mode has been used, or after a @kbd{M-- C-x * a}).
30692 Embedded formulas can refer to assignments both before and after them
30693 in the buffer. If there are several assignments to a variable, the
30694 nearest preceding assignment is used if there is one, otherwise the
30695 following assignment is used.
30709 As well as simple variables, you can also assign to subscript
30710 expressions of the form @samp{@var{var}_@var{number}} (as in
30711 @code{x_0}), or @samp{@var{var}_@var{var}} (as in @code{x_max}).
30712 Assignments to other kinds of objects can be represented by Calc,
30713 but the automatic linkage between assignments and references works
30714 only for plain variables and these two kinds of subscript expressions.
30716 If there are no assignments to a given variable, the global
30717 stored value for the variable is used (@pxref{Storing Variables}),
30718 or, if no value is stored, the variable is left in symbolic form.
30719 Note that global stored values will be lost when the file is saved
30720 and loaded in a later Emacs session, unless you have used the
30721 @kbd{s p} (@code{calc-permanent-variable}) command to save them;
30722 @pxref{Operations on Variables}.
30724 The @kbd{m C} (@code{calc-auto-recompute}) command turns automatic
30725 recomputation of @samp{=>} forms on and off. If you turn automatic
30726 recomputation off, you will have to use @kbd{C-x * u} to update these
30727 formulas manually after an assignment has been changed. If you
30728 plan to change several assignments at once, it may be more efficient
30729 to type @kbd{m C}, change all the assignments, then use @kbd{M-1 C-x * u}
30730 to update the entire buffer afterwards. The @kbd{m C} command also
30731 controls @samp{=>} formulas on the stack; @pxref{Evaluates-To
30732 Operator}. When you turn automatic recomputation back on, the
30733 stack will be updated but the Embedded buffer will not; you must
30734 use @kbd{C-x * u} to update the buffer by hand.
30736 @node Mode Settings in Embedded Mode, Customizing Embedded Mode, Assignments in Embedded Mode, Embedded Mode
30737 @section Mode Settings in Embedded Mode
30740 @pindex calc-embedded-preserve-modes
30742 The mode settings can be changed while Calc is in embedded mode, but
30743 by default they will revert to their original values when embedded mode
30744 is ended. However, the modes saved when the mode-recording mode is
30745 @code{Save} (see below) and the modes in effect when the @kbd{m e}
30746 (@code{calc-embedded-preserve-modes}) command is given
30747 will be preserved when embedded mode is ended.
30749 Embedded mode has a rather complicated mechanism for handling mode
30750 settings in Embedded formulas. It is possible to put annotations
30751 in the file that specify mode settings either global to the entire
30752 file or local to a particular formula or formulas. In the latter
30753 case, different modes can be specified for use when a formula
30754 is the enabled Embedded mode formula.
30756 When you give any mode-setting command, like @kbd{m f} (for Fraction
30757 mode) or @kbd{d s} (for scientific notation), Embedded mode adds
30758 a line like the following one to the file just before the opening
30759 delimiter of the formula.
30762 % [calc-mode: fractions: t]
30763 % [calc-mode: float-format: (sci 0)]
30766 When Calc interprets an embedded formula, it scans the text before
30767 the formula for mode-setting annotations like these and sets the
30768 Calc buffer to match these modes. Modes not explicitly described
30769 in the file are not changed. Calc scans all the way to the top of
30770 the file, or up to a line of the form
30777 which you can insert at strategic places in the file if this backward
30778 scan is getting too slow, or just to provide a barrier between one
30779 ``zone'' of mode settings and another.
30781 If the file contains several annotations for the same mode, the
30782 closest one before the formula is used. Annotations after the
30783 formula are never used (except for global annotations, described
30786 The scan does not look for the leading @samp{% }, only for the
30787 square brackets and the text they enclose. In fact, the leading
30788 characters are different for different major modes. You can edit the
30789 mode annotations to a style that works better in context if you wish.
30790 @xref{Customizing Embedded Mode}, to see how to change the style
30791 that Calc uses when it generates the annotations. You can write
30792 mode annotations into the file yourself if you know the syntax;
30793 the easiest way to find the syntax for a given mode is to let
30794 Calc write the annotation for it once and see what it does.
30796 If you give a mode-changing command for a mode that already has
30797 a suitable annotation just above the current formula, Calc will
30798 modify that annotation rather than generating a new, conflicting
30801 Mode annotations have three parts, separated by colons. (Spaces
30802 after the colons are optional.) The first identifies the kind
30803 of mode setting, the second is a name for the mode itself, and
30804 the third is the value in the form of a Lisp symbol, number,
30805 or list. Annotations with unrecognizable text in the first or
30806 second parts are ignored. The third part is not checked to make
30807 sure the value is of a valid type or range; if you write an
30808 annotation by hand, be sure to give a proper value or results
30809 will be unpredictable. Mode-setting annotations are case-sensitive.
30811 While Embedded mode is enabled, the word @code{Local} appears in
30812 the mode line. This is to show that mode setting commands generate
30813 annotations that are ``local'' to the current formula or set of
30814 formulas. The @kbd{m R} (@code{calc-mode-record-mode}) command
30815 causes Calc to generate different kinds of annotations. Pressing
30816 @kbd{m R} repeatedly cycles through the possible modes.
30818 @code{LocEdit} and @code{LocPerm} modes generate annotations
30819 that look like this, respectively:
30822 % [calc-edit-mode: float-format: (sci 0)]
30823 % [calc-perm-mode: float-format: (sci 5)]
30826 The first kind of annotation will be used only while a formula
30827 is enabled in Embedded mode. The second kind will be used only
30828 when the formula is @emph{not} enabled. (Whether the formula
30829 is ``active'' or not, i.e., whether Calc has seen this formula
30830 yet, is not relevant here.)
30832 @code{Global} mode generates an annotation like this at the end
30836 % [calc-global-mode: fractions t]
30839 Global mode annotations affect all formulas throughout the file,
30840 and may appear anywhere in the file. This allows you to tuck your
30841 mode annotations somewhere out of the way, say, on a new page of
30842 the file, as long as those mode settings are suitable for all
30843 formulas in the file.
30845 Enabling a formula with @kbd{C-x * e} causes a fresh scan for local
30846 mode annotations; you will have to use this after adding annotations
30847 above a formula by hand to get the formula to notice them. Updating
30848 a formula with @kbd{C-x * u} will also re-scan the local modes, but
30849 global modes are only re-scanned by @kbd{C-x * a}.
30851 Another way that modes can get out of date is if you add a local
30852 mode annotation to a formula that has another formula after it.
30853 In this example, we have used the @kbd{d s} command while the
30854 first of the two embedded formulas is active. But the second
30855 formula has not changed its style to match, even though by the
30856 rules of reading annotations the @samp{(sci 0)} applies to it, too.
30859 % [calc-mode: float-format: (sci 0)]
30865 We would have to go down to the other formula and press @kbd{C-x * u}
30866 on it in order to get it to notice the new annotation.
30868 Two more mode-recording modes selectable by @kbd{m R} are available
30869 which are also available outside of Embedded mode.
30870 (@pxref{General Mode Commands}.) They are @code{Save}, in which mode
30871 settings are recorded permanently in your Calc init file (the file given
30872 by the variable @code{calc-settings-file}, typically @file{~/.emacs.d/calc.el})
30873 rather than by annotating the current document, and no-recording
30874 mode (where there is no symbol like @code{Save} or @code{Local} in
30875 the mode line), in which mode-changing commands do not leave any
30876 annotations at all.
30878 When Embedded mode is not enabled, mode-recording modes except
30879 for @code{Save} have no effect.
30881 @node Customizing Embedded Mode, , Mode Settings in Embedded Mode, Embedded Mode
30882 @section Customizing Embedded Mode
30885 You can modify Embedded mode's behavior by setting various Lisp
30886 variables described here. These variables are customizable
30887 (@pxref{Customizing Calc}), or you can use @kbd{M-x set-variable}
30888 or @kbd{M-x edit-options} to adjust a variable on the fly.
30889 (Another possibility would be to use a file-local variable annotation at
30890 the end of the file;
30891 @pxref{File Variables, , Local Variables in Files, emacs, the Emacs manual}.)
30892 Many of the variables given mentioned here can be set to depend on the
30893 major mode of the editing buffer (@pxref{Customizing Calc}).
30895 @vindex calc-embedded-open-formula
30896 The @code{calc-embedded-open-formula} variable holds a regular
30897 expression for the opening delimiter of a formula. @xref{Regexp Search,
30898 , Regular Expression Search, emacs, the Emacs manual}, to see
30899 how regular expressions work. Basically, a regular expression is a
30900 pattern that Calc can search for. A regular expression that considers
30901 blank lines, @samp{$}, and @samp{$$} to be opening delimiters is
30902 @code{"\\`\\|^\n\\|\\$\\$?"}. Just in case the meaning of this
30903 regular expression is not completely plain, let's go through it
30906 The surrounding @samp{" "} marks quote the text between them as a
30907 Lisp string. If you left them off, @code{set-variable} or
30908 @code{edit-options} would try to read the regular expression as a
30911 The most obvious property of this regular expression is that it
30912 contains indecently many backslashes. There are actually two levels
30913 of backslash usage going on here. First, when Lisp reads a quoted
30914 string, all pairs of characters beginning with a backslash are
30915 interpreted as special characters. Here, @code{\n} changes to a
30916 new-line character, and @code{\\} changes to a single backslash.
30917 So the actual regular expression seen by Calc is
30918 @samp{\`\|^ @r{(newline)} \|\$\$?}.
30920 Regular expressions also consider pairs beginning with backslash
30921 to have special meanings. Sometimes the backslash is used to quote
30922 a character that otherwise would have a special meaning in a regular
30923 expression, like @samp{$}, which normally means ``end-of-line,''
30924 or @samp{?}, which means that the preceding item is optional. So
30925 @samp{\$\$?} matches either one or two dollar signs.
30927 The other codes in this regular expression are @samp{^}, which matches
30928 ``beginning-of-line,'' @samp{\|}, which means ``or,'' and @samp{\`},
30929 which matches ``beginning-of-buffer.'' So the whole pattern means
30930 that a formula begins at the beginning of the buffer, or on a newline
30931 that occurs at the beginning of a line (i.e., a blank line), or at
30932 one or two dollar signs.
30934 The default value of @code{calc-embedded-open-formula} looks just
30935 like this example, with several more alternatives added on to
30936 recognize various other common kinds of delimiters.
30938 By the way, the reason to use @samp{^\n} rather than @samp{^$}
30939 or @samp{\n\n}, which also would appear to match blank lines,
30940 is that the former expression actually ``consumes'' only one
30941 newline character as @emph{part of} the delimiter, whereas the
30942 latter expressions consume zero or two newlines, respectively.
30943 The former choice gives the most natural behavior when Calc
30944 must operate on a whole formula including its delimiters.
30946 See the Emacs manual for complete details on regular expressions.
30947 But just for your convenience, here is a list of all characters
30948 which must be quoted with backslash (like @samp{\$}) to avoid
30949 some special interpretation: @samp{. * + ? [ ] ^ $ \}. (Note
30950 the backslash in this list; for example, to match @samp{\[} you
30951 must use @code{"\\\\\\["}. An exercise for the reader is to
30952 account for each of these six backslashes!)
30954 @vindex calc-embedded-close-formula
30955 The @code{calc-embedded-close-formula} variable holds a regular
30956 expression for the closing delimiter of a formula. A closing
30957 regular expression to match the above example would be
30958 @code{"\\'\\|\n$\\|\\$\\$?"}. This is almost the same as the
30959 other one, except it now uses @samp{\'} (``end-of-buffer'') and
30960 @samp{\n$} (newline occurring at end of line, yet another way
30961 of describing a blank line that is more appropriate for this
30964 @vindex calc-embedded-word-regexp
30965 The @code{calc-embedded-word-regexp} variable holds a regular expression
30966 used to define an expression to look for (a ``word'') when you type
30967 @kbd{C-x * w} to enable Embedded mode.
30969 @vindex calc-embedded-open-plain
30970 The @code{calc-embedded-open-plain} variable is a string which
30971 begins a ``plain'' formula written in front of the formatted
30972 formula when @kbd{d p} mode is turned on. Note that this is an
30973 actual string, not a regular expression, because Calc must be able
30974 to write this string into a buffer as well as to recognize it.
30975 The default string is @code{"%%% "} (note the trailing space), but may
30976 be different for certain major modes.
30978 @vindex calc-embedded-close-plain
30979 The @code{calc-embedded-close-plain} variable is a string which
30980 ends a ``plain'' formula. The default is @code{" %%%\n"}, but may be
30981 different for different major modes. Without
30982 the trailing newline here, the first line of a Big mode formula
30983 that followed might be shifted over with respect to the other lines.
30985 @vindex calc-embedded-open-new-formula
30986 The @code{calc-embedded-open-new-formula} variable is a string
30987 which is inserted at the front of a new formula when you type
30988 @kbd{C-x * f}. Its default value is @code{"\n\n"}. If this
30989 string begins with a newline character and the @kbd{C-x * f} is
30990 typed at the beginning of a line, @kbd{C-x * f} will skip this
30991 first newline to avoid introducing unnecessary blank lines in
30994 @vindex calc-embedded-close-new-formula
30995 The @code{calc-embedded-close-new-formula} variable is the corresponding
30996 string which is inserted at the end of a new formula. Its default
30997 value is also @code{"\n\n"}. The final newline is omitted by
30998 @w{@kbd{C-x * f}} if typed at the end of a line. (It follows that if
30999 @kbd{C-x * f} is typed on a blank line, both a leading opening
31000 newline and a trailing closing newline are omitted.)
31002 @vindex calc-embedded-announce-formula
31003 The @code{calc-embedded-announce-formula} variable is a regular
31004 expression which is sure to be followed by an embedded formula.
31005 The @kbd{C-x * a} command searches for this pattern as well as for
31006 @samp{=>} and @samp{:=} operators. Note that @kbd{C-x * a} will
31007 not activate just anything surrounded by formula delimiters; after
31008 all, blank lines are considered formula delimiters by default!
31009 But if your language includes a delimiter which can only occur
31010 actually in front of a formula, you can take advantage of it here.
31011 The default pattern is @code{"%Embed\n\\(% .*\n\\)*"}, but may be
31012 different for different major modes.
31013 This pattern will check for @samp{%Embed} followed by any number of
31014 lines beginning with @samp{%} and a space. This last is important to
31015 make Calc consider mode annotations part of the pattern, so that the
31016 formula's opening delimiter really is sure to follow the pattern.
31018 @vindex calc-embedded-open-mode
31019 The @code{calc-embedded-open-mode} variable is a string (not a
31020 regular expression) which should precede a mode annotation.
31021 Calc never scans for this string; Calc always looks for the
31022 annotation itself. But this is the string that is inserted before
31023 the opening bracket when Calc adds an annotation on its own.
31024 The default is @code{"% "}, but may be different for different major
31027 @vindex calc-embedded-close-mode
31028 The @code{calc-embedded-close-mode} variable is a string which
31029 follows a mode annotation written by Calc. Its default value
31030 is simply a newline, @code{"\n"}, but may be different for different
31031 major modes. If you change this, it is a good idea still to end with a
31032 newline so that mode annotations will appear on lines by themselves.
31034 @node Programming, Copying, Embedded Mode, Top
31035 @chapter Programming
31038 There are several ways to ``program'' the Emacs Calculator, depending
31039 on the nature of the problem you need to solve.
31043 @dfn{Keyboard macros} allow you to record a sequence of keystrokes
31044 and play them back at a later time. This is just the standard Emacs
31045 keyboard macro mechanism, dressed up with a few more features such
31046 as loops and conditionals.
31049 @dfn{Algebraic definitions} allow you to use any formula to define a
31050 new function. This function can then be used in algebraic formulas or
31051 as an interactive command.
31054 @dfn{Rewrite rules} are discussed in the section on algebra commands.
31055 @xref{Rewrite Rules}. If you put your rewrite rules in the variable
31056 @code{EvalRules}, they will be applied automatically to all Calc
31057 results in just the same way as an internal ``rule'' is applied to
31058 evaluate @samp{sqrt(9)} to 3 and so on. @xref{Automatic Rewrites}.
31061 @dfn{Lisp} is the programming language that Calc (and most of Emacs)
31062 is written in. If the above techniques aren't powerful enough, you
31063 can write Lisp functions to do anything that built-in Calc commands
31064 can do. Lisp code is also somewhat faster than keyboard macros or
31069 Programming features are available through the @kbd{z} and @kbd{Z}
31070 prefix keys. New commands that you define are two-key sequences
31071 beginning with @kbd{z}. Commands for managing these definitions
31072 use the shift-@kbd{Z} prefix. (The @kbd{Z T} (@code{calc-timing})
31073 command is described elsewhere; @pxref{Troubleshooting Commands}.
31074 The @kbd{Z C} (@code{calc-user-define-composition}) command is also
31075 described elsewhere; @pxref{User-Defined Compositions}.)
31078 * Creating User Keys::
31079 * Keyboard Macros::
31080 * Invocation Macros::
31081 * Algebraic Definitions::
31082 * Lisp Definitions::
31085 @node Creating User Keys, Keyboard Macros, Programming, Programming
31086 @section Creating User Keys
31090 @pindex calc-user-define
31091 Any Calculator command may be bound to a key using the @kbd{Z D}
31092 (@code{calc-user-define}) command. Actually, it is bound to a two-key
31093 sequence beginning with the lower-case @kbd{z} prefix.
31095 The @kbd{Z D} command first prompts for the key to define. For example,
31096 press @kbd{Z D a} to define the new key sequence @kbd{z a}. You are then
31097 prompted for the name of the Calculator command that this key should
31098 run. For example, the @code{calc-sincos} command is not normally
31099 available on a key. Typing @kbd{Z D s sincos @key{RET}} programs the
31100 @kbd{z s} key sequence to run @code{calc-sincos}. This definition will remain
31101 in effect for the rest of this Emacs session, or until you redefine
31102 @kbd{z s} to be something else.
31104 You can actually bind any Emacs command to a @kbd{z} key sequence by
31105 backspacing over the @samp{calc-} when you are prompted for the command name.
31107 As with any other prefix key, you can type @kbd{z ?} to see a list of
31108 all the two-key sequences you have defined that start with @kbd{z}.
31109 Initially, no @kbd{z} sequences (except @kbd{z ?} itself) are defined.
31111 User keys are typically letters, but may in fact be any key.
31112 (@key{META}-keys are not permitted, nor are a terminal's special
31113 function keys which generate multi-character sequences when pressed.)
31114 You can define different commands on the shifted and unshifted versions
31115 of a letter if you wish.
31118 @pindex calc-user-undefine
31119 The @kbd{Z U} (@code{calc-user-undefine}) command unbinds a user key.
31120 For example, the key sequence @kbd{Z U s} will undefine the @code{sincos}
31121 key we defined above.
31124 @pindex calc-user-define-permanent
31125 @cindex Storing user definitions
31126 @cindex Permanent user definitions
31127 @cindex Calc init file, user-defined commands
31128 The @kbd{Z P} (@code{calc-user-define-permanent}) command makes a key
31129 binding permanent so that it will remain in effect even in future Emacs
31130 sessions. (It does this by adding a suitable bit of Lisp code into
31131 your Calc init file; that is, the file given by the variable
31132 @code{calc-settings-file}, typically @file{~/.emacs.d/calc.el}.) For example,
31133 @kbd{Z P s} would register our @code{sincos} command permanently. If
31134 you later wish to unregister this command you must edit your Calc init
31135 file by hand. (@xref{General Mode Commands}, for a way to tell Calc to
31136 use a different file for the Calc init file.)
31138 The @kbd{Z P} command also saves the user definition, if any, for the
31139 command bound to the key. After @kbd{Z F} and @kbd{Z C}, a given user
31140 key could invoke a command, which in turn calls an algebraic function,
31141 which might have one or more special display formats. A single @kbd{Z P}
31142 command will save all of these definitions.
31143 To save an algebraic function, type @kbd{'} (the apostrophe)
31144 when prompted for a key, and type the function name. To save a command
31145 without its key binding, type @kbd{M-x} and enter a function name. (The
31146 @samp{calc-} prefix will automatically be inserted for you.)
31147 (If the command you give implies a function, the function will be saved,
31148 and if the function has any display formats, those will be saved, but
31149 not the other way around: Saving a function will not save any commands
31150 or key bindings associated with the function.)
31153 @pindex calc-user-define-edit
31154 @cindex Editing user definitions
31155 The @kbd{Z E} (@code{calc-user-define-edit}) command edits the definition
31156 of a user key. This works for keys that have been defined by either
31157 keyboard macros or formulas; further details are contained in the relevant
31158 following sections.
31160 @node Keyboard Macros, Invocation Macros, Creating User Keys, Programming
31161 @section Programming with Keyboard Macros
31165 @cindex Programming with keyboard macros
31166 @cindex Keyboard macros
31167 The easiest way to ``program'' the Emacs Calculator is to use standard
31168 keyboard macros. Press @w{@kbd{C-x (}} to begin recording a macro. From
31169 this point on, keystrokes you type will be saved away as well as
31170 performing their usual functions. Press @kbd{C-x )} to end recording.
31171 Press shift-@kbd{X} (or the standard Emacs key sequence @kbd{C-x e}) to
31172 execute your keyboard macro by replaying the recorded keystrokes.
31173 @xref{Keyboard Macros, , , emacs, the Emacs Manual}, for further
31176 When you use @kbd{X} to invoke a keyboard macro, the entire macro is
31177 treated as a single command by the undo and trail features. The stack
31178 display buffer is not updated during macro execution, but is instead
31179 fixed up once the macro completes. Thus, commands defined with keyboard
31180 macros are convenient and efficient. The @kbd{C-x e} command, on the
31181 other hand, invokes the keyboard macro with no special treatment: Each
31182 command in the macro will record its own undo information and trail entry,
31183 and update the stack buffer accordingly. If your macro uses features
31184 outside of Calc's control to operate on the contents of the Calc stack
31185 buffer, or if it includes Undo, Redo, or last-arguments commands, you
31186 must use @kbd{C-x e} to make sure the buffer and undo list are up-to-date
31187 at all times. You could also consider using @kbd{K} (@code{calc-keep-args})
31188 instead of @kbd{M-@key{RET}} (@code{calc-last-args}).
31190 Calc extends the standard Emacs keyboard macros in several ways.
31191 Keyboard macros can be used to create user-defined commands. Keyboard
31192 macros can include conditional and iteration structures, somewhat
31193 analogous to those provided by a traditional programmable calculator.
31196 * Naming Keyboard Macros::
31197 * Conditionals in Macros::
31198 * Loops in Macros::
31199 * Local Values in Macros::
31200 * Queries in Macros::
31203 @node Naming Keyboard Macros, Conditionals in Macros, Keyboard Macros, Keyboard Macros
31204 @subsection Naming Keyboard Macros
31208 @pindex calc-user-define-kbd-macro
31209 Once you have defined a keyboard macro, you can bind it to a @kbd{z}
31210 key sequence with the @kbd{Z K} (@code{calc-user-define-kbd-macro}) command.
31211 This command prompts first for a key, then for a command name. For
31212 example, if you type @kbd{C-x ( n @key{TAB} n @key{TAB} C-x )} you will
31213 define a keyboard macro which negates the top two numbers on the stack
31214 (@key{TAB} swaps the top two stack elements). Now you can type
31215 @kbd{Z K n @key{RET}} to define this keyboard macro onto the @kbd{z n} key
31216 sequence. The default command name (if you answer the second prompt with
31217 just the @key{RET} key as in this example) will be something like
31218 @samp{calc-User-n}. The keyboard macro will now be available as both
31219 @kbd{z n} and @kbd{M-x calc-User-n}. You can backspace and enter a more
31220 descriptive command name if you wish.
31222 Macros defined by @kbd{Z K} act like single commands; they are executed
31223 in the same way as by the @kbd{X} key. If you wish to define the macro
31224 as a standard no-frills Emacs macro (to be executed as if by @kbd{C-x e}),
31225 give a negative prefix argument to @kbd{Z K}.
31227 Once you have bound your keyboard macro to a key, you can use
31228 @kbd{Z P} to register it permanently with Emacs. @xref{Creating User Keys}.
31230 @cindex Keyboard macros, editing
31231 The @kbd{Z E} (@code{calc-user-define-edit}) command on a key that has
31232 been defined by a keyboard macro tries to use the @code{edmacro} package
31233 edit the macro. Type @kbd{C-c C-c} to finish editing and update
31234 the definition stored on the key, or, to cancel the edit, kill the
31235 buffer with @kbd{C-x k}.
31236 The special characters @code{RET}, @code{LFD}, @code{TAB}, @code{SPC},
31237 @code{DEL}, and @code{NUL} must be entered as these three character
31238 sequences, written in all uppercase, as must the prefixes @code{C-} and
31239 @code{M-}. Spaces and line breaks are ignored. Other characters are
31240 copied verbatim into the keyboard macro. Basically, the notation is the
31241 same as is used in all of this manual's examples, except that the manual
31242 takes some liberties with spaces: When we say @kbd{' [1 2 3] @key{RET}},
31243 we take it for granted that it is clear we really mean
31244 @kbd{' [1 @key{SPC} 2 @key{SPC} 3] @key{RET}}.
31247 @pindex read-kbd-macro
31248 The @kbd{C-x * m} (@code{read-kbd-macro}) command reads an Emacs ``region''
31249 of spelled-out keystrokes and defines it as the current keyboard macro.
31250 It is a convenient way to define a keyboard macro that has been stored
31251 in a file, or to define a macro without executing it at the same time.
31253 @node Conditionals in Macros, Loops in Macros, Naming Keyboard Macros, Keyboard Macros
31254 @subsection Conditionals in Keyboard Macros
31259 @pindex calc-kbd-if
31260 @pindex calc-kbd-else
31261 @pindex calc-kbd-else-if
31262 @pindex calc-kbd-end-if
31263 @cindex Conditional structures
31264 The @kbd{Z [} (@code{calc-kbd-if}) and @kbd{Z ]} (@code{calc-kbd-end-if})
31265 commands allow you to put simple tests in a keyboard macro. When Calc
31266 sees the @kbd{Z [}, it pops an object from the stack and, if the object is
31267 a non-zero value, continues executing keystrokes. But if the object is
31268 zero, or if it is not provably nonzero, Calc skips ahead to the matching
31269 @kbd{Z ]} keystroke. @xref{Logical Operations}, for a set of commands for
31270 performing tests which conveniently produce 1 for true and 0 for false.
31272 For example, @kbd{@key{RET} 0 a < Z [ n Z ]} implements an absolute-value
31273 function in the form of a keyboard macro. This macro duplicates the
31274 number on the top of the stack, pushes zero and compares using @kbd{a <}
31275 (@code{calc-less-than}), then, if the number was less than zero,
31276 executes @kbd{n} (@code{calc-change-sign}). Otherwise, the change-sign
31277 command is skipped.
31279 To program this macro, type @kbd{C-x (}, type the above sequence of
31280 keystrokes, then type @kbd{C-x )}. Note that the keystrokes will be
31281 executed while you are making the definition as well as when you later
31282 re-execute the macro by typing @kbd{X}. Thus you should make sure a
31283 suitable number is on the stack before defining the macro so that you
31284 don't get a stack-underflow error during the definition process.
31286 Conditionals can be nested arbitrarily. However, there should be exactly
31287 one @kbd{Z ]} for each @kbd{Z [} in a keyboard macro.
31290 The @kbd{Z :} (@code{calc-kbd-else}) command allows you to choose between
31291 two keystroke sequences. The general format is @kbd{@var{cond} Z [
31292 @var{then-part} Z : @var{else-part} Z ]}. If @var{cond} is true
31293 (i.e., if the top of stack contains a non-zero number after @var{cond}
31294 has been executed), the @var{then-part} will be executed and the
31295 @var{else-part} will be skipped. Otherwise, the @var{then-part} will
31296 be skipped and the @var{else-part} will be executed.
31299 The @kbd{Z |} (@code{calc-kbd-else-if}) command allows you to choose
31300 between any number of alternatives. For example,
31301 @kbd{@var{cond1} Z [ @var{part1} Z : @var{cond2} Z | @var{part2} Z :
31302 @var{part3} Z ]} will execute @var{part1} if @var{cond1} is true,
31303 otherwise it will execute @var{part2} if @var{cond2} is true, otherwise
31304 it will execute @var{part3}.
31306 More precisely, @kbd{Z [} pops a number and conditionally skips to the
31307 next matching @kbd{Z :} or @kbd{Z ]} key. @w{@kbd{Z ]}} has no effect when
31308 actually executed. @kbd{Z :} skips to the next matching @kbd{Z ]}.
31309 @kbd{Z |} pops a number and conditionally skips to the next matching
31310 @kbd{Z :} or @kbd{Z ]}; thus, @kbd{Z [} and @kbd{Z |} are functionally
31311 equivalent except that @kbd{Z [} participates in nesting but @kbd{Z |}
31314 Calc's conditional and looping constructs work by scanning the
31315 keyboard macro for occurrences of character sequences like @samp{Z:}
31316 and @samp{Z]}. One side-effect of this is that if you use these
31317 constructs you must be careful that these character pairs do not
31318 occur by accident in other parts of the macros. Since Calc rarely
31319 uses shift-@kbd{Z} for any purpose except as a prefix character, this
31320 is not likely to be a problem. Another side-effect is that it will
31321 not work to define your own custom key bindings for these commands.
31322 Only the standard shift-@kbd{Z} bindings will work correctly.
31325 If Calc gets stuck while skipping characters during the definition of a
31326 macro, type @kbd{Z C-g} to cancel the definition. (Typing plain @kbd{C-g}
31327 actually adds a @kbd{C-g} keystroke to the macro.)
31329 @node Loops in Macros, Local Values in Macros, Conditionals in Macros, Keyboard Macros
31330 @subsection Loops in Keyboard Macros
31335 @pindex calc-kbd-repeat
31336 @pindex calc-kbd-end-repeat
31337 @cindex Looping structures
31338 @cindex Iterative structures
31339 The @kbd{Z <} (@code{calc-kbd-repeat}) and @kbd{Z >}
31340 (@code{calc-kbd-end-repeat}) commands pop a number from the stack,
31341 which must be an integer, then repeat the keystrokes between the brackets
31342 the specified number of times. If the integer is zero or negative, the
31343 body is skipped altogether. For example, @kbd{1 @key{TAB} Z < 2 * Z >}
31344 computes two to a nonnegative integer power. First, we push 1 on the
31345 stack and then swap the integer argument back to the top. The @kbd{Z <}
31346 pops that argument leaving the 1 back on top of the stack. Then, we
31347 repeat a multiply-by-two step however many times.
31349 Once again, the keyboard macro is executed as it is being entered.
31350 In this case it is especially important to set up reasonable initial
31351 conditions before making the definition: Suppose the integer 1000 just
31352 happened to be sitting on the stack before we typed the above definition!
31353 Another approach is to enter a harmless dummy definition for the macro,
31354 then go back and edit in the real one with a @kbd{Z E} command. Yet
31355 another approach is to type the macro as written-out keystroke names
31356 in a buffer, then use @kbd{C-x * m} (@code{read-kbd-macro}) to read the
31361 The @kbd{Z /} (@code{calc-kbd-break}) command allows you to break out
31362 of a keyboard macro loop prematurely. It pops an object from the stack;
31363 if that object is true (a non-zero number), control jumps out of the
31364 innermost enclosing @kbd{Z <} @dots{} @kbd{Z >} loop and continues
31365 after the @kbd{Z >}. If the object is false, the @kbd{Z /} has no
31366 effect. Thus @kbd{@var{cond} Z /} is similar to @samp{if (@var{cond}) break;}
31371 @pindex calc-kbd-for
31372 @pindex calc-kbd-end-for
31373 The @kbd{Z (} (@code{calc-kbd-for}) and @kbd{Z )} (@code{calc-kbd-end-for})
31374 commands are similar to @kbd{Z <} and @kbd{Z >}, except that they make the
31375 value of the counter available inside the loop. The general layout is
31376 @kbd{@var{init} @var{final} Z ( @var{body} @var{step} Z )}. The @kbd{Z (}
31377 command pops initial and final values from the stack. It then creates
31378 a temporary internal counter and initializes it with the value @var{init}.
31379 The @kbd{Z (} command then repeatedly pushes the counter value onto the
31380 stack and executes @var{body} and @var{step}, adding @var{step} to the
31381 counter each time until the loop finishes.
31383 @cindex Summations (by keyboard macros)
31384 By default, the loop finishes when the counter becomes greater than (or
31385 less than) @var{final}, assuming @var{initial} is less than (greater
31386 than) @var{final}. If @var{initial} is equal to @var{final}, the body
31387 executes exactly once. The body of the loop always executes at least
31388 once. For example, @kbd{0 1 10 Z ( 2 ^ + 1 Z )} computes the sum of the
31389 squares of the integers from 1 to 10, in steps of 1.
31391 If you give a numeric prefix argument of 1 to @kbd{Z (}, the loop is
31392 forced to use upward-counting conventions. In this case, if @var{initial}
31393 is greater than @var{final} the body will not be executed at all.
31394 Note that @var{step} may still be negative in this loop; the prefix
31395 argument merely constrains the loop-finished test. Likewise, a prefix
31396 argument of @mathit{-1} forces downward-counting conventions.
31400 @pindex calc-kbd-loop
31401 @pindex calc-kbd-end-loop
31402 The @kbd{Z @{} (@code{calc-kbd-loop}) and @kbd{Z @}}
31403 (@code{calc-kbd-end-loop}) commands are similar to @kbd{Z <} and
31404 @kbd{Z >}, except that they do not pop a count from the stack---they
31405 effectively create an infinite loop. Every @kbd{Z @{} @dots{} @kbd{Z @}}
31406 loop ought to include at least one @kbd{Z /} to make sure the loop
31407 doesn't run forever. (If any error message occurs which causes Emacs
31408 to beep, the keyboard macro will also be halted; this is a standard
31409 feature of Emacs. You can also generally press @kbd{C-g} to halt a
31410 running keyboard macro, although not all versions of Unix support
31413 The conditional and looping constructs are not actually tied to
31414 keyboard macros, but they are most often used in that context.
31415 For example, the keystrokes @kbd{10 Z < 23 @key{RET} Z >} push
31416 ten copies of 23 onto the stack. This can be typed ``live'' just
31417 as easily as in a macro definition.
31419 @xref{Conditionals in Macros}, for some additional notes about
31420 conditional and looping commands.
31422 @node Local Values in Macros, Queries in Macros, Loops in Macros, Keyboard Macros
31423 @subsection Local Values in Macros
31426 @cindex Local variables
31427 @cindex Restoring saved modes
31428 Keyboard macros sometimes want to operate under known conditions
31429 without affecting surrounding conditions. For example, a keyboard
31430 macro may wish to turn on Fraction mode, or set a particular
31431 precision, independent of the user's normal setting for those
31436 @pindex calc-kbd-push
31437 @pindex calc-kbd-pop
31438 Macros also sometimes need to use local variables. Assignments to
31439 local variables inside the macro should not affect any variables
31440 outside the macro. The @kbd{Z `} (@code{calc-kbd-push}) and @kbd{Z '}
31441 (@code{calc-kbd-pop}) commands give you both of these capabilities.
31443 When you type @kbd{Z `} (with a backquote or accent grave character),
31444 the values of various mode settings are saved away. The ten ``quick''
31445 variables @code{q0} through @code{q9} are also saved. When
31446 you type @w{@kbd{Z '}} (with an apostrophe), these values are restored.
31447 Pairs of @kbd{Z `} and @kbd{Z '} commands may be nested.
31449 If a keyboard macro halts due to an error in between a @kbd{Z `} and
31450 a @kbd{Z '}, the saved values will be restored correctly even though
31451 the macro never reaches the @kbd{Z '} command. Thus you can use
31452 @kbd{Z `} and @kbd{Z '} without having to worry about what happens
31453 in exceptional conditions.
31455 If you type @kbd{Z `} ``live'' (not in a keyboard macro), Calc puts
31456 you into a ``recursive edit.'' You can tell you are in a recursive
31457 edit because there will be extra square brackets in the mode line,
31458 as in @samp{[(Calculator)]}. These brackets will go away when you
31459 type the matching @kbd{Z '} command. The modes and quick variables
31460 will be saved and restored in just the same way as if actual keyboard
31461 macros were involved.
31463 The modes saved by @kbd{Z `} and @kbd{Z '} are the current precision
31464 and binary word size, the angular mode (Deg, Rad, or HMS), the
31465 simplification mode, Algebraic mode, Symbolic mode, Infinite mode,
31466 Matrix or Scalar mode, Fraction mode, and the current complex mode
31467 (Polar or Rectangular). The ten ``quick'' variables' values (or lack
31468 thereof) are also saved.
31470 Most mode-setting commands act as toggles, but with a numeric prefix
31471 they force the mode either on (positive prefix) or off (negative
31472 or zero prefix). Since you don't know what the environment might
31473 be when you invoke your macro, it's best to use prefix arguments
31474 for all mode-setting commands inside the macro.
31476 In fact, @kbd{C-u Z `} is like @kbd{Z `} except that it sets the modes
31477 listed above to their default values. As usual, the matching @kbd{Z '}
31478 will restore the modes to their settings from before the @kbd{C-u Z `}.
31479 Also, @w{@kbd{Z `}} with a negative prefix argument resets the algebraic mode
31480 to its default (off) but leaves the other modes the same as they were
31481 outside the construct.
31483 The contents of the stack and trail, values of non-quick variables, and
31484 other settings such as the language mode and the various display modes,
31485 are @emph{not} affected by @kbd{Z `} and @kbd{Z '}.
31487 @node Queries in Macros, , Local Values in Macros, Keyboard Macros
31488 @subsection Queries in Keyboard Macros
31492 @c @pindex calc-kbd-report
31493 @c The @kbd{Z =} (@code{calc-kbd-report}) command displays an informative
31494 @c message including the value on the top of the stack. You are prompted
31495 @c to enter a string. That string, along with the top-of-stack value,
31496 @c is displayed unless @kbd{m w} (@code{calc-working}) has been used
31497 @c to turn such messages off.
31501 @pindex calc-kbd-query
31502 The @kbd{Z #} (@code{calc-kbd-query}) command prompts for an algebraic
31503 entry which takes its input from the keyboard, even during macro
31504 execution. All the normal conventions of algebraic input, including the
31505 use of @kbd{$} characters, are supported. The prompt message itself is
31506 taken from the top of the stack, and so must be entered (as a string)
31507 before the @kbd{Z #} command. (Recall, as a string it can be entered by
31508 pressing the @kbd{"} key and will appear as a vector when it is put on
31509 the stack. The prompt message is only put on the stack to provide a
31510 prompt for the @kbd{Z #} command; it will not play any role in any
31511 subsequent calculations.) This command allows your keyboard macros to
31512 accept numbers or formulas as interactive input.
31515 @kbd{2 @key{RET} "Power: " @key{RET} Z # 3 @key{RET} ^} will prompt for
31516 input with ``Power: '' in the minibuffer, then return 2 to the provided
31517 power. (The response to the prompt that's given, 3 in this example,
31518 will not be part of the macro.)
31520 @xref{Keyboard Macro Query, , , emacs, the Emacs Manual}, for a description of
31521 @kbd{C-x q} (@code{kbd-macro-query}), the standard Emacs way to accept
31522 keyboard input during a keyboard macro. In particular, you can use
31523 @kbd{C-x q} to enter a recursive edit, which allows the user to perform
31524 any Calculator operations interactively before pressing @kbd{C-M-c} to
31525 return control to the keyboard macro.
31527 @node Invocation Macros, Algebraic Definitions, Keyboard Macros, Programming
31528 @section Invocation Macros
31532 @pindex calc-user-invocation
31533 @pindex calc-user-define-invocation
31534 Calc provides one special keyboard macro, called up by @kbd{C-x * z}
31535 (@code{calc-user-invocation}), that is intended to allow you to define
31536 your own special way of starting Calc. To define this ``invocation
31537 macro,'' create the macro in the usual way with @kbd{C-x (} and
31538 @kbd{C-x )}, then type @kbd{Z I} (@code{calc-user-define-invocation}).
31539 There is only one invocation macro, so you don't need to type any
31540 additional letters after @kbd{Z I}. From now on, you can type
31541 @kbd{C-x * z} at any time to execute your invocation macro.
31543 For example, suppose you find yourself often grabbing rectangles of
31544 numbers into Calc and multiplying their columns. You can do this
31545 by typing @kbd{C-x * r} to grab, and @kbd{V R : *} to multiply columns.
31546 To make this into an invocation macro, just type @kbd{C-x ( C-x * r
31547 V R : * C-x )}, then @kbd{Z I}. Then, to multiply a rectangle of data,
31548 just mark the data in its buffer in the usual way and type @kbd{C-x * z}.
31550 Invocation macros are treated like regular Emacs keyboard macros;
31551 all the special features described above for @kbd{Z K}-style macros
31552 do not apply. @kbd{C-x * z} is just like @kbd{C-x e}, except that it
31553 uses the macro that was last stored by @kbd{Z I}. (In fact, the
31554 macro does not even have to have anything to do with Calc!)
31556 The @kbd{m m} command saves the last invocation macro defined by
31557 @kbd{Z I} along with all the other Calc mode settings.
31558 @xref{General Mode Commands}.
31560 @node Algebraic Definitions, Lisp Definitions, Invocation Macros, Programming
31561 @section Programming with Formulas
31565 @pindex calc-user-define-formula
31566 @cindex Programming with algebraic formulas
31567 Another way to create a new Calculator command uses algebraic formulas.
31568 The @kbd{Z F} (@code{calc-user-define-formula}) command stores the
31569 formula at the top of the stack as the definition for a key. This
31570 command prompts for five things: The key, the command name, the function
31571 name, the argument list, and the behavior of the command when given
31572 non-numeric arguments.
31574 For example, suppose we type @kbd{' a+2b @key{RET}} to push the formula
31575 @samp{a + 2*b} onto the stack. We now type @kbd{Z F m} to define this
31576 formula on the @kbd{z m} key sequence. The next prompt is for a command
31577 name, beginning with @samp{calc-}, which should be the long (@kbd{M-x}) form
31578 for the new command. If you simply press @key{RET}, a default name like
31579 @code{calc-User-m} will be constructed. In our example, suppose we enter
31580 @kbd{spam @key{RET}} to define the new command as @code{calc-spam}.
31582 If you want to give the formula a long-style name only, you can press
31583 @key{SPC} or @key{RET} when asked which single key to use. For example
31584 @kbd{Z F @key{RET} spam @key{RET}} defines the new command as
31585 @kbd{M-x calc-spam}, with no keyboard equivalent.
31587 The third prompt is for an algebraic function name. The default is to
31588 use the same name as the command name but without the @samp{calc-}
31589 prefix. (If this is of the form @samp{User-m}, the hyphen is removed so
31590 it won't be taken for a minus sign in algebraic formulas.)
31591 This is the name you will use if you want to enter your
31592 new function in an algebraic formula. Suppose we enter @kbd{yow @key{RET}}.
31593 Then the new function can be invoked by pushing two numbers on the
31594 stack and typing @kbd{z m} or @kbd{x spam}, or by entering the algebraic
31595 formula @samp{yow(x,y)}.
31597 The fourth prompt is for the function's argument list. This is used to
31598 associate values on the stack with the variables that appear in the formula.
31599 The default is a list of all variables which appear in the formula, sorted
31600 into alphabetical order. In our case, the default would be @samp{(a b)}.
31601 This means that, when the user types @kbd{z m}, the Calculator will remove
31602 two numbers from the stack, substitute these numbers for @samp{a} and
31603 @samp{b} (respectively) in the formula, then simplify the formula and
31604 push the result on the stack. In other words, @kbd{10 @key{RET} 100 z m}
31605 would replace the 10 and 100 on the stack with the number 210, which is
31606 @expr{a + 2 b} with @expr{a=10} and @expr{b=100}. Likewise, the formula
31607 @samp{yow(10, 100)} will be evaluated by substituting @expr{a=10} and
31608 @expr{b=100} in the definition.
31610 You can rearrange the order of the names before pressing @key{RET} to
31611 control which stack positions go to which variables in the formula. If
31612 you remove a variable from the argument list, that variable will be left
31613 in symbolic form by the command. Thus using an argument list of @samp{(b)}
31614 for our function would cause @kbd{10 z m} to replace the 10 on the stack
31615 with the formula @samp{a + 20}. If we had used an argument list of
31616 @samp{(b a)}, the result with inputs 10 and 100 would have been 120.
31618 You can also put a nameless function on the stack instead of just a
31619 formula, as in @samp{<a, b : a + 2 b>}. @xref{Specifying Operators}.
31620 In this example, the command will be defined by the formula @samp{a + 2 b}
31621 using the argument list @samp{(a b)}.
31623 The final prompt is a y-or-n question concerning what to do if symbolic
31624 arguments are given to your function. If you answer @kbd{y}, then
31625 executing @kbd{z m} (using the original argument list @samp{(a b)}) with
31626 arguments @expr{10} and @expr{x} will leave the function in symbolic
31627 form, i.e., @samp{yow(10,x)}. On the other hand, if you answer @kbd{n},
31628 then the formula will always be expanded, even for non-constant
31629 arguments: @samp{10 + 2 x}. If you never plan to feed algebraic
31630 formulas to your new function, it doesn't matter how you answer this
31633 If you answered @kbd{y} to this question you can still cause a function
31634 call to be expanded by typing @kbd{a "} (@code{calc-expand-formula}).
31635 Also, Calc will expand the function if necessary when you take a
31636 derivative or integral or solve an equation involving the function.
31639 @pindex calc-get-user-defn
31640 Once you have defined a formula on a key, you can retrieve this formula
31641 with the @kbd{Z G} (@code{calc-user-define-get-defn}) command. Press a
31642 key, and this command pushes the formula that was used to define that
31643 key onto the stack. Actually, it pushes a nameless function that
31644 specifies both the argument list and the defining formula. You will get
31645 an error message if the key is undefined, or if the key was not defined
31646 by a @kbd{Z F} command.
31648 The @kbd{Z E} (@code{calc-user-define-edit}) command on a key that has
31649 been defined by a formula uses a variant of the @code{calc-edit} command
31650 to edit the defining formula. Press @kbd{C-c C-c} to finish editing and
31651 store the new formula back in the definition, or kill the buffer with
31653 cancel the edit. (The argument list and other properties of the
31654 definition are unchanged; to adjust the argument list, you can use
31655 @kbd{Z G} to grab the function onto the stack, edit with @kbd{`}, and
31656 then re-execute the @kbd{Z F} command.)
31658 As usual, the @kbd{Z P} command records your definition permanently.
31659 In this case it will permanently record all three of the relevant
31660 definitions: the key, the command, and the function.
31662 You may find it useful to turn off the default simplifications with
31663 @kbd{m O} (@code{calc-no-simplify-mode}) when entering a formula to be
31664 used as a function definition. For example, the formula @samp{deriv(a^2,v)}
31665 which might be used to define a new function @samp{dsqr(a,v)} will be
31666 ``simplified'' to 0 immediately upon entry since @code{deriv} considers
31667 @expr{a} to be constant with respect to @expr{v}. Turning off
31668 default simplifications cures this problem: The definition will be stored
31669 in symbolic form without ever activating the @code{deriv} function. Press
31670 @kbd{m D} to turn the default simplifications back on afterwards.
31672 @node Lisp Definitions, , Algebraic Definitions, Programming
31673 @section Programming with Lisp
31676 The Calculator can be programmed quite extensively in Lisp. All you
31677 do is write a normal Lisp function definition, but with @code{defmath}
31678 in place of @code{defun}. This has the same form as @code{defun}, but it
31679 automagically replaces calls to standard Lisp functions like @code{+} and
31680 @code{zerop} with calls to the corresponding functions in Calc's own library.
31681 Thus you can write natural-looking Lisp code which operates on all of the
31682 standard Calculator data types. You can then use @kbd{Z D} if you wish to
31683 bind your new command to a @kbd{z}-prefix key sequence. The @kbd{Z E} command
31684 will not edit a Lisp-based definition.
31686 Emacs Lisp is described in the GNU Emacs Lisp Reference Manual. This section
31687 assumes a familiarity with Lisp programming concepts; if you do not know
31688 Lisp, you may find keyboard macros or rewrite rules to be an easier way
31689 to program the Calculator.
31691 This section first discusses ways to write commands, functions, or
31692 small programs to be executed inside of Calc. Then it discusses how
31693 your own separate programs are able to call Calc from the outside.
31694 Finally, there is a list of internal Calc functions and data structures
31695 for the true Lisp enthusiast.
31698 * Defining Functions::
31699 * Defining Simple Commands::
31700 * Defining Stack Commands::
31701 * Argument Qualifiers::
31702 * Example Definitions::
31704 * Calling Calc from Your Programs::
31708 @node Defining Functions, Defining Simple Commands, Lisp Definitions, Lisp Definitions
31709 @subsection Defining New Functions
31713 The @code{defmath} function (actually a Lisp macro) is like @code{defun}
31714 except that code in the body of the definition can make use of the full
31715 range of Calculator data types. The prefix @samp{calcFunc-} is added
31716 to the specified name to get the actual Lisp function name. As a simple
31720 (defmath myfact (n)
31722 (* n (myfact (1- n)))
31727 This actually expands to the code,
31730 (defun calcFunc-myfact (n)
31732 (math-mul n (calcFunc-myfact (math-add n -1)))
31737 This function can be used in algebraic expressions, e.g., @samp{myfact(5)}.
31739 The @samp{myfact} function as it is defined above has the bug that an
31740 expression @samp{myfact(a+b)} will be simplified to 1 because the
31741 formula @samp{a+b} is not considered to be @code{posp}. A robust
31742 factorial function would be written along the following lines:
31745 (defmath myfact (n)
31747 (* n (myfact (1- n)))
31750 nil))) ; this could be simplified as: (and (= n 0) 1)
31753 If a function returns @code{nil}, it is left unsimplified by the Calculator
31754 (except that its arguments will be simplified). Thus, @samp{myfact(a+1+2)}
31755 will be simplified to @samp{myfact(a+3)} but no further. Beware that every
31756 time the Calculator reexamines this formula it will attempt to resimplify
31757 it, so your function ought to detect the returning-@code{nil} case as
31758 efficiently as possible.
31760 The following standard Lisp functions are treated by @code{defmath}:
31761 @code{+}, @code{-}, @code{*}, @code{/}, @code{%}, @code{^} or
31762 @code{expt}, @code{=}, @code{<}, @code{>}, @code{<=}, @code{>=},
31763 @code{/=}, @code{1+}, @code{1-}, @code{logand}, @code{logior}, @code{logxor},
31764 @code{logandc2}, @code{lognot}. Also, @code{~=} is an abbreviation for
31765 @code{math-nearly-equal}, which is useful in implementing Taylor series.
31767 For other functions @var{func}, if a function by the name
31768 @samp{calcFunc-@var{func}} exists it is used, otherwise if a function by the
31769 name @samp{math-@var{func}} exists it is used, otherwise if @var{func} itself
31770 is defined as a function it is used, otherwise @samp{calcFunc-@var{func}} is
31771 used on the assumption that this is a to-be-defined math function. Also, if
31772 the function name is quoted as in @samp{('integerp a)} the function name is
31773 always used exactly as written (but not quoted).
31775 Variable names have @samp{var-} prepended to them unless they appear in
31776 the function's argument list or in an enclosing @code{let}, @code{let*},
31777 @code{for}, or @code{foreach} form,
31778 or their names already contain a @samp{-} character. Thus a reference to
31779 @samp{foo} is the same as a reference to @samp{var-foo}.
31781 A few other Lisp extensions are available in @code{defmath} definitions:
31785 The @code{elt} function accepts any number of index variables.
31786 Note that Calc vectors are stored as Lisp lists whose first
31787 element is the symbol @code{vec}; thus, @samp{(elt v 2)} yields
31788 the second element of vector @code{v}, and @samp{(elt m i j)}
31789 yields one element of a Calc matrix.
31792 The @code{setq} function has been extended to act like the Common
31793 Lisp @code{setf} function. (The name @code{setf} is recognized as
31794 a synonym of @code{setq}.) Specifically, the first argument of
31795 @code{setq} can be an @code{nth}, @code{elt}, @code{car}, or @code{cdr} form,
31796 in which case the effect is to store into the specified
31797 element of a list. Thus, @samp{(setq (elt m i j) x)} stores @expr{x}
31798 into one element of a matrix.
31801 A @code{for} looping construct is available. For example,
31802 @samp{(for ((i 0 10)) body)} executes @code{body} once for each
31803 binding of @expr{i} from zero to 10. This is like a @code{let}
31804 form in that @expr{i} is temporarily bound to the loop count
31805 without disturbing its value outside the @code{for} construct.
31806 Nested loops, as in @samp{(for ((i 0 10) (j 0 (1- i) 2)) body)},
31807 are also available. For each value of @expr{i} from zero to 10,
31808 @expr{j} counts from 0 to @expr{i-1} in steps of two. Note that
31809 @code{for} has the same general outline as @code{let*}, except
31810 that each element of the header is a list of three or four
31811 things, not just two.
31814 The @code{foreach} construct loops over elements of a list.
31815 For example, @samp{(foreach ((x (cdr v))) body)} executes
31816 @code{body} with @expr{x} bound to each element of Calc vector
31817 @expr{v} in turn. The purpose of @code{cdr} here is to skip over
31818 the initial @code{vec} symbol in the vector.
31821 The @code{break} function breaks out of the innermost enclosing
31822 @code{while}, @code{for}, or @code{foreach} loop. If given a
31823 value, as in @samp{(break x)}, this value is returned by the
31824 loop. (Lisp loops otherwise always return @code{nil}.)
31827 The @code{return} function prematurely returns from the enclosing
31828 function. For example, @samp{(return (+ x y))} returns @expr{x+y}
31829 as the value of a function. You can use @code{return} anywhere
31830 inside the body of the function.
31833 Non-integer numbers (and extremely large integers) cannot be included
31834 directly into a @code{defmath} definition. This is because the Lisp
31835 reader will fail to parse them long before @code{defmath} ever gets control.
31836 Instead, use the notation, @samp{:"3.1415"}. In fact, any algebraic
31837 formula can go between the quotes. For example,
31840 (defmath sqexp (x) ; sqexp(x) == sqrt(exp(x)) == exp(x*0.5)
31848 (defun calcFunc-sqexp (x)
31849 (and (math-numberp x)
31850 (calcFunc-exp (math-mul x '(float 5 -1)))))
31853 Note the use of @code{numberp} as a guard to ensure that the argument is
31854 a number first, returning @code{nil} if not. The exponential function
31855 could itself have been included in the expression, if we had preferred:
31856 @samp{:"exp(x * 0.5)"}. As another example, the multiplication-and-recursion
31857 step of @code{myfact} could have been written
31863 A good place to put your @code{defmath} commands is your Calc init file
31864 (the file given by @code{calc-settings-file}, typically
31865 @file{~/.emacs.d/calc.el}), which will not be loaded until Calc starts.
31866 If a file named @file{.emacs} exists in your home directory, Emacs reads
31867 and executes the Lisp forms in this file as it starts up. While it may
31868 seem reasonable to put your favorite @code{defmath} commands there,
31869 this has the unfortunate side-effect that parts of the Calculator must be
31870 loaded in to process the @code{defmath} commands whether or not you will
31871 actually use the Calculator! If you want to put the @code{defmath}
31872 commands there (for example, if you redefine @code{calc-settings-file}
31873 to be @file{.emacs}), a better effect can be had by writing
31876 (put 'calc-define 'thing '(progn
31883 @vindex calc-define
31884 The @code{put} function adds a @dfn{property} to a symbol. Each Lisp
31885 symbol has a list of properties associated with it. Here we add a
31886 property with a name of @code{thing} and a @samp{(progn ...)} form as
31887 its value. When Calc starts up, and at the start of every Calc command,
31888 the property list for the symbol @code{calc-define} is checked and the
31889 values of any properties found are evaluated as Lisp forms. The
31890 properties are removed as they are evaluated. The property names
31891 (like @code{thing}) are not used; you should choose something like the
31892 name of your project so as not to conflict with other properties.
31894 The net effect is that you can put the above code in your @file{.emacs}
31895 file and it will not be executed until Calc is loaded. Or, you can put
31896 that same code in another file which you load by hand either before or
31897 after Calc itself is loaded.
31899 The properties of @code{calc-define} are evaluated in the same order
31900 that they were added. They can assume that the Calc modules @file{calc.el},
31901 @file{calc-ext.el}, and @file{calc-macs.el} have been fully loaded, and
31902 that the @samp{*Calculator*} buffer will be the current buffer.
31904 If your @code{calc-define} property only defines algebraic functions,
31905 you can be sure that it will have been evaluated before Calc tries to
31906 call your function, even if the file defining the property is loaded
31907 after Calc is loaded. But if the property defines commands or key
31908 sequences, it may not be evaluated soon enough. (Suppose it defines the
31909 new command @code{tweak-calc}; the user can load your file, then type
31910 @kbd{M-x tweak-calc} before Calc has had chance to do anything.) To
31911 protect against this situation, you can put
31914 (run-hooks 'calc-check-defines)
31917 @findex calc-check-defines
31919 at the end of your file. The @code{calc-check-defines} function is what
31920 looks for and evaluates properties on @code{calc-define}; @code{run-hooks}
31921 has the advantage that it is quietly ignored if @code{calc-check-defines}
31922 is not yet defined because Calc has not yet been loaded.
31924 Examples of things that ought to be enclosed in a @code{calc-define}
31925 property are @code{defmath} calls, @code{define-key} calls that modify
31926 the Calc key map, and any calls that redefine things defined inside Calc.
31927 Ordinary @code{defun}s need not be enclosed with @code{calc-define}.
31929 @node Defining Simple Commands, Defining Stack Commands, Defining Functions, Lisp Definitions
31930 @subsection Defining New Simple Commands
31933 @findex interactive
31934 If a @code{defmath} form contains an @code{interactive} clause, it defines
31935 a Calculator command. Actually such a @code{defmath} results in @emph{two}
31936 function definitions: One, a @samp{calcFunc-} function as was just described,
31937 with the @code{interactive} clause removed. Two, a @samp{calc-} function
31938 with a suitable @code{interactive} clause and some sort of wrapper to make
31939 the command work in the Calc environment.
31941 In the simple case, the @code{interactive} clause has the same form as
31942 for normal Emacs Lisp commands:
31945 (defmath increase-precision (delta)
31946 "Increase precision by DELTA." ; This is the "documentation string"
31947 (interactive "p") ; Register this as a M-x-able command
31948 (setq calc-internal-prec (+ calc-internal-prec delta)))
31951 This expands to the pair of definitions,
31954 (defun calc-increase-precision (delta)
31955 "Increase precision by DELTA."
31958 (setq calc-internal-prec (math-add calc-internal-prec delta))))
31960 (defun calcFunc-increase-precision (delta)
31961 "Increase precision by DELTA."
31962 (setq calc-internal-prec (math-add calc-internal-prec delta)))
31966 where in this case the latter function would never really be used! Note
31967 that since the Calculator stores small integers as plain Lisp integers,
31968 the @code{math-add} function will work just as well as the native
31969 @code{+} even when the intent is to operate on native Lisp integers.
31971 @findex calc-wrapper
31972 The @samp{calc-wrapper} call invokes a macro which surrounds the body of
31973 the function with code that looks roughly like this:
31976 (let ((calc-command-flags nil))
31978 (save-current-buffer
31979 (calc-select-buffer)
31980 @emph{body of function}
31981 @emph{renumber stack}
31982 @emph{clear} Working @emph{message})
31983 @emph{realign cursor and window}
31984 @emph{clear Inverse, Hyperbolic, and Keep Args flags}
31985 @emph{update Emacs mode line}))
31988 @findex calc-select-buffer
31989 The @code{calc-select-buffer} function selects the @samp{*Calculator*}
31990 buffer if necessary, say, because the command was invoked from inside
31991 the @samp{*Calc Trail*} window.
31993 @findex calc-set-command-flag
31994 You can call, for example, @code{(calc-set-command-flag 'no-align)} to
31995 set the above-mentioned command flags. Calc routines recognize the
31996 following command flags:
32000 Stack line numbers @samp{1:}, @samp{2:}, and so on must be renumbered
32001 after this command completes. This is set by routines like
32004 @item clear-message
32005 Calc should call @samp{(message "")} if this command completes normally
32006 (to clear a ``Working@dots{}'' message out of the echo area).
32009 Do not move the cursor back to the @samp{.} top-of-stack marker.
32011 @item position-point
32012 Use the variables @code{calc-position-point-line} and
32013 @code{calc-position-point-column} to position the cursor after
32014 this command finishes.
32017 Do not clear @code{calc-inverse-flag}, @code{calc-hyperbolic-flag},
32018 and @code{calc-keep-args-flag} at the end of this command.
32021 Switch to buffer @samp{*Calc Edit*} after this command.
32024 Do not move trail pointer to end of trail when something is recorded
32030 @vindex calc-Y-help-msgs
32031 Calc reserves a special prefix key, shift-@kbd{Y}, for user-written
32032 extensions to Calc. There are no built-in commands that work with
32033 this prefix key; you must call @code{define-key} from Lisp (probably
32034 from inside a @code{calc-define} property) to add to it. Initially only
32035 @kbd{Y ?} is defined; it takes help messages from a list of strings
32036 (initially @code{nil}) in the variable @code{calc-Y-help-msgs}. All
32037 other undefined keys except for @kbd{Y} are reserved for use by
32038 future versions of Calc.
32040 If you are writing a Calc enhancement which you expect to give to
32041 others, it is best to minimize the number of @kbd{Y}-key sequences
32042 you use. In fact, if you have more than one key sequence you should
32043 consider defining three-key sequences with a @kbd{Y}, then a key that
32044 stands for your package, then a third key for the particular command
32045 within your package.
32047 Users may wish to install several Calc enhancements, and it is possible
32048 that several enhancements will choose to use the same key. In the
32049 example below, a variable @code{inc-prec-base-key} has been defined
32050 to contain the key that identifies the @code{inc-prec} package. Its
32051 value is initially @code{"P"}, but a user can change this variable
32052 if necessary without having to modify the file.
32054 Here is a complete file, @file{inc-prec.el}, which makes a @kbd{Y P I}
32055 command that increases the precision, and a @kbd{Y P D} command that
32056 decreases the precision.
32059 ;;; Increase and decrease Calc precision. Dave Gillespie, 5/31/91.
32060 ;; (Include copyright or copyleft stuff here.)
32062 (defvar inc-prec-base-key "P"
32063 "Base key for inc-prec.el commands.")
32065 (put 'calc-define 'inc-prec '(progn
32067 (define-key calc-mode-map (format "Y%sI" inc-prec-base-key)
32068 'increase-precision)
32069 (define-key calc-mode-map (format "Y%sD" inc-prec-base-key)
32070 'decrease-precision)
32072 (setq calc-Y-help-msgs
32073 (cons (format "%s + Inc-prec, Dec-prec" inc-prec-base-key)
32076 (defmath increase-precision (delta)
32077 "Increase precision by DELTA."
32079 (setq calc-internal-prec (+ calc-internal-prec delta)))
32081 (defmath decrease-precision (delta)
32082 "Decrease precision by DELTA."
32084 (setq calc-internal-prec (- calc-internal-prec delta)))
32086 )) ; end of calc-define property
32088 (run-hooks 'calc-check-defines)
32091 @node Defining Stack Commands, Argument Qualifiers, Defining Simple Commands, Lisp Definitions
32092 @subsection Defining New Stack-Based Commands
32095 To define a new computational command which takes and/or leaves arguments
32096 on the stack, a special form of @code{interactive} clause is used.
32099 (interactive @var{num} @var{tag})
32103 where @var{num} is an integer, and @var{tag} is a string. The effect is
32104 to pop @var{num} values off the stack, resimplify them by calling
32105 @code{calc-normalize}, and hand them to your function according to the
32106 function's argument list. Your function may include @code{&optional} and
32107 @code{&rest} parameters, so long as calling the function with @var{num}
32108 parameters is valid.
32110 Your function must return either a number or a formula in a form
32111 acceptable to Calc, or a list of such numbers or formulas. These value(s)
32112 are pushed onto the stack when the function completes. They are also
32113 recorded in the Calc Trail buffer on a line beginning with @var{tag},
32114 a string of (normally) four characters or less. If you omit @var{tag}
32115 or use @code{nil} as a tag, the result is not recorded in the trail.
32117 As an example, the definition
32120 (defmath myfact (n)
32121 "Compute the factorial of the integer at the top of the stack."
32122 (interactive 1 "fact")
32124 (* n (myfact (1- n)))
32129 is a version of the factorial function shown previously which can be used
32130 as a command as well as an algebraic function. It expands to
32133 (defun calc-myfact ()
32134 "Compute the factorial of the integer at the top of the stack."
32137 (calc-enter-result 1 "fact"
32138 (cons 'calcFunc-myfact (calc-top-list-n 1)))))
32140 (defun calcFunc-myfact (n)
32141 "Compute the factorial of the integer at the top of the stack."
32143 (math-mul n (calcFunc-myfact (math-add n -1)))
32144 (and (math-zerop n) 1)))
32147 @findex calc-slow-wrapper
32148 The @code{calc-slow-wrapper} function is a version of @code{calc-wrapper}
32149 that automatically puts up a @samp{Working...} message before the
32150 computation begins. (This message can be turned off by the user
32151 with an @kbd{m w} (@code{calc-working}) command.)
32153 @findex calc-top-list-n
32154 The @code{calc-top-list-n} function returns a list of the specified number
32155 of values from the top of the stack. It resimplifies each value by
32156 calling @code{calc-normalize}. If its argument is zero it returns an
32157 empty list. It does not actually remove these values from the stack.
32159 @findex calc-enter-result
32160 The @code{calc-enter-result} function takes an integer @var{num} and string
32161 @var{tag} as described above, plus a third argument which is either a
32162 Calculator data object or a list of such objects. These objects are
32163 resimplified and pushed onto the stack after popping the specified number
32164 of values from the stack. If @var{tag} is non-@code{nil}, the values
32165 being pushed are also recorded in the trail.
32167 Note that if @code{calcFunc-myfact} returns @code{nil} this represents
32168 ``leave the function in symbolic form.'' To return an actual empty list,
32169 in the sense that @code{calc-enter-result} will push zero elements back
32170 onto the stack, you should return the special value @samp{'(nil)}, a list
32171 containing the single symbol @code{nil}.
32173 The @code{interactive} declaration can actually contain a limited
32174 Emacs-style code string as well which comes just before @var{num} and
32175 @var{tag}. Currently the only Emacs code supported is @samp{"p"}, as in
32178 (defmath foo (a b &optional c)
32179 (interactive "p" 2 "foo")
32183 In this example, the command @code{calc-foo} will evaluate the expression
32184 @samp{foo(a,b)} if executed with no argument, or @samp{foo(a,b,n)} if
32185 executed with a numeric prefix argument of @expr{n}.
32187 The other code string allowed is @samp{"m"} (unrelated to the usual @samp{"m"}
32188 code as used with @code{defun}). It uses the numeric prefix argument as the
32189 number of objects to remove from the stack and pass to the function.
32190 In this case, the integer @var{num} serves as a default number of
32191 arguments to be used when no prefix is supplied.
32193 @node Argument Qualifiers, Example Definitions, Defining Stack Commands, Lisp Definitions
32194 @subsection Argument Qualifiers
32197 Anywhere a parameter name can appear in the parameter list you can also use
32198 an @dfn{argument qualifier}. Thus the general form of a definition is:
32201 (defmath @var{name} (@var{param} @var{param...}
32202 &optional @var{param} @var{param...}
32208 where each @var{param} is either a symbol or a list of the form
32211 (@var{qual} @var{param})
32214 The following qualifiers are recognized:
32219 The argument must not be an incomplete vector, interval, or complex number.
32220 (This is rarely needed since the Calculator itself will never call your
32221 function with an incomplete argument. But there is nothing stopping your
32222 own Lisp code from calling your function with an incomplete argument.)
32226 The argument must be an integer. If it is an integer-valued float
32227 it will be accepted but converted to integer form. Non-integers and
32228 formulas are rejected.
32232 Like @samp{integer}, but the argument must be non-negative.
32236 Like @samp{integer}, but the argument must fit into a native Lisp integer,
32237 which on most systems means less than 2^23 in absolute value. The
32238 argument is converted into Lisp-integer form if necessary.
32242 The argument is converted to floating-point format if it is a number or
32243 vector. If it is a formula it is left alone. (The argument is never
32244 actually rejected by this qualifier.)
32247 The argument must satisfy predicate @var{pred}, which is one of the
32248 standard Calculator predicates. @xref{Predicates}.
32250 @item not-@var{pred}
32251 The argument must @emph{not} satisfy predicate @var{pred}.
32257 (defmath foo (a (constp (not-matrixp b)) &optional (float c)
32266 (defun calcFunc-foo (a b &optional c &rest d)
32267 (and (math-matrixp b)
32268 (math-reject-arg b 'not-matrixp))
32269 (or (math-constp b)
32270 (math-reject-arg b 'constp))
32271 (and c (setq c (math-check-float c)))
32272 (setq d (mapcar 'math-check-integer d))
32277 which performs the necessary checks and conversions before executing the
32278 body of the function.
32280 @node Example Definitions, Calling Calc from Your Programs, Argument Qualifiers, Lisp Definitions
32281 @subsection Example Definitions
32284 This section includes some Lisp programming examples on a larger scale.
32285 These programs make use of some of the Calculator's internal functions;
32289 * Bit Counting Example::
32293 @node Bit Counting Example, Sine Example, Example Definitions, Example Definitions
32294 @subsubsection Bit-Counting
32301 Calc does not include a built-in function for counting the number of
32302 ``one'' bits in a binary integer. It's easy to invent one using @kbd{b u}
32303 to convert the integer to a set, and @kbd{V #} to count the elements of
32304 that set; let's write a function that counts the bits without having to
32305 create an intermediate set.
32308 (defmath bcount ((natnum n))
32309 (interactive 1 "bcnt")
32313 (setq count (1+ count)))
32314 (setq n (lsh n -1)))
32319 When this is expanded by @code{defmath}, it will become the following
32320 Emacs Lisp function:
32323 (defun calcFunc-bcount (n)
32324 (setq n (math-check-natnum n))
32326 (while (math-posp n)
32328 (setq count (math-add count 1)))
32329 (setq n (calcFunc-lsh n -1)))
32333 If the input numbers are large, this function involves a fair amount
32334 of arithmetic. A binary right shift is essentially a division by two;
32335 recall that Calc stores integers in decimal form so bit shifts must
32336 involve actual division.
32338 To gain a bit more efficiency, we could divide the integer into
32339 @var{n}-bit chunks, each of which can be handled quickly because
32340 they fit into Lisp integers. It turns out that Calc's arithmetic
32341 routines are especially fast when dividing by an integer less than
32342 1000, so we can set @var{n = 9} bits and use repeated division by 512:
32345 (defmath bcount ((natnum n))
32346 (interactive 1 "bcnt")
32348 (while (not (fixnump n))
32349 (let ((qr (idivmod n 512)))
32350 (setq count (+ count (bcount-fixnum (cdr qr)))
32352 (+ count (bcount-fixnum n))))
32354 (defun bcount-fixnum (n)
32357 (setq count (+ count (logand n 1))
32363 Note that the second function uses @code{defun}, not @code{defmath}.
32364 Because this function deals only with native Lisp integers (``fixnums''),
32365 it can use the actual Emacs @code{+} and related functions rather
32366 than the slower but more general Calc equivalents which @code{defmath}
32369 The @code{idivmod} function does an integer division, returning both
32370 the quotient and the remainder at once. Again, note that while it
32371 might seem that @samp{(logand n 511)} and @samp{(lsh n -9)} are
32372 more efficient ways to split off the bottom nine bits of @code{n},
32373 actually they are less efficient because each operation is really
32374 a division by 512 in disguise; @code{idivmod} allows us to do the
32375 same thing with a single division by 512.
32377 @node Sine Example, , Bit Counting Example, Example Definitions
32378 @subsubsection The Sine Function
32385 A somewhat limited sine function could be defined as follows, using the
32386 well-known Taylor series expansion for
32387 @texline @math{\sin x}:
32388 @infoline @samp{sin(x)}:
32391 (defmath mysin ((float (anglep x)))
32392 (interactive 1 "mysn")
32393 (setq x (to-radians x)) ; Convert from current angular mode.
32394 (let ((sum x) ; Initial term of Taylor expansion of sin.
32396 (nfact 1) ; "nfact" equals "n" factorial at all times.
32397 (xnegsqr :"-(x^2)")) ; "xnegsqr" equals -x^2.
32398 (for ((n 3 100 2)) ; Upper limit of 100 is a good precaution.
32399 (working "mysin" sum) ; Display "Working" message, if enabled.
32400 (setq nfact (* nfact (1- n) n)
32402 newsum (+ sum (/ x nfact)))
32403 (if (~= newsum sum) ; If newsum is "nearly equal to" sum,
32404 (break)) ; then we are done.
32409 The actual @code{sin} function in Calc works by first reducing the problem
32410 to a sine or cosine of a nonnegative number less than @cpiover{4}. This
32411 ensures that the Taylor series will converge quickly. Also, the calculation
32412 is carried out with two extra digits of precision to guard against cumulative
32413 round-off in @samp{sum}. Finally, complex arguments are allowed and handled
32414 by a separate algorithm.
32417 (defmath mysin ((float (scalarp x)))
32418 (interactive 1 "mysn")
32419 (setq x (to-radians x)) ; Convert from current angular mode.
32420 (with-extra-prec 2 ; Evaluate with extra precision.
32421 (cond ((complexp x)
32424 (- (mysin-raw (- x))) ; Always call mysin-raw with x >= 0.
32425 (t (mysin-raw x))))))
32427 (defmath mysin-raw (x)
32429 (mysin-raw (% x (two-pi)))) ; Now x < 7.
32431 (- (mysin-raw (- x (pi))))) ; Now -pi/2 <= x <= pi/2.
32433 (mycos-raw (- x (pi-over-2)))) ; Now -pi/2 <= x <= pi/4.
32434 ((< x (- (pi-over-4)))
32435 (- (mycos-raw (+ x (pi-over-2))))) ; Now -pi/4 <= x <= pi/4,
32436 (t (mysin-series x)))) ; so the series will be efficient.
32440 where @code{mysin-complex} is an appropriate function to handle complex
32441 numbers, @code{mysin-series} is the routine to compute the sine Taylor
32442 series as before, and @code{mycos-raw} is a function analogous to
32443 @code{mysin-raw} for cosines.
32445 The strategy is to ensure that @expr{x} is nonnegative before calling
32446 @code{mysin-raw}. This function then recursively reduces its argument
32447 to a suitable range, namely, plus-or-minus @cpiover{4}. Note that each
32448 test, and particularly the first comparison against 7, is designed so
32449 that small roundoff errors cannot produce an infinite loop. (Suppose
32450 we compared with @samp{(two-pi)} instead; if due to roundoff problems
32451 the modulo operator ever returned @samp{(two-pi)} exactly, an infinite
32452 recursion could result!) We use modulo only for arguments that will
32453 clearly get reduced, knowing that the next rule will catch any reductions
32454 that this rule misses.
32456 If a program is being written for general use, it is important to code
32457 it carefully as shown in this second example. For quick-and-dirty programs,
32458 when you know that your own use of the sine function will never encounter
32459 a large argument, a simpler program like the first one shown is fine.
32461 @node Calling Calc from Your Programs, Internals, Example Definitions, Lisp Definitions
32462 @subsection Calling Calc from Your Lisp Programs
32465 A later section (@pxref{Internals}) gives a full description of
32466 Calc's internal Lisp functions. It's not hard to call Calc from
32467 inside your programs, but the number of these functions can be daunting.
32468 So Calc provides one special ``programmer-friendly'' function called
32469 @code{calc-eval} that can be made to do just about everything you
32470 need. It's not as fast as the low-level Calc functions, but it's
32471 much simpler to use!
32473 It may seem that @code{calc-eval} itself has a daunting number of
32474 options, but they all stem from one simple operation.
32476 In its simplest manifestation, @samp{(calc-eval "1+2")} parses the
32477 string @code{"1+2"} as if it were a Calc algebraic entry and returns
32478 the result formatted as a string: @code{"3"}.
32480 Since @code{calc-eval} is on the list of recommended @code{autoload}
32481 functions, you don't need to make any special preparations to load
32482 Calc before calling @code{calc-eval} the first time. Calc will be
32483 loaded and initialized for you.
32485 All the Calc modes that are currently in effect will be used when
32486 evaluating the expression and formatting the result.
32493 @subsubsection Additional Arguments to @code{calc-eval}
32496 If the input string parses to a list of expressions, Calc returns
32497 the results separated by @code{", "}. You can specify a different
32498 separator by giving a second string argument to @code{calc-eval}:
32499 @samp{(calc-eval "1+2,3+4" ";")} returns @code{"3;7"}.
32501 The ``separator'' can also be any of several Lisp symbols which
32502 request other behaviors from @code{calc-eval}. These are discussed
32505 You can give additional arguments to be substituted for
32506 @samp{$}, @samp{$$}, and so on in the main expression. For
32507 example, @samp{(calc-eval "$/$$" nil "7" "1+1")} evaluates the
32508 expression @code{"7/(1+1)"} to yield the result @code{"3.5"}
32509 (assuming Fraction mode is not in effect). Note the @code{nil}
32510 used as a placeholder for the item-separator argument.
32517 @subsubsection Error Handling
32520 If @code{calc-eval} encounters an error, it returns a list containing
32521 the character position of the error, plus a suitable message as a
32522 string. Note that @samp{1 / 0} is @emph{not} an error by Calc's
32523 standards; it simply returns the string @code{"1 / 0"} which is the
32524 division left in symbolic form. But @samp{(calc-eval "1/")} will
32525 return the list @samp{(2 "Expected a number")}.
32527 If you bind the variable @code{calc-eval-error} to @code{t}
32528 using a @code{let} form surrounding the call to @code{calc-eval},
32529 errors instead call the Emacs @code{error} function which aborts
32530 to the Emacs command loop with a beep and an error message.
32532 If you bind this variable to the symbol @code{string}, error messages
32533 are returned as strings instead of lists. The character position is
32536 As a courtesy to other Lisp code which may be using Calc, be sure
32537 to bind @code{calc-eval-error} using @code{let} rather than changing
32538 it permanently with @code{setq}.
32545 @subsubsection Numbers Only
32548 Sometimes it is preferable to treat @samp{1 / 0} as an error
32549 rather than returning a symbolic result. If you pass the symbol
32550 @code{num} as the second argument to @code{calc-eval}, results
32551 that are not constants are treated as errors. The error message
32552 reported is the first @code{calc-why} message if there is one,
32553 or otherwise ``Number expected.''
32555 A result is ``constant'' if it is a number, vector, or other
32556 object that does not include variables or function calls. If it
32557 is a vector, the components must themselves be constants.
32564 @subsubsection Default Modes
32567 If the first argument to @code{calc-eval} is a list whose first
32568 element is a formula string, then @code{calc-eval} sets all the
32569 various Calc modes to their default values while the formula is
32570 evaluated and formatted. For example, the precision is set to 12
32571 digits, digit grouping is turned off, and the Normal language
32574 This same principle applies to the other options discussed below.
32575 If the first argument would normally be @var{x}, then it can also
32576 be the list @samp{(@var{x})} to use the default mode settings.
32578 If there are other elements in the list, they are taken as
32579 variable-name/value pairs which override the default mode
32580 settings. Look at the documentation at the front of the
32581 @file{calc.el} file to find the names of the Lisp variables for
32582 the various modes. The mode settings are restored to their
32583 original values when @code{calc-eval} is done.
32585 For example, @samp{(calc-eval '("$+$$" calc-internal-prec 8) 'num a b)}
32586 computes the sum of two numbers, requiring a numeric result, and
32587 using default mode settings except that the precision is 8 instead
32588 of the default of 12.
32590 It's usually best to use this form of @code{calc-eval} unless your
32591 program actually considers the interaction with Calc's mode settings
32592 to be a feature. This will avoid all sorts of potential ``gotchas'';
32593 consider what happens with @samp{(calc-eval "sqrt(2)" 'num)}
32594 when the user has left Calc in Symbolic mode or No-Simplify mode.
32596 As another example, @samp{(equal (calc-eval '("$<$$") nil a b) "1")}
32597 checks if the number in string @expr{a} is less than the one in
32598 string @expr{b}. Without using a list, the integer 1 might
32599 come out in a variety of formats which would be hard to test for
32600 conveniently: @code{"1"}, @code{"8#1"}, @code{"00001"}. (But
32601 see ``Predicates'' mode, below.)
32608 @subsubsection Raw Numbers
32611 Normally all input and output for @code{calc-eval} is done with strings.
32612 You can do arithmetic with, say, @samp{(calc-eval "$+$$" nil a b)}
32613 in place of @samp{(+ a b)}, but this is very inefficient since the
32614 numbers must be converted to and from string format as they are passed
32615 from one @code{calc-eval} to the next.
32617 If the separator is the symbol @code{raw}, the result will be returned
32618 as a raw Calc data structure rather than a string. You can read about
32619 how these objects look in the following sections, but usually you can
32620 treat them as ``black box'' objects with no important internal
32623 There is also a @code{rawnum} symbol, which is a combination of
32624 @code{raw} (returning a raw Calc object) and @code{num} (signaling
32625 an error if that object is not a constant).
32627 You can pass a raw Calc object to @code{calc-eval} in place of a
32628 string, either as the formula itself or as one of the @samp{$}
32629 arguments. Thus @samp{(calc-eval "$+$$" 'raw a b)} is an
32630 addition function that operates on raw Calc objects. Of course
32631 in this case it would be easier to call the low-level @code{math-add}
32632 function in Calc, if you can remember its name.
32634 In particular, note that a plain Lisp integer is acceptable to Calc
32635 as a raw object. (All Lisp integers are accepted on input, but
32636 integers of more than six decimal digits are converted to ``big-integer''
32637 form for output. @xref{Data Type Formats}.)
32639 When it comes time to display the object, just use @samp{(calc-eval a)}
32640 to format it as a string.
32642 It is an error if the input expression evaluates to a list of
32643 values. The separator symbol @code{list} is like @code{raw}
32644 except that it returns a list of one or more raw Calc objects.
32646 Note that a Lisp string is not a valid Calc object, nor is a list
32647 containing a string. Thus you can still safely distinguish all the
32648 various kinds of error returns discussed above.
32655 @subsubsection Predicates
32658 If the separator symbol is @code{pred}, the result of the formula is
32659 treated as a true/false value; @code{calc-eval} returns @code{t} or
32660 @code{nil}, respectively. A value is considered ``true'' if it is a
32661 non-zero number, or false if it is zero or if it is not a number.
32663 For example, @samp{(calc-eval "$<$$" 'pred a b)} tests whether
32664 one value is less than another.
32666 As usual, it is also possible for @code{calc-eval} to return one of
32667 the error indicators described above. Lisp will interpret such an
32668 indicator as ``true'' if you don't check for it explicitly. If you
32669 wish to have an error register as ``false'', use something like
32670 @samp{(eq (calc-eval ...) t)}.
32677 @subsubsection Variable Values
32680 Variables in the formula passed to @code{calc-eval} are not normally
32681 replaced by their values. If you wish this, you can use the
32682 @code{evalv} function (@pxref{Algebraic Manipulation}). For example,
32683 if 4 is stored in Calc variable @code{a} (i.e., in Lisp variable
32684 @code{var-a}), then @samp{(calc-eval "a+pi")} will return the
32685 formula @code{"a + pi"}, but @samp{(calc-eval "evalv(a+pi)")}
32686 will return @code{"7.14159265359"}.
32688 To store in a Calc variable, just use @code{setq} to store in the
32689 corresponding Lisp variable. (This is obtained by prepending
32690 @samp{var-} to the Calc variable name.) Calc routines will
32691 understand either string or raw form values stored in variables,
32692 although raw data objects are much more efficient. For example,
32693 to increment the Calc variable @code{a}:
32696 (setq var-a (calc-eval "evalv(a+1)" 'raw))
32704 @subsubsection Stack Access
32707 If the separator symbol is @code{push}, the formula argument is
32708 evaluated (with possible @samp{$} expansions, as usual). The
32709 result is pushed onto the Calc stack. The return value is @code{nil}
32710 (unless there is an error from evaluating the formula, in which
32711 case the return value depends on @code{calc-eval-error} in the
32714 If the separator symbol is @code{pop}, the first argument to
32715 @code{calc-eval} must be an integer instead of a string. That
32716 many values are popped from the stack and thrown away. A negative
32717 argument deletes the entry at that stack level. The return value
32718 is the number of elements remaining in the stack after popping;
32719 @samp{(calc-eval 0 'pop)} is a good way to measure the size of
32722 If the separator symbol is @code{top}, the first argument to
32723 @code{calc-eval} must again be an integer. The value at that
32724 stack level is formatted as a string and returned. Thus
32725 @samp{(calc-eval 1 'top)} returns the top-of-stack value. If the
32726 integer is out of range, @code{nil} is returned.
32728 The separator symbol @code{rawtop} is just like @code{top} except
32729 that the stack entry is returned as a raw Calc object instead of
32732 In all of these cases the first argument can be made a list in
32733 order to force the default mode settings, as described above.
32734 Thus @samp{(calc-eval '(2 calc-number-radix 16) 'top)} returns the
32735 second-to-top stack entry, formatted as a string using the default
32736 instead of current display modes, except that the radix is
32737 hexadecimal instead of decimal.
32739 It is, of course, polite to put the Calc stack back the way you
32740 found it when you are done, unless the user of your program is
32741 actually expecting it to affect the stack.
32743 Note that you do not actually have to switch into the @samp{*Calculator*}
32744 buffer in order to use @code{calc-eval}; it temporarily switches into
32745 the stack buffer if necessary.
32752 @subsubsection Keyboard Macros
32755 If the separator symbol is @code{macro}, the first argument must be a
32756 string of characters which Calc can execute as a sequence of keystrokes.
32757 This switches into the Calc buffer for the duration of the macro.
32758 For example, @samp{(calc-eval "vx5\rVR+" 'macro)} pushes the
32759 vector @samp{[1,2,3,4,5]} on the stack and then replaces it
32760 with the sum of those numbers. Note that @samp{\r} is the Lisp
32761 notation for the carriage-return, @key{RET}, character.
32763 If your keyboard macro wishes to pop the stack, @samp{\C-d} is
32764 safer than @samp{\177} (the @key{DEL} character) because some
32765 installations may have switched the meanings of @key{DEL} and
32766 @kbd{C-h}. Calc always interprets @kbd{C-d} as a synonym for
32767 ``pop-stack'' regardless of key mapping.
32769 If you provide a third argument to @code{calc-eval}, evaluation
32770 of the keyboard macro will leave a record in the Trail using
32771 that argument as a tag string. Normally the Trail is unaffected.
32773 The return value in this case is always @code{nil}.
32780 @subsubsection Lisp Evaluation
32783 Finally, if the separator symbol is @code{eval}, then the Lisp
32784 @code{eval} function is called on the first argument, which must
32785 be a Lisp expression rather than a Calc formula. Remember to
32786 quote the expression so that it is not evaluated until inside
32789 The difference from plain @code{eval} is that @code{calc-eval}
32790 switches to the Calc buffer before evaluating the expression.
32791 For example, @samp{(calc-eval '(setq calc-internal-prec 17) 'eval)}
32792 will correctly affect the buffer-local Calc precision variable.
32794 An alternative would be @samp{(calc-eval '(calc-precision 17) 'eval)}.
32795 This is evaluating a call to the function that is normally invoked
32796 by the @kbd{p} key, giving it 17 as its ``numeric prefix argument.''
32797 Note that this function will leave a message in the echo area as
32798 a side effect. Also, all Calc functions switch to the Calc buffer
32799 automatically if not invoked from there, so the above call is
32800 also equivalent to @samp{(calc-precision 17)} by itself.
32801 In all cases, Calc uses @code{save-excursion} to switch back to
32802 your original buffer when it is done.
32804 As usual the first argument can be a list that begins with a Lisp
32805 expression to use default instead of current mode settings.
32807 The result of @code{calc-eval} in this usage is just the result
32808 returned by the evaluated Lisp expression.
32815 @subsubsection Example
32818 @findex convert-temp
32819 Here is a sample Emacs command that uses @code{calc-eval}. Suppose
32820 you have a document with lots of references to temperatures on the
32821 Fahrenheit scale, say ``98.6 F'', and you wish to convert these
32822 references to Centigrade. The following command does this conversion.
32823 Place the Emacs cursor right after the letter ``F'' and invoke the
32824 command to change ``98.6 F'' to ``37 C''. Or, if the temperature is
32825 already in Centigrade form, the command changes it back to Fahrenheit.
32828 (defun convert-temp ()
32831 (re-search-backward "[^-.0-9]\\([-.0-9]+\\) *\\([FC]\\)")
32832 (let* ((top1 (match-beginning 1))
32833 (bot1 (match-end 1))
32834 (number (buffer-substring top1 bot1))
32835 (top2 (match-beginning 2))
32836 (bot2 (match-end 2))
32837 (type (buffer-substring top2 bot2)))
32838 (if (equal type "F")
32840 number (calc-eval "($ - 32)*5/9" nil number))
32842 number (calc-eval "$*9/5 + 32" nil number)))
32844 (delete-region top2 bot2)
32845 (insert-before-markers type)
32847 (delete-region top1 bot1)
32848 (if (string-match "\\.$" number) ; change "37." to "37"
32849 (setq number (substring number 0 -1)))
32853 Note the use of @code{insert-before-markers} when changing between
32854 ``F'' and ``C'', so that the character winds up before the cursor
32855 instead of after it.
32857 @node Internals, , Calling Calc from Your Programs, Lisp Definitions
32858 @subsection Calculator Internals
32861 This section describes the Lisp functions defined by the Calculator that
32862 may be of use to user-written Calculator programs (as described in the
32863 rest of this chapter). These functions are shown by their names as they
32864 conventionally appear in @code{defmath}. Their full Lisp names are
32865 generally gotten by prepending @samp{calcFunc-} or @samp{math-} to their
32866 apparent names. (Names that begin with @samp{calc-} are already in
32867 their full Lisp form.) You can use the actual full names instead if you
32868 prefer them, or if you are calling these functions from regular Lisp.
32870 The functions described here are scattered throughout the various
32871 Calc component files. Note that @file{calc.el} includes @code{autoload}s
32872 for only a few component files; when Calc wants to call an advanced
32873 function it calls @samp{(calc-extensions)} first; this function
32874 autoloads @file{calc-ext.el}, which in turn autoloads all the functions
32875 in the remaining component files.
32877 Because @code{defmath} itself uses the extensions, user-written code
32878 generally always executes with the extensions already loaded, so
32879 normally you can use any Calc function and be confident that it will
32880 be autoloaded for you when necessary. If you are doing something
32881 special, check carefully to make sure each function you are using is
32882 from @file{calc.el} or its components, and call @samp{(calc-extensions)}
32883 before using any function based in @file{calc-ext.el} if you can't
32884 prove this file will already be loaded.
32887 * Data Type Formats::
32888 * Interactive Lisp Functions::
32889 * Stack Lisp Functions::
32891 * Computational Lisp Functions::
32892 * Vector Lisp Functions::
32893 * Symbolic Lisp Functions::
32894 * Formatting Lisp Functions::
32898 @node Data Type Formats, Interactive Lisp Functions, Internals, Internals
32899 @subsubsection Data Type Formats
32902 Integers are stored in either of two ways, depending on their magnitude.
32903 Integers less than one million in absolute value are stored as standard
32904 Lisp integers. This is the only storage format for Calc data objects
32905 which is not a Lisp list.
32907 Large integers are stored as lists of the form @samp{(bigpos @var{d0}
32908 @var{d1} @var{d2} @dots{})} for positive integers 1000000 or more, or
32909 @samp{(bigneg @var{d0} @var{d1} @var{d2} @dots{})} for negative integers
32910 @mathit{-1000000} or less. Each @var{d} is a base-1000 ``digit,'' a Lisp integer
32911 from 0 to 999. The least significant digit is @var{d0}; the last digit,
32912 @var{dn}, which is always nonzero, is the most significant digit. For
32913 example, the integer @mathit{-12345678} is stored as @samp{(bigneg 678 345 12)}.
32915 The distinction between small and large integers is entirely hidden from
32916 the user. In @code{defmath} definitions, the Lisp predicate @code{integerp}
32917 returns true for either kind of integer, and in general both big and small
32918 integers are accepted anywhere the word ``integer'' is used in this manual.
32919 If the distinction must be made, native Lisp integers are called @dfn{fixnums}
32920 and large integers are called @dfn{bignums}.
32922 Fractions are stored as a list of the form, @samp{(frac @var{n} @var{d})}
32923 where @var{n} is an integer (big or small) numerator, @var{d} is an
32924 integer denominator greater than one, and @var{n} and @var{d} are relatively
32925 prime. Note that fractions where @var{d} is one are automatically converted
32926 to plain integers by all math routines; fractions where @var{d} is negative
32927 are normalized by negating the numerator and denominator.
32929 Floating-point numbers are stored in the form, @samp{(float @var{mant}
32930 @var{exp})}, where @var{mant} (the ``mantissa'') is an integer less than
32931 @samp{10^@var{p}} in absolute value (@var{p} represents the current
32932 precision), and @var{exp} (the ``exponent'') is a fixnum. The value of
32933 the float is @samp{@var{mant} * 10^@var{exp}}. For example, the number
32934 @mathit{-3.14} is stored as @samp{(float -314 -2) = -314*10^-2}. Other constraints
32935 are that the number 0.0 is always stored as @samp{(float 0 0)}, and,
32936 except for the 0.0 case, the rightmost base-10 digit of @var{mant} is
32937 always nonzero. (If the rightmost digit is zero, the number is
32938 rearranged by dividing @var{mant} by ten and incrementing @var{exp}.)
32940 Rectangular complex numbers are stored in the form @samp{(cplx @var{re}
32941 @var{im})}, where @var{re} and @var{im} are each real numbers, either
32942 integers, fractions, or floats. The value is @samp{@var{re} + @var{im}i}.
32943 The @var{im} part is nonzero; complex numbers with zero imaginary
32944 components are converted to real numbers automatically.
32946 Polar complex numbers are stored in the form @samp{(polar @var{r}
32947 @var{theta})}, where @var{r} is a positive real value and @var{theta}
32948 is a real value or HMS form representing an angle. This angle is
32949 usually normalized to lie in the interval @samp{(-180 ..@: 180)} degrees,
32950 or @samp{(-pi ..@: pi)} radians, according to the current angular mode.
32951 If the angle is 0 the value is converted to a real number automatically.
32952 (If the angle is 180 degrees, the value is usually also converted to a
32953 negative real number.)
32955 Hours-minutes-seconds forms are stored as @samp{(hms @var{h} @var{m}
32956 @var{s})}, where @var{h} is an integer or an integer-valued float (i.e.,
32957 a float with @samp{@var{exp} >= 0}), @var{m} is an integer or integer-valued
32958 float in the range @w{@samp{[0 ..@: 60)}}, and @var{s} is any real number
32959 in the range @samp{[0 ..@: 60)}.
32961 Date forms are stored as @samp{(date @var{n})}, where @var{n} is
32962 a real number that counts days since midnight on the morning of
32963 January 1, 1 AD. If @var{n} is an integer, this is a pure date
32964 form. If @var{n} is a fraction or float, this is a date/time form.
32966 Modulo forms are stored as @samp{(mod @var{n} @var{m})}, where @var{m} is a
32967 positive real number or HMS form, and @var{n} is a real number or HMS
32968 form in the range @samp{[0 ..@: @var{m})}.
32970 Error forms are stored as @samp{(sdev @var{x} @var{sigma})}, where @var{x}
32971 is the mean value and @var{sigma} is the standard deviation. Each
32972 component is either a number, an HMS form, or a symbolic object
32973 (a variable or function call). If @var{sigma} is zero, the value is
32974 converted to a plain real number. If @var{sigma} is negative or
32975 complex, it is automatically normalized to be a positive real.
32977 Interval forms are stored as @samp{(intv @var{mask} @var{lo} @var{hi})},
32978 where @var{mask} is one of the integers 0, 1, 2, or 3, and @var{lo} and
32979 @var{hi} are real numbers, HMS forms, or symbolic objects. The @var{mask}
32980 is a binary integer where 1 represents the fact that the interval is
32981 closed on the high end, and 2 represents the fact that it is closed on
32982 the low end. (Thus 3 represents a fully closed interval.) The interval
32983 @w{@samp{(intv 3 @var{x} @var{x})}} is converted to the plain number @var{x};
32984 intervals @samp{(intv @var{mask} @var{x} @var{x})} for any other @var{mask}
32985 represent empty intervals. If @var{hi} is less than @var{lo}, the interval
32986 is converted to a standard empty interval by replacing @var{hi} with @var{lo}.
32988 Vectors are stored as @samp{(vec @var{v1} @var{v2} @dots{})}, where @var{v1}
32989 is the first element of the vector, @var{v2} is the second, and so on.
32990 An empty vector is stored as @samp{(vec)}. A matrix is simply a vector
32991 where all @var{v}'s are themselves vectors of equal lengths. Note that
32992 Calc vectors are unrelated to the Emacs Lisp ``vector'' type, which is
32993 generally unused by Calc data structures.
32995 Variables are stored as @samp{(var @var{name} @var{sym})}, where
32996 @var{name} is a Lisp symbol whose print name is used as the visible name
32997 of the variable, and @var{sym} is a Lisp symbol in which the variable's
32998 value is actually stored. Thus, @samp{(var pi var-pi)} represents the
32999 special constant @samp{pi}. Almost always, the form is @samp{(var
33000 @var{v} var-@var{v})}. If the variable name was entered with @code{#}
33001 signs (which are converted to hyphens internally), the form is
33002 @samp{(var @var{u} @var{v})}, where @var{u} is a symbol whose name
33003 contains @code{#} characters, and @var{v} is a symbol that contains
33004 @code{-} characters instead. The value of a variable is the Calc
33005 object stored in its @var{sym} symbol's value cell. If the symbol's
33006 value cell is void or if it contains @code{nil}, the variable has no
33007 value. Special constants have the form @samp{(special-const
33008 @var{value})} stored in their value cell, where @var{value} is a formula
33009 which is evaluated when the constant's value is requested. Variables
33010 which represent units are not stored in any special way; they are units
33011 only because their names appear in the units table. If the value
33012 cell contains a string, it is parsed to get the variable's value when
33013 the variable is used.
33015 A Lisp list with any other symbol as the first element is a function call.
33016 The symbols @code{+}, @code{-}, @code{*}, @code{/}, @code{%}, @code{^},
33017 and @code{|} represent special binary operators; these lists are always
33018 of the form @samp{(@var{op} @var{lhs} @var{rhs})} where @var{lhs} is the
33019 sub-formula on the lefthand side and @var{rhs} is the sub-formula on the
33020 right. The symbol @code{neg} represents unary negation; this list is always
33021 of the form @samp{(neg @var{arg})}. Any other symbol @var{func} represents a
33022 function that would be displayed in function-call notation; the symbol
33023 @var{func} is in general always of the form @samp{calcFunc-@var{name}}.
33024 The function cell of the symbol @var{func} should contain a Lisp function
33025 for evaluating a call to @var{func}. This function is passed the remaining
33026 elements of the list (themselves already evaluated) as arguments; such
33027 functions should return @code{nil} or call @code{reject-arg} to signify
33028 that they should be left in symbolic form, or they should return a Calc
33029 object which represents their value, or a list of such objects if they
33030 wish to return multiple values. (The latter case is allowed only for
33031 functions which are the outer-level call in an expression whose value is
33032 about to be pushed on the stack; this feature is considered obsolete
33033 and is not used by any built-in Calc functions.)
33035 @node Interactive Lisp Functions, Stack Lisp Functions, Data Type Formats, Internals
33036 @subsubsection Interactive Functions
33039 The functions described here are used in implementing interactive Calc
33040 commands. Note that this list is not exhaustive! If there is an
33041 existing command that behaves similarly to the one you want to define,
33042 you may find helpful tricks by checking the source code for that command.
33044 @defun calc-set-command-flag flag
33045 Set the command flag @var{flag}. This is generally a Lisp symbol, but
33046 may in fact be anything. The effect is to add @var{flag} to the list
33047 stored in the variable @code{calc-command-flags}, unless it is already
33048 there. @xref{Defining Simple Commands}.
33051 @defun calc-clear-command-flag flag
33052 If @var{flag} appears among the list of currently-set command flags,
33053 remove it from that list.
33056 @defun calc-record-undo rec
33057 Add the ``undo record'' @var{rec} to the list of steps to take if the
33058 current operation should need to be undone. Stack push and pop functions
33059 automatically call @code{calc-record-undo}, so the kinds of undo records
33060 you might need to create take the form @samp{(set @var{sym} @var{value})},
33061 which says that the Lisp variable @var{sym} was changed and had previously
33062 contained @var{value}; @samp{(store @var{var} @var{value})} which says that
33063 the Calc variable @var{var} (a string which is the name of the symbol that
33064 contains the variable's value) was stored and its previous value was
33065 @var{value} (either a Calc data object, or @code{nil} if the variable was
33066 previously void); or @samp{(eval @var{undo} @var{redo} @var{args} @dots{})},
33067 which means that to undo requires calling the function @samp{(@var{undo}
33068 @var{args} @dots{})} and, if the undo is later redone, calling
33069 @samp{(@var{redo} @var{args} @dots{})}.
33072 @defun calc-record-why msg args
33073 Record the error or warning message @var{msg}, which is normally a string.
33074 This message will be replayed if the user types @kbd{w} (@code{calc-why});
33075 if the message string begins with a @samp{*}, it is considered important
33076 enough to display even if the user doesn't type @kbd{w}. If one or more
33077 @var{args} are present, the displayed message will be of the form,
33078 @samp{@var{msg}: @var{arg1}, @var{arg2}, @dots{}}, where the arguments are
33079 formatted on the assumption that they are either strings or Calc objects of
33080 some sort. If @var{msg} is a symbol, it is the name of a Calc predicate
33081 (such as @code{integerp} or @code{numvecp}) which the arguments did not
33082 satisfy; it is expanded to a suitable string such as ``Expected an
33083 integer.'' The @code{reject-arg} function calls @code{calc-record-why}
33084 automatically; @pxref{Predicates}.
33087 @defun calc-is-inverse
33088 This predicate returns true if the current command is inverse,
33089 i.e., if the Inverse (@kbd{I} key) flag was set.
33092 @defun calc-is-hyperbolic
33093 This predicate is the analogous function for the @kbd{H} key.
33096 @node Stack Lisp Functions, Predicates, Interactive Lisp Functions, Internals
33097 @subsubsection Stack-Oriented Functions
33100 The functions described here perform various operations on the Calc
33101 stack and trail. They are to be used in interactive Calc commands.
33103 @defun calc-push-list vals n
33104 Push the Calc objects in list @var{vals} onto the stack at stack level
33105 @var{n}. If @var{n} is omitted it defaults to 1, so that the elements
33106 are pushed at the top of the stack. If @var{n} is greater than 1, the
33107 elements will be inserted into the stack so that the last element will
33108 end up at level @var{n}, the next-to-last at level @var{n}+1, etc.
33109 The elements of @var{vals} are assumed to be valid Calc objects, and
33110 are not evaluated, rounded, or renormalized in any way. If @var{vals}
33111 is an empty list, nothing happens.
33113 The stack elements are pushed without any sub-formula selections.
33114 You can give an optional third argument to this function, which must
33115 be a list the same size as @var{vals} of selections. Each selection
33116 must be @code{eq} to some sub-formula of the corresponding formula
33117 in @var{vals}, or @code{nil} if that formula should have no selection.
33120 @defun calc-top-list n m
33121 Return a list of the @var{n} objects starting at level @var{m} of the
33122 stack. If @var{m} is omitted it defaults to 1, so that the elements are
33123 taken from the top of the stack. If @var{n} is omitted, it also
33124 defaults to 1, so that the top stack element (in the form of a
33125 one-element list) is returned. If @var{m} is greater than 1, the
33126 @var{m}th stack element will be at the end of the list, the @var{m}+1st
33127 element will be next-to-last, etc. If @var{n} or @var{m} are out of
33128 range, the command is aborted with a suitable error message. If @var{n}
33129 is zero, the function returns an empty list. The stack elements are not
33130 evaluated, rounded, or renormalized.
33132 If any stack elements contain selections, and selections have not
33133 been disabled by the @kbd{j e} (@code{calc-enable-selections}) command,
33134 this function returns the selected portions rather than the entire
33135 stack elements. It can be given a third ``selection-mode'' argument
33136 which selects other behaviors. If it is the symbol @code{t}, then
33137 a selection in any of the requested stack elements produces an
33138 ``invalid operation on selections'' error. If it is the symbol @code{full},
33139 the whole stack entry is always returned regardless of selections.
33140 If it is the symbol @code{sel}, the selected portion is always returned,
33141 or @code{nil} if there is no selection. (This mode ignores the @kbd{j e}
33142 command.) If the symbol is @code{entry}, the complete stack entry in
33143 list form is returned; the first element of this list will be the whole
33144 formula, and the third element will be the selection (or @code{nil}).
33147 @defun calc-pop-stack n m
33148 Remove the specified elements from the stack. The parameters @var{n}
33149 and @var{m} are defined the same as for @code{calc-top-list}. The return
33150 value of @code{calc-pop-stack} is uninteresting.
33152 If there are any selected sub-formulas among the popped elements, and
33153 @kbd{j e} has not been used to disable selections, this produces an
33154 error without changing the stack. If you supply an optional third
33155 argument of @code{t}, the stack elements are popped even if they
33156 contain selections.
33159 @defun calc-record-list vals tag
33160 This function records one or more results in the trail. The @var{vals}
33161 are a list of strings or Calc objects. The @var{tag} is the four-character
33162 tag string to identify the values. If @var{tag} is omitted, a blank tag
33166 @defun calc-normalize n
33167 This function takes a Calc object and ``normalizes'' it. At the very
33168 least this involves re-rounding floating-point values according to the
33169 current precision and other similar jobs. Also, unless the user has
33170 selected No-Simplify mode (@pxref{Simplification Modes}), this involves
33171 actually evaluating a formula object by executing the function calls
33172 it contains, and possibly also doing algebraic simplification, etc.
33175 @defun calc-top-list-n n m
33176 This function is identical to @code{calc-top-list}, except that it calls
33177 @code{calc-normalize} on the values that it takes from the stack. They
33178 are also passed through @code{check-complete}, so that incomplete
33179 objects will be rejected with an error message. All computational
33180 commands should use this in preference to @code{calc-top-list}; the only
33181 standard Calc commands that operate on the stack without normalizing
33182 are stack management commands like @code{calc-enter} and @code{calc-roll-up}.
33183 This function accepts the same optional selection-mode argument as
33184 @code{calc-top-list}.
33187 @defun calc-top-n m
33188 This function is a convenient form of @code{calc-top-list-n} in which only
33189 a single element of the stack is taken and returned, rather than a list
33190 of elements. This also accepts an optional selection-mode argument.
33193 @defun calc-enter-result n tag vals
33194 This function is a convenient interface to most of the above functions.
33195 The @var{vals} argument should be either a single Calc object, or a list
33196 of Calc objects; the object or objects are normalized, and the top @var{n}
33197 stack entries are replaced by the normalized objects. If @var{tag} is
33198 non-@code{nil}, the normalized objects are also recorded in the trail.
33199 A typical stack-based computational command would take the form,
33202 (calc-enter-result @var{n} @var{tag} (cons 'calcFunc-@var{func}
33203 (calc-top-list-n @var{n})))
33206 If any of the @var{n} stack elements replaced contain sub-formula
33207 selections, and selections have not been disabled by @kbd{j e},
33208 this function takes one of two courses of action. If @var{n} is
33209 equal to the number of elements in @var{vals}, then each element of
33210 @var{vals} is spliced into the corresponding selection; this is what
33211 happens when you use the @key{TAB} key, or when you use a unary
33212 arithmetic operation like @code{sqrt}. If @var{vals} has only one
33213 element but @var{n} is greater than one, there must be only one
33214 selection among the top @var{n} stack elements; the element from
33215 @var{vals} is spliced into that selection. This is what happens when
33216 you use a binary arithmetic operation like @kbd{+}. Any other
33217 combination of @var{n} and @var{vals} is an error when selections
33221 @defun calc-unary-op tag func arg
33222 This function implements a unary operator that allows a numeric prefix
33223 argument to apply the operator over many stack entries. If the prefix
33224 argument @var{arg} is @code{nil}, this uses @code{calc-enter-result}
33225 as outlined above. Otherwise, it maps the function over several stack
33226 elements; @pxref{Prefix Arguments}. For example,
33229 (defun calc-zeta (arg)
33231 (calc-unary-op "zeta" 'calcFunc-zeta arg))
33235 @defun calc-binary-op tag func arg ident unary
33236 This function implements a binary operator, analogously to
33237 @code{calc-unary-op}. The optional @var{ident} and @var{unary}
33238 arguments specify the behavior when the prefix argument is zero or
33239 one, respectively. If the prefix is zero, the value @var{ident}
33240 is pushed onto the stack, if specified, otherwise an error message
33241 is displayed. If the prefix is one, the unary function @var{unary}
33242 is applied to the top stack element, or, if @var{unary} is not
33243 specified, nothing happens. When the argument is two or more,
33244 the binary function @var{func} is reduced across the top @var{arg}
33245 stack elements; when the argument is negative, the function is
33246 mapped between the next-to-top @mathit{-@var{arg}} stack elements and the
33250 @defun calc-stack-size
33251 Return the number of elements on the stack as an integer. This count
33252 does not include elements that have been temporarily hidden by stack
33253 truncation; @pxref{Truncating the Stack}.
33256 @defun calc-cursor-stack-index n
33257 Move the point to the @var{n}th stack entry. If @var{n} is zero, this
33258 will be the @samp{.} line. If @var{n} is from 1 to the current stack size,
33259 this will be the beginning of the first line of that stack entry's display.
33260 If line numbers are enabled, this will move to the first character of the
33261 line number, not the stack entry itself.
33264 @defun calc-substack-height n
33265 Return the number of lines between the beginning of the @var{n}th stack
33266 entry and the bottom of the buffer. If @var{n} is zero, this
33267 will be one (assuming no stack truncation). If all stack entries are
33268 one line long (i.e., no matrices are displayed), the return value will
33269 be equal @var{n}+1 as long as @var{n} is in range. (Note that in Big
33270 mode, the return value includes the blank lines that separate stack
33274 @defun calc-refresh
33275 Erase the @code{*Calculator*} buffer and reformat its contents from memory.
33276 This must be called after changing any parameter, such as the current
33277 display radix, which might change the appearance of existing stack
33278 entries. (During a keyboard macro invoked by the @kbd{X} key, refreshing
33279 is suppressed, but a flag is set so that the entire stack will be refreshed
33280 rather than just the top few elements when the macro finishes.)
33283 @node Predicates, Computational Lisp Functions, Stack Lisp Functions, Internals
33284 @subsubsection Predicates
33287 The functions described here are predicates, that is, they return a
33288 true/false value where @code{nil} means false and anything else means
33289 true. These predicates are expanded by @code{defmath}, for example,
33290 from @code{zerop} to @code{math-zerop}. In many cases they correspond
33291 to native Lisp functions by the same name, but are extended to cover
33292 the full range of Calc data types.
33295 Returns true if @var{x} is numerically zero, in any of the Calc data
33296 types. (Note that for some types, such as error forms and intervals,
33297 it never makes sense to return true.) In @code{defmath}, the expression
33298 @samp{(= x 0)} will automatically be converted to @samp{(math-zerop x)},
33299 and @samp{(/= x 0)} will be converted to @samp{(not (math-zerop x))}.
33303 Returns true if @var{x} is negative. This accepts negative real numbers
33304 of various types, negative HMS and date forms, and intervals in which
33305 all included values are negative. In @code{defmath}, the expression
33306 @samp{(< x 0)} will automatically be converted to @samp{(math-negp x)},
33307 and @samp{(>= x 0)} will be converted to @samp{(not (math-negp x))}.
33311 Returns true if @var{x} is positive (and non-zero). For complex
33312 numbers, none of these three predicates will return true.
33315 @defun looks-negp x
33316 Returns true if @var{x} is ``negative-looking.'' This returns true if
33317 @var{x} is a negative number, or a formula with a leading minus sign
33318 such as @samp{-a/b}. In other words, this is an object which can be
33319 made simpler by calling @code{(- @var{x})}.
33323 Returns true if @var{x} is an integer of any size.
33327 Returns true if @var{x} is a native Lisp integer.
33331 Returns true if @var{x} is a nonnegative integer of any size.
33334 @defun fixnatnump x
33335 Returns true if @var{x} is a nonnegative Lisp integer.
33338 @defun num-integerp x
33339 Returns true if @var{x} is numerically an integer, i.e., either a
33340 true integer or a float with no significant digits to the right of
33344 @defun messy-integerp x
33345 Returns true if @var{x} is numerically, but not literally, an integer.
33346 A value is @code{num-integerp} if it is @code{integerp} or
33347 @code{messy-integerp} (but it is never both at once).
33350 @defun num-natnump x
33351 Returns true if @var{x} is numerically a nonnegative integer.
33355 Returns true if @var{x} is an even integer.
33358 @defun looks-evenp x
33359 Returns true if @var{x} is an even integer, or a formula with a leading
33360 multiplicative coefficient which is an even integer.
33364 Returns true if @var{x} is an odd integer.
33368 Returns true if @var{x} is a rational number, i.e., an integer or a
33373 Returns true if @var{x} is a real number, i.e., an integer, fraction,
33374 or floating-point number.
33378 Returns true if @var{x} is a real number or HMS form.
33382 Returns true if @var{x} is a float, or a complex number, error form,
33383 interval, date form, or modulo form in which at least one component
33388 Returns true if @var{x} is a rectangular or polar complex number
33389 (but not a real number).
33392 @defun rect-complexp x
33393 Returns true if @var{x} is a rectangular complex number.
33396 @defun polar-complexp x
33397 Returns true if @var{x} is a polar complex number.
33401 Returns true if @var{x} is a real number or a complex number.
33405 Returns true if @var{x} is a real or complex number or an HMS form.
33409 Returns true if @var{x} is a vector (this simply checks if its argument
33410 is a list whose first element is the symbol @code{vec}).
33414 Returns true if @var{x} is a number or vector.
33418 Returns true if @var{x} is a matrix, i.e., a vector of one or more vectors,
33419 all of the same size.
33422 @defun square-matrixp x
33423 Returns true if @var{x} is a square matrix.
33427 Returns true if @var{x} is any numeric Calc object, including real and
33428 complex numbers, HMS forms, date forms, error forms, intervals, and
33429 modulo forms. (Note that error forms and intervals may include formulas
33430 as their components; see @code{constp} below.)
33434 Returns true if @var{x} is an object or a vector. This also accepts
33435 incomplete objects, but it rejects variables and formulas (except as
33436 mentioned above for @code{objectp}).
33440 Returns true if @var{x} is a ``primitive'' or ``atomic'' Calc object,
33441 i.e., one whose components cannot be regarded as sub-formulas. This
33442 includes variables, and all @code{objectp} types except error forms
33447 Returns true if @var{x} is constant, i.e., a real or complex number,
33448 HMS form, date form, or error form, interval, or vector all of whose
33449 components are @code{constp}.
33453 Returns true if @var{x} is numerically less than @var{y}. Returns false
33454 if @var{x} is greater than or equal to @var{y}, or if the order is
33455 undefined or cannot be determined. Generally speaking, this works
33456 by checking whether @samp{@var{x} - @var{y}} is @code{negp}. In
33457 @code{defmath}, the expression @samp{(< x y)} will automatically be
33458 converted to @samp{(lessp x y)}; expressions involving @code{>}, @code{<=},
33459 and @code{>=} are similarly converted in terms of @code{lessp}.
33463 Returns true if @var{x} comes before @var{y} in a canonical ordering
33464 of Calc objects. If @var{x} and @var{y} are both real numbers, this
33465 will be the same as @code{lessp}. But whereas @code{lessp} considers
33466 other types of objects to be unordered, @code{beforep} puts any two
33467 objects into a definite, consistent order. The @code{beforep}
33468 function is used by the @kbd{V S} vector-sorting command, and also
33469 by @kbd{a s} to put the terms of a product into canonical order:
33470 This allows @samp{x y + y x} to be simplified easily to @samp{2 x y}.
33474 This is the standard Lisp @code{equal} predicate; it returns true if
33475 @var{x} and @var{y} are structurally identical. This is the usual way
33476 to compare numbers for equality, but note that @code{equal} will treat
33477 0 and 0.0 as different.
33480 @defun math-equal x y
33481 Returns true if @var{x} and @var{y} are numerically equal, either because
33482 they are @code{equal}, or because their difference is @code{zerop}. In
33483 @code{defmath}, the expression @samp{(= x y)} will automatically be
33484 converted to @samp{(math-equal x y)}.
33487 @defun equal-int x n
33488 Returns true if @var{x} and @var{n} are numerically equal, where @var{n}
33489 is a fixnum which is not a multiple of 10. This will automatically be
33490 used by @code{defmath} in place of the more general @code{math-equal}
33494 @defun nearly-equal x y
33495 Returns true if @var{x} and @var{y}, as floating-point numbers, are
33496 equal except possibly in the last decimal place. For example,
33497 314.159 and 314.166 are considered nearly equal if the current
33498 precision is 6 (since they differ by 7 units), but not if the current
33499 precision is 7 (since they differ by 70 units). Most functions which
33500 use series expansions use @code{with-extra-prec} to evaluate the
33501 series with 2 extra digits of precision, then use @code{nearly-equal}
33502 to decide when the series has converged; this guards against cumulative
33503 error in the series evaluation without doing extra work which would be
33504 lost when the result is rounded back down to the current precision.
33505 In @code{defmath}, this can be written @samp{(~= @var{x} @var{y})}.
33506 The @var{x} and @var{y} can be numbers of any kind, including complex.
33509 @defun nearly-zerop x y
33510 Returns true if @var{x} is nearly zero, compared to @var{y}. This
33511 checks whether @var{x} plus @var{y} would by be @code{nearly-equal}
33512 to @var{y} itself, to within the current precision, in other words,
33513 if adding @var{x} to @var{y} would have a negligible effect on @var{y}
33514 due to roundoff error. @var{X} may be a real or complex number, but
33515 @var{y} must be real.
33519 Return true if the formula @var{x} represents a true value in
33520 Calc, not Lisp, terms. It tests if @var{x} is a non-zero number
33521 or a provably non-zero formula.
33524 @defun reject-arg val pred
33525 Abort the current function evaluation due to unacceptable argument values.
33526 This calls @samp{(calc-record-why @var{pred} @var{val})}, then signals a
33527 Lisp error which @code{normalize} will trap. The net effect is that the
33528 function call which led here will be left in symbolic form.
33531 @defun inexact-value
33532 If Symbolic mode is enabled, this will signal an error that causes
33533 @code{normalize} to leave the formula in symbolic form, with the message
33534 ``Inexact result.'' (This function has no effect when not in Symbolic mode.)
33535 Note that if your function calls @samp{(sin 5)} in Symbolic mode, the
33536 @code{sin} function will call @code{inexact-value}, which will cause your
33537 function to be left unsimplified. You may instead wish to call
33538 @samp{(normalize (list 'calcFunc-sin 5))}, which in Symbolic mode will
33539 return the formula @samp{sin(5)} to your function.
33543 This signals an error that will be reported as a floating-point overflow.
33547 This signals a floating-point underflow.
33550 @node Computational Lisp Functions, Vector Lisp Functions, Predicates, Internals
33551 @subsubsection Computational Functions
33554 The functions described here do the actual computational work of the
33555 Calculator. In addition to these, note that any function described in
33556 the main body of this manual may be called from Lisp; for example, if
33557 the documentation refers to the @code{calc-sqrt} [@code{sqrt}] command,
33558 this means @code{calc-sqrt} is an interactive stack-based square-root
33559 command and @code{sqrt} (which @code{defmath} expands to @code{calcFunc-sqrt})
33560 is the actual Lisp function for taking square roots.
33562 The functions @code{math-add}, @code{math-sub}, @code{math-mul},
33563 @code{math-div}, @code{math-mod}, and @code{math-neg} are not included
33564 in this list, since @code{defmath} allows you to write native Lisp
33565 @code{+}, @code{-}, @code{*}, @code{/}, @code{%}, and unary @code{-},
33566 respectively, instead.
33568 @defun normalize val
33569 (Full form: @code{math-normalize}.)
33570 Reduce the value @var{val} to standard form. For example, if @var{val}
33571 is a fixnum, it will be converted to a bignum if it is too large, and
33572 if @var{val} is a bignum it will be normalized by clipping off trailing
33573 (i.e., most-significant) zero digits and converting to a fixnum if it is
33574 small. All the various data types are similarly converted to their standard
33575 forms. Variables are left alone, but function calls are actually evaluated
33576 in formulas. For example, normalizing @samp{(+ 2 (calcFunc-abs -4))} will
33579 If a function call fails, because the function is void or has the wrong
33580 number of parameters, or because it returns @code{nil} or calls
33581 @code{reject-arg} or @code{inexact-result}, @code{normalize} returns
33582 the formula still in symbolic form.
33584 If the current simplification mode is ``none'' or ``numeric arguments
33585 only,'' @code{normalize} will act appropriately. However, the more
33586 powerful simplification modes (like Algebraic Simplification) are
33587 not handled by @code{normalize}. They are handled by @code{calc-normalize},
33588 which calls @code{normalize} and possibly some other routines, such
33589 as @code{simplify} or @code{simplify-units}. Programs generally will
33590 never call @code{calc-normalize} except when popping or pushing values
33594 @defun evaluate-expr expr
33595 Replace all variables in @var{expr} that have values with their values,
33596 then use @code{normalize} to simplify the result. This is what happens
33597 when you press the @kbd{=} key interactively.
33600 @defmac with-extra-prec n body
33601 Evaluate the Lisp forms in @var{body} with precision increased by @var{n}
33602 digits. This is a macro which expands to
33606 (let ((calc-internal-prec (+ calc-internal-prec @var{n})))
33610 The surrounding call to @code{math-normalize} causes a floating-point
33611 result to be rounded down to the original precision afterwards. This
33612 is important because some arithmetic operations assume a number's
33613 mantissa contains no more digits than the current precision allows.
33616 @defun make-frac n d
33617 Build a fraction @samp{@var{n}:@var{d}}. This is equivalent to calling
33618 @samp{(normalize (list 'frac @var{n} @var{d}))}, but more efficient.
33621 @defun make-float mant exp
33622 Build a floating-point value out of @var{mant} and @var{exp}, both
33623 of which are arbitrary integers. This function will return a
33624 properly normalized float value, or signal an overflow or underflow
33625 if @var{exp} is out of range.
33628 @defun make-sdev x sigma
33629 Build an error form out of @var{x} and the absolute value of @var{sigma}.
33630 If @var{sigma} is zero, the result is the number @var{x} directly.
33631 If @var{sigma} is negative or complex, its absolute value is used.
33632 If @var{x} or @var{sigma} is not a valid type of object for use in
33633 error forms, this calls @code{reject-arg}.
33636 @defun make-intv mask lo hi
33637 Build an interval form out of @var{mask} (which is assumed to be an
33638 integer from 0 to 3), and the limits @var{lo} and @var{hi}. If
33639 @var{lo} is greater than @var{hi}, an empty interval form is returned.
33640 This calls @code{reject-arg} if @var{lo} or @var{hi} is unsuitable.
33643 @defun sort-intv mask lo hi
33644 Build an interval form, similar to @code{make-intv}, except that if
33645 @var{lo} is less than @var{hi} they are simply exchanged, and the
33646 bits of @var{mask} are swapped accordingly.
33649 @defun make-mod n m
33650 Build a modulo form out of @var{n} and the modulus @var{m}. Since modulo
33651 forms do not allow formulas as their components, if @var{n} or @var{m}
33652 is not a real number or HMS form the result will be a formula which
33653 is a call to @code{makemod}, the algebraic version of this function.
33657 Convert @var{x} to floating-point form. Integers and fractions are
33658 converted to numerically equivalent floats; components of complex
33659 numbers, vectors, HMS forms, date forms, error forms, intervals, and
33660 modulo forms are recursively floated. If the argument is a variable
33661 or formula, this calls @code{reject-arg}.
33665 Compare the numbers @var{x} and @var{y}, and return @mathit{-1} if
33666 @samp{(lessp @var{x} @var{y})}, 1 if @samp{(lessp @var{y} @var{x})},
33667 0 if @samp{(math-equal @var{x} @var{y})}, or 2 if the order is
33668 undefined or cannot be determined.
33672 Return the number of digits of integer @var{n}, effectively
33673 @samp{ceil(log10(@var{n}))}, but much more efficient. Zero is
33674 considered to have zero digits.
33677 @defun scale-int x n
33678 Shift integer @var{x} left @var{n} decimal digits, or right @mathit{-@var{n}}
33679 digits with truncation toward zero.
33682 @defun scale-rounding x n
33683 Like @code{scale-int}, except that a right shift rounds to the nearest
33684 integer rather than truncating.
33688 Return the integer @var{n} as a fixnum, i.e., a native Lisp integer.
33689 If @var{n} is outside the permissible range for Lisp integers (usually
33690 24 binary bits) the result is undefined.
33694 Compute the square of @var{x}; short for @samp{(* @var{x} @var{x})}.
33697 @defun quotient x y
33698 Divide integer @var{x} by integer @var{y}; return an integer quotient
33699 and discard the remainder. If @var{x} or @var{y} is negative, the
33700 direction of rounding is undefined.
33704 Perform an integer division; if @var{x} and @var{y} are both nonnegative
33705 integers, this uses the @code{quotient} function, otherwise it computes
33706 @samp{floor(@var{x}/@var{y})}. Thus the result is well-defined but
33707 slower than for @code{quotient}.
33711 Divide integer @var{x} by integer @var{y}; return the integer remainder
33712 and discard the quotient. Like @code{quotient}, this works only for
33713 integer arguments and is not well-defined for negative arguments.
33714 For a more well-defined result, use @samp{(% @var{x} @var{y})}.
33718 Divide integer @var{x} by integer @var{y}; return a cons cell whose
33719 @code{car} is @samp{(quotient @var{x} @var{y})} and whose @code{cdr}
33720 is @samp{(imod @var{x} @var{y})}.
33724 Compute @var{x} to the power @var{y}. In @code{defmath} code, this can
33725 also be written @samp{(^ @var{x} @var{y})} or
33726 @w{@samp{(expt @var{x} @var{y})}}.
33729 @defun abs-approx x
33730 Compute a fast approximation to the absolute value of @var{x}. For
33731 example, for a rectangular complex number the result is the sum of
33732 the absolute values of the components.
33736 @findex gamma-const
33742 @findex pi-over-180
33743 @findex sqrt-two-pi
33747 The function @samp{(pi)} computes @samp{pi} to the current precision.
33748 Other related constant-generating functions are @code{two-pi},
33749 @code{pi-over-2}, @code{pi-over-4}, @code{pi-over-180}, @code{sqrt-two-pi},
33750 @code{e}, @code{sqrt-e}, @code{ln-2}, @code{ln-10}, @code{phi} and
33751 @code{gamma-const}. Each function returns a floating-point value in the
33752 current precision, and each uses caching so that all calls after the
33753 first are essentially free.
33756 @defmac math-defcache @var{func} @var{initial} @var{form}
33757 This macro, usually used as a top-level call like @code{defun} or
33758 @code{defvar}, defines a new cached constant analogous to @code{pi}, etc.
33759 It defines a function @code{func} which returns the requested value;
33760 if @var{initial} is non-@code{nil} it must be a @samp{(float @dots{})}
33761 form which serves as an initial value for the cache. If @var{func}
33762 is called when the cache is empty or does not have enough digits to
33763 satisfy the current precision, the Lisp expression @var{form} is evaluated
33764 with the current precision increased by four, and the result minus its
33765 two least significant digits is stored in the cache. For example,
33766 calling @samp{(pi)} with a precision of 30 computes @samp{pi} to 34
33767 digits, rounds it down to 32 digits for future use, then rounds it
33768 again to 30 digits for use in the present request.
33771 @findex half-circle
33772 @findex quarter-circle
33773 @defun full-circle symb
33774 If the current angular mode is Degrees or HMS, this function returns the
33775 integer 360. In Radians mode, this function returns either the
33776 corresponding value in radians to the current precision, or the formula
33777 @samp{2*pi}, depending on the Symbolic mode. There are also similar
33778 function @code{half-circle} and @code{quarter-circle}.
33781 @defun power-of-2 n
33782 Compute two to the integer power @var{n}, as a (potentially very large)
33783 integer. Powers of two are cached, so only the first call for a
33784 particular @var{n} is expensive.
33787 @defun integer-log2 n
33788 Compute the base-2 logarithm of @var{n}, which must be an integer which
33789 is a power of two. If @var{n} is not a power of two, this function will
33793 @defun div-mod a b m
33794 Divide @var{a} by @var{b}, modulo @var{m}. This returns @code{nil} if
33795 there is no solution, or if any of the arguments are not integers.
33798 @defun pow-mod a b m
33799 Compute @var{a} to the power @var{b}, modulo @var{m}. If @var{a},
33800 @var{b}, and @var{m} are integers, this uses an especially efficient
33801 algorithm. Otherwise, it simply computes @samp{(% (^ a b) m)}.
33805 Compute the integer square root of @var{n}. This is the square root
33806 of @var{n} rounded down toward zero, i.e., @samp{floor(sqrt(@var{n}))}.
33807 If @var{n} is itself an integer, the computation is especially efficient.
33810 @defun to-hms a ang
33811 Convert the argument @var{a} into an HMS form. If @var{ang} is specified,
33812 it is the angular mode in which to interpret @var{a}, either @code{deg}
33813 or @code{rad}. Otherwise, the current angular mode is used. If @var{a}
33814 is already an HMS form it is returned as-is.
33817 @defun from-hms a ang
33818 Convert the HMS form @var{a} into a real number. If @var{ang} is specified,
33819 it is the angular mode in which to express the result, otherwise the
33820 current angular mode is used. If @var{a} is already a real number, it
33824 @defun to-radians a
33825 Convert the number or HMS form @var{a} to radians from the current
33829 @defun from-radians a
33830 Convert the number @var{a} from radians to the current angular mode.
33831 If @var{a} is a formula, this returns the formula @samp{deg(@var{a})}.
33834 @defun to-radians-2 a
33835 Like @code{to-radians}, except that in Symbolic mode a degrees to
33836 radians conversion yields a formula like @samp{@var{a}*pi/180}.
33839 @defun from-radians-2 a
33840 Like @code{from-radians}, except that in Symbolic mode a radians to
33841 degrees conversion yields a formula like @samp{@var{a}*180/pi}.
33844 @defun random-digit
33845 Produce a random base-1000 digit in the range 0 to 999.
33848 @defun random-digits n
33849 Produce a random @var{n}-digit integer; this will be an integer
33850 in the interval @samp{[0, 10^@var{n})}.
33853 @defun random-float
33854 Produce a random float in the interval @samp{[0, 1)}.
33857 @defun prime-test n iters
33858 Determine whether the integer @var{n} is prime. Return a list which has
33859 one of these forms: @samp{(nil @var{f})} means the number is non-prime
33860 because it was found to be divisible by @var{f}; @samp{(nil)} means it
33861 was found to be non-prime by table look-up (so no factors are known);
33862 @samp{(nil unknown)} means it is definitely non-prime but no factors
33863 are known because @var{n} was large enough that Fermat's probabilistic
33864 test had to be used; @samp{(t)} means the number is definitely prime;
33865 and @samp{(maybe @var{i} @var{p})} means that Fermat's test, after @var{i}
33866 iterations, is @var{p} percent sure that the number is prime. The
33867 @var{iters} parameter is the number of Fermat iterations to use, in the
33868 case that this is necessary. If @code{prime-test} returns ``maybe,''
33869 you can call it again with the same @var{n} to get a greater certainty;
33870 @code{prime-test} remembers where it left off.
33873 @defun to-simple-fraction f
33874 If @var{f} is a floating-point number which can be represented exactly
33875 as a small rational number. return that number, else return @var{f}.
33876 For example, 0.75 would be converted to 3:4. This function is very
33880 @defun to-fraction f tol
33881 Find a rational approximation to floating-point number @var{f} to within
33882 a specified tolerance @var{tol}; this corresponds to the algebraic
33883 function @code{frac}, and can be rather slow.
33886 @defun quarter-integer n
33887 If @var{n} is an integer or integer-valued float, this function
33888 returns zero. If @var{n} is a half-integer (i.e., an integer plus
33889 @mathit{1:2} or 0.5), it returns 2. If @var{n} is a quarter-integer,
33890 it returns 1 or 3. If @var{n} is anything else, this function
33891 returns @code{nil}.
33894 @node Vector Lisp Functions, Symbolic Lisp Functions, Computational Lisp Functions, Internals
33895 @subsubsection Vector Functions
33898 The functions described here perform various operations on vectors and
33901 @defun math-concat x y
33902 Do a vector concatenation; this operation is written @samp{@var{x} | @var{y}}
33903 in a symbolic formula. @xref{Building Vectors}.
33906 @defun vec-length v
33907 Return the length of vector @var{v}. If @var{v} is not a vector, the
33908 result is zero. If @var{v} is a matrix, this returns the number of
33909 rows in the matrix.
33912 @defun mat-dimens m
33913 Determine the dimensions of vector or matrix @var{m}. If @var{m} is not
33914 a vector, the result is an empty list. If @var{m} is a plain vector
33915 but not a matrix, the result is a one-element list containing the length
33916 of the vector. If @var{m} is a matrix with @var{r} rows and @var{c} columns,
33917 the result is the list @samp{(@var{r} @var{c})}. Higher-order tensors
33918 produce lists of more than two dimensions. Note that the object
33919 @samp{[[1, 2, 3], [4, 5]]} is a vector of vectors not all the same size,
33920 and is treated by this and other Calc routines as a plain vector of two
33924 @defun dimension-error
33925 Abort the current function with a message of ``Dimension error.''
33926 The Calculator will leave the function being evaluated in symbolic
33927 form; this is really just a special case of @code{reject-arg}.
33930 @defun build-vector args
33931 Return a Calc vector with @var{args} as elements.
33932 For example, @samp{(build-vector 1 2 3)} returns the Calc vector
33933 @samp{[1, 2, 3]}, stored internally as the list @samp{(vec 1 2 3)}.
33936 @defun make-vec obj dims
33937 Return a Calc vector or matrix all of whose elements are equal to
33938 @var{obj}. For example, @samp{(make-vec 27 3 4)} returns a 3x4 matrix
33942 @defun row-matrix v
33943 If @var{v} is a plain vector, convert it into a row matrix, i.e.,
33944 a matrix whose single row is @var{v}. If @var{v} is already a matrix,
33948 @defun col-matrix v
33949 If @var{v} is a plain vector, convert it into a column matrix, i.e., a
33950 matrix with each element of @var{v} as a separate row. If @var{v} is
33951 already a matrix, leave it alone.
33955 Map the Lisp function @var{f} over the Calc vector @var{v}. For example,
33956 @samp{(map-vec 'math-floor v)} returns a vector of the floored components
33960 @defun map-vec-2 f a b
33961 Map the Lisp function @var{f} over the two vectors @var{a} and @var{b}.
33962 If @var{a} and @var{b} are vectors of equal length, the result is a
33963 vector of the results of calling @samp{(@var{f} @var{ai} @var{bi})}
33964 for each pair of elements @var{ai} and @var{bi}. If either @var{a} or
33965 @var{b} is a scalar, it is matched with each value of the other vector.
33966 For example, @samp{(map-vec-2 'math-add v 1)} returns the vector @var{v}
33967 with each element increased by one. Note that using @samp{'+} would not
33968 work here, since @code{defmath} does not expand function names everywhere,
33969 just where they are in the function position of a Lisp expression.
33972 @defun reduce-vec f v
33973 Reduce the function @var{f} over the vector @var{v}. For example, if
33974 @var{v} is @samp{[10, 20, 30, 40]}, this calls @samp{(f (f (f 10 20) 30) 40)}.
33975 If @var{v} is a matrix, this reduces over the rows of @var{v}.
33978 @defun reduce-cols f m
33979 Reduce the function @var{f} over the columns of matrix @var{m}. For
33980 example, if @var{m} is @samp{[[1, 2], [3, 4], [5, 6]]}, the result
33981 is a vector of the two elements @samp{(f (f 1 3) 5)} and @samp{(f (f 2 4) 6)}.
33985 Return the @var{n}th row of matrix @var{m}. This is equivalent to
33986 @samp{(elt m n)}. For a slower but safer version, use @code{mrow}.
33987 (@xref{Extracting Elements}.)
33991 Return the @var{n}th column of matrix @var{m}, in the form of a vector.
33992 The arguments are not checked for correctness.
33995 @defun mat-less-row m n
33996 Return a copy of matrix @var{m} with its @var{n}th row deleted. The
33997 number @var{n} must be in range from 1 to the number of rows in @var{m}.
34000 @defun mat-less-col m n
34001 Return a copy of matrix @var{m} with its @var{n}th column deleted.
34005 Return the transpose of matrix @var{m}.
34008 @defun flatten-vector v
34009 Flatten nested vector @var{v} into a vector of scalars. For example,
34010 if @var{v} is @samp{[[1, 2, 3], [4, 5]]} the result is @samp{[1, 2, 3, 4, 5]}.
34013 @defun copy-matrix m
34014 If @var{m} is a matrix, return a copy of @var{m}. This maps
34015 @code{copy-sequence} over the rows of @var{m}; in Lisp terms, each
34016 element of the result matrix will be @code{eq} to the corresponding
34017 element of @var{m}, but none of the @code{cons} cells that make up
34018 the structure of the matrix will be @code{eq}. If @var{m} is a plain
34019 vector, this is the same as @code{copy-sequence}.
34022 @defun swap-rows m r1 r2
34023 Exchange rows @var{r1} and @var{r2} of matrix @var{m} in-place. In
34024 other words, unlike most of the other functions described here, this
34025 function changes @var{m} itself rather than building up a new result
34026 matrix. The return value is @var{m}, i.e., @samp{(eq (swap-rows m 1 2) m)}
34027 is true, with the side effect of exchanging the first two rows of
34031 @node Symbolic Lisp Functions, Formatting Lisp Functions, Vector Lisp Functions, Internals
34032 @subsubsection Symbolic Functions
34035 The functions described here operate on symbolic formulas in the
34038 @defun calc-prepare-selection num
34039 Prepare a stack entry for selection operations. If @var{num} is
34040 omitted, the stack entry containing the cursor is used; otherwise,
34041 it is the number of the stack entry to use. This function stores
34042 useful information about the current stack entry into a set of
34043 variables. @code{calc-selection-cache-num} contains the number of
34044 the stack entry involved (equal to @var{num} if you specified it);
34045 @code{calc-selection-cache-entry} contains the stack entry as a
34046 list (such as @code{calc-top-list} would return with @code{entry}
34047 as the selection mode); and @code{calc-selection-cache-comp} contains
34048 a special ``tagged'' composition (@pxref{Formatting Lisp Functions})
34049 which allows Calc to relate cursor positions in the buffer with
34050 their corresponding sub-formulas.
34052 A slight complication arises in the selection mechanism because
34053 formulas may contain small integers. For example, in the vector
34054 @samp{[1, 2, 1]} the first and last elements are @code{eq} to each
34055 other; selections are recorded as the actual Lisp object that
34056 appears somewhere in the tree of the whole formula, but storing
34057 @code{1} would falsely select both @code{1}'s in the vector. So
34058 @code{calc-prepare-selection} also checks the stack entry and
34059 replaces any plain integers with ``complex number'' lists of the form
34060 @samp{(cplx @var{n} 0)}. This list will be displayed the same as a
34061 plain @var{n} and the change will be completely invisible to the
34062 user, but it will guarantee that no two sub-formulas of the stack
34063 entry will be @code{eq} to each other. Next time the stack entry
34064 is involved in a computation, @code{calc-normalize} will replace
34065 these lists with plain numbers again, again invisibly to the user.
34068 @defun calc-encase-atoms x
34069 This modifies the formula @var{x} to ensure that each part of the
34070 formula is a unique atom, using the @samp{(cplx @var{n} 0)} trick
34071 described above. This function may use @code{setcar} to modify
34072 the formula in-place.
34075 @defun calc-find-selected-part
34076 Find the smallest sub-formula of the current formula that contains
34077 the cursor. This assumes @code{calc-prepare-selection} has been
34078 called already. If the cursor is not actually on any part of the
34079 formula, this returns @code{nil}.
34082 @defun calc-change-current-selection selection
34083 Change the currently prepared stack element's selection to
34084 @var{selection}, which should be @code{eq} to some sub-formula
34085 of the stack element, or @code{nil} to unselect the formula.
34086 The stack element's appearance in the Calc buffer is adjusted
34087 to reflect the new selection.
34090 @defun calc-find-nth-part expr n
34091 Return the @var{n}th sub-formula of @var{expr}. This function is used
34092 by the selection commands, and (unless @kbd{j b} has been used) treats
34093 sums and products as flat many-element formulas. Thus if @var{expr}
34094 is @samp{((a + b) - c) + d}, calling @code{calc-find-nth-part} with
34095 @var{n} equal to four will return @samp{d}.
34098 @defun calc-find-parent-formula expr part
34099 Return the sub-formula of @var{expr} which immediately contains
34100 @var{part}. If @var{expr} is @samp{a*b + (c+1)*d} and @var{part}
34101 is @code{eq} to the @samp{c+1} term of @var{expr}, then this function
34102 will return @samp{(c+1)*d}. If @var{part} turns out not to be a
34103 sub-formula of @var{expr}, the function returns @code{nil}. If
34104 @var{part} is @code{eq} to @var{expr}, the function returns @code{t}.
34105 This function does not take associativity into account.
34108 @defun calc-find-assoc-parent-formula expr part
34109 This is the same as @code{calc-find-parent-formula}, except that
34110 (unless @kbd{j b} has been used) it continues widening the selection
34111 to contain a complete level of the formula. Given @samp{a} from
34112 @samp{((a + b) - c) + d}, @code{calc-find-parent-formula} will
34113 return @samp{a + b} but @code{calc-find-assoc-parent-formula} will
34114 return the whole expression.
34117 @defun calc-grow-assoc-formula expr part
34118 This expands sub-formula @var{part} of @var{expr} to encompass a
34119 complete level of the formula. If @var{part} and its immediate
34120 parent are not compatible associative operators, or if @kbd{j b}
34121 has been used, this simply returns @var{part}.
34124 @defun calc-find-sub-formula expr part
34125 This finds the immediate sub-formula of @var{expr} which contains
34126 @var{part}. It returns an index @var{n} such that
34127 @samp{(calc-find-nth-part @var{expr} @var{n})} would return @var{part}.
34128 If @var{part} is not a sub-formula of @var{expr}, it returns @code{nil}.
34129 If @var{part} is @code{eq} to @var{expr}, it returns @code{t}. This
34130 function does not take associativity into account.
34133 @defun calc-replace-sub-formula expr old new
34134 This function returns a copy of formula @var{expr}, with the
34135 sub-formula that is @code{eq} to @var{old} replaced by @var{new}.
34138 @defun simplify expr
34139 Simplify the expression @var{expr} by applying various algebraic rules.
34140 This is what the @w{@kbd{a s}} (@code{calc-simplify}) command uses. This
34141 always returns a copy of the expression; the structure @var{expr} points
34142 to remains unchanged in memory.
34144 More precisely, here is what @code{simplify} does: The expression is
34145 first normalized and evaluated by calling @code{normalize}. If any
34146 @code{AlgSimpRules} have been defined, they are then applied. Then
34147 the expression is traversed in a depth-first, bottom-up fashion; at
34148 each level, any simplifications that can be made are made until no
34149 further changes are possible. Once the entire formula has been
34150 traversed in this way, it is compared with the original formula (from
34151 before the call to @code{normalize}) and, if it has changed,
34152 the entire procedure is repeated (starting with @code{normalize})
34153 until no further changes occur. Usually only two iterations are
34154 needed:@: one to simplify the formula, and another to verify that no
34155 further simplifications were possible.
34158 @defun simplify-extended expr
34159 Simplify the expression @var{expr}, with additional rules enabled that
34160 help do a more thorough job, while not being entirely ``safe'' in all
34161 circumstances. (For example, this mode will simplify @samp{sqrt(x^2)}
34162 to @samp{x}, which is only valid when @var{x} is positive.) This is
34163 implemented by temporarily binding the variable @code{math-living-dangerously}
34164 to @code{t} (using a @code{let} form) and calling @code{simplify}.
34165 Dangerous simplification rules are written to check this variable
34166 before taking any action.
34169 @defun simplify-units expr
34170 Simplify the expression @var{expr}, treating variable names as units
34171 whenever possible. This works by binding the variable
34172 @code{math-simplifying-units} to @code{t} while calling @code{simplify}.
34175 @defmac math-defsimplify funcs body
34176 Register a new simplification rule; this is normally called as a top-level
34177 form, like @code{defun} or @code{defmath}. If @var{funcs} is a symbol
34178 (like @code{+} or @code{calcFunc-sqrt}), this simplification rule is
34179 applied to the formulas which are calls to the specified function. Or,
34180 @var{funcs} can be a list of such symbols; the rule applies to all
34181 functions on the list. The @var{body} is written like the body of a
34182 function with a single argument called @code{expr}. The body will be
34183 executed with @code{expr} bound to a formula which is a call to one of
34184 the functions @var{funcs}. If the function body returns @code{nil}, or
34185 if it returns a result @code{equal} to the original @code{expr}, it is
34186 ignored and Calc goes on to try the next simplification rule that applies.
34187 If the function body returns something different, that new formula is
34188 substituted for @var{expr} in the original formula.
34190 At each point in the formula, rules are tried in the order of the
34191 original calls to @code{math-defsimplify}; the search stops after the
34192 first rule that makes a change. Thus later rules for that same
34193 function will not have a chance to trigger until the next iteration
34194 of the main @code{simplify} loop.
34196 Note that, since @code{defmath} is not being used here, @var{body} must
34197 be written in true Lisp code without the conveniences that @code{defmath}
34198 provides. If you prefer, you can have @var{body} simply call another
34199 function (defined with @code{defmath}) which does the real work.
34201 The arguments of a function call will already have been simplified
34202 before any rules for the call itself are invoked. Since a new argument
34203 list is consed up when this happens, this means that the rule's body is
34204 allowed to rearrange the function's arguments destructively if that is
34205 convenient. Here is a typical example of a simplification rule:
34208 (math-defsimplify calcFunc-arcsinh
34209 (or (and (math-looks-negp (nth 1 expr))
34210 (math-neg (list 'calcFunc-arcsinh
34211 (math-neg (nth 1 expr)))))
34212 (and (eq (car-safe (nth 1 expr)) 'calcFunc-sinh)
34213 (or math-living-dangerously
34214 (math-known-realp (nth 1 (nth 1 expr))))
34215 (nth 1 (nth 1 expr)))))
34218 This is really a pair of rules written with one @code{math-defsimplify}
34219 for convenience; the first replaces @samp{arcsinh(-x)} with
34220 @samp{-arcsinh(x)}, and the second, which is safe only for real @samp{x},
34221 replaces @samp{arcsinh(sinh(x))} with @samp{x}.
34224 @defun common-constant-factor expr
34225 Check @var{expr} to see if it is a sum of terms all multiplied by the
34226 same rational value. If so, return this value. If not, return @code{nil}.
34227 For example, if called on @samp{6x + 9y + 12z}, it would return 3, since
34228 3 is a common factor of all the terms.
34231 @defun cancel-common-factor expr factor
34232 Assuming @var{expr} is a sum with @var{factor} as a common factor,
34233 divide each term of the sum by @var{factor}. This is done by
34234 destructively modifying parts of @var{expr}, on the assumption that
34235 it is being used by a simplification rule (where such things are
34236 allowed; see above). For example, consider this built-in rule for
34240 (math-defsimplify calcFunc-sqrt
34241 (let ((fac (math-common-constant-factor (nth 1 expr))))
34242 (and fac (not (eq fac 1))
34243 (math-mul (math-normalize (list 'calcFunc-sqrt fac))
34245 (list 'calcFunc-sqrt
34246 (math-cancel-common-factor
34247 (nth 1 expr) fac)))))))
34251 @defun frac-gcd a b
34252 Compute a ``rational GCD'' of @var{a} and @var{b}, which must both be
34253 rational numbers. This is the fraction composed of the GCD of the
34254 numerators of @var{a} and @var{b}, over the GCD of the denominators.
34255 It is used by @code{common-constant-factor}. Note that the standard
34256 @code{gcd} function uses the LCM to combine the denominators.
34259 @defun map-tree func expr many
34260 Try applying Lisp function @var{func} to various sub-expressions of
34261 @var{expr}. Initially, call @var{func} with @var{expr} itself as an
34262 argument. If this returns an expression which is not @code{equal} to
34263 @var{expr}, apply @var{func} again until eventually it does return
34264 @var{expr} with no changes. Then, if @var{expr} is a function call,
34265 recursively apply @var{func} to each of the arguments. This keeps going
34266 until no changes occur anywhere in the expression; this final expression
34267 is returned by @code{map-tree}. Note that, unlike simplification rules,
34268 @var{func} functions may @emph{not} make destructive changes to
34269 @var{expr}. If a third argument @var{many} is provided, it is an
34270 integer which says how many times @var{func} may be applied; the
34271 default, as described above, is infinitely many times.
34274 @defun compile-rewrites rules
34275 Compile the rewrite rule set specified by @var{rules}, which should
34276 be a formula that is either a vector or a variable name. If the latter,
34277 the compiled rules are saved so that later @code{compile-rules} calls
34278 for that same variable can return immediately. If there are problems
34279 with the rules, this function calls @code{error} with a suitable
34283 @defun apply-rewrites expr crules heads
34284 Apply the compiled rewrite rule set @var{crules} to the expression
34285 @var{expr}. This will make only one rewrite and only checks at the
34286 top level of the expression. The result @code{nil} if no rules
34287 matched, or if the only rules that matched did not actually change
34288 the expression. The @var{heads} argument is optional; if is given,
34289 it should be a list of all function names that (may) appear in
34290 @var{expr}. The rewrite compiler tags each rule with the
34291 rarest-looking function name in the rule; if you specify @var{heads},
34292 @code{apply-rewrites} can use this information to narrow its search
34293 down to just a few rules in the rule set.
34296 @defun rewrite-heads expr
34297 Compute a @var{heads} list for @var{expr} suitable for use with
34298 @code{apply-rewrites}, as discussed above.
34301 @defun rewrite expr rules many
34302 This is an all-in-one rewrite function. It compiles the rule set
34303 specified by @var{rules}, then uses @code{map-tree} to apply the
34304 rules throughout @var{expr} up to @var{many} (default infinity)
34308 @defun match-patterns pat vec not-flag
34309 Given a Calc vector @var{vec} and an uncompiled pattern set or
34310 pattern set variable @var{pat}, this function returns a new vector
34311 of all elements of @var{vec} which do (or don't, if @var{not-flag} is
34312 non-@code{nil}) match any of the patterns in @var{pat}.
34315 @defun deriv expr var value symb
34316 Compute the derivative of @var{expr} with respect to variable @var{var}
34317 (which may actually be any sub-expression). If @var{value} is specified,
34318 the derivative is evaluated at the value of @var{var}; otherwise, the
34319 derivative is left in terms of @var{var}. If the expression contains
34320 functions for which no derivative formula is known, new derivative
34321 functions are invented by adding primes to the names; @pxref{Calculus}.
34322 However, if @var{symb} is non-@code{nil}, the presence of undifferentiable
34323 functions in @var{expr} instead cancels the whole differentiation, and
34324 @code{deriv} returns @code{nil} instead.
34326 Derivatives of an @var{n}-argument function can be defined by
34327 adding a @code{math-derivative-@var{n}} property to the property list
34328 of the symbol for the function's derivative, which will be the
34329 function name followed by an apostrophe. The value of the property
34330 should be a Lisp function; it is called with the same arguments as the
34331 original function call that is being differentiated. It should return
34332 a formula for the derivative. For example, the derivative of @code{ln}
34336 (put 'calcFunc-ln\' 'math-derivative-1
34337 (function (lambda (u) (math-div 1 u))))
34340 The two-argument @code{log} function has two derivatives,
34342 (put 'calcFunc-log\' 'math-derivative-2 ; d(log(x,b)) / dx
34343 (function (lambda (x b) ... )))
34344 (put 'calcFunc-log\'2 'math-derivative-2 ; d(log(x,b)) / db
34345 (function (lambda (x b) ... )))
34349 @defun tderiv expr var value symb
34350 Compute the total derivative of @var{expr}. This is the same as
34351 @code{deriv}, except that variables other than @var{var} are not
34352 assumed to be constant with respect to @var{var}.
34355 @defun integ expr var low high
34356 Compute the integral of @var{expr} with respect to @var{var}.
34357 @xref{Calculus}, for further details.
34360 @defmac math-defintegral funcs body
34361 Define a rule for integrating a function or functions of one argument;
34362 this macro is very similar in format to @code{math-defsimplify}.
34363 The main difference is that here @var{body} is the body of a function
34364 with a single argument @code{u} which is bound to the argument to the
34365 function being integrated, not the function call itself. Also, the
34366 variable of integration is available as @code{math-integ-var}. If
34367 evaluation of the integral requires doing further integrals, the body
34368 should call @samp{(math-integral @var{x})} to find the integral of
34369 @var{x} with respect to @code{math-integ-var}; this function returns
34370 @code{nil} if the integral could not be done. Some examples:
34373 (math-defintegral calcFunc-conj
34374 (let ((int (math-integral u)))
34376 (list 'calcFunc-conj int))))
34378 (math-defintegral calcFunc-cos
34379 (and (equal u math-integ-var)
34380 (math-from-radians-2 (list 'calcFunc-sin u))))
34383 In the @code{cos} example, we define only the integral of @samp{cos(x) dx},
34384 relying on the general integration-by-substitution facility to handle
34385 cosines of more complicated arguments. An integration rule should return
34386 @code{nil} if it can't do the integral; if several rules are defined for
34387 the same function, they are tried in order until one returns a non-@code{nil}
34391 @defmac math-defintegral-2 funcs body
34392 Define a rule for integrating a function or functions of two arguments.
34393 This is exactly analogous to @code{math-defintegral}, except that @var{body}
34394 is written as the body of a function with two arguments, @var{u} and
34398 @defun solve-for lhs rhs var full
34399 Attempt to solve the equation @samp{@var{lhs} = @var{rhs}} by isolating
34400 the variable @var{var} on the lefthand side; return the resulting righthand
34401 side, or @code{nil} if the equation cannot be solved. The variable
34402 @var{var} must appear at least once in @var{lhs} or @var{rhs}. Note that
34403 the return value is a formula which does not contain @var{var}; this is
34404 different from the user-level @code{solve} and @code{finv} functions,
34405 which return a rearranged equation or a functional inverse, respectively.
34406 If @var{full} is non-@code{nil}, a full solution including dummy signs
34407 and dummy integers will be produced. User-defined inverses are provided
34408 as properties in a manner similar to derivatives:
34411 (put 'calcFunc-ln 'math-inverse
34412 (function (lambda (x) (list 'calcFunc-exp x))))
34415 This function can call @samp{(math-solve-get-sign @var{x})} to create
34416 a new arbitrary sign variable, returning @var{x} times that sign, and
34417 @samp{(math-solve-get-int @var{x})} to create a new arbitrary integer
34418 variable multiplied by @var{x}. These functions simply return @var{x}
34419 if the caller requested a non-``full'' solution.
34422 @defun solve-eqn expr var full
34423 This version of @code{solve-for} takes an expression which will
34424 typically be an equation or inequality. (If it is not, it will be
34425 interpreted as the equation @samp{@var{expr} = 0}.) It returns an
34426 equation or inequality, or @code{nil} if no solution could be found.
34429 @defun solve-system exprs vars full
34430 This function solves a system of equations. Generally, @var{exprs}
34431 and @var{vars} will be vectors of equal length.
34432 @xref{Solving Systems of Equations}, for other options.
34435 @defun expr-contains expr var
34436 Returns a non-@code{nil} value if @var{var} occurs as a subexpression
34439 This function might seem at first to be identical to
34440 @code{calc-find-sub-formula}. The key difference is that
34441 @code{expr-contains} uses @code{equal} to test for matches, whereas
34442 @code{calc-find-sub-formula} uses @code{eq}. In the formula
34443 @samp{f(a, a)}, the two @samp{a}s will be @code{equal} but not
34444 @code{eq} to each other.
34447 @defun expr-contains-count expr var
34448 Returns the number of occurrences of @var{var} as a subexpression
34449 of @var{expr}, or @code{nil} if there are no occurrences.
34452 @defun expr-depends expr var
34453 Returns true if @var{expr} refers to any variable the occurs in @var{var}.
34454 In other words, it checks if @var{expr} and @var{var} have any variables
34458 @defun expr-contains-vars expr
34459 Return true if @var{expr} contains any variables, or @code{nil} if @var{expr}
34460 contains only constants and functions with constant arguments.
34463 @defun expr-subst expr old new
34464 Returns a copy of @var{expr}, with all occurrences of @var{old} replaced
34465 by @var{new}. This treats @code{lambda} forms specially with respect
34466 to the dummy argument variables, so that the effect is always to return
34467 @var{expr} evaluated at @var{old} = @var{new}.
34470 @defun multi-subst expr old new
34471 This is like @code{expr-subst}, except that @var{old} and @var{new}
34472 are lists of expressions to be substituted simultaneously. If one
34473 list is shorter than the other, trailing elements of the longer list
34477 @defun expr-weight expr
34478 Returns the ``weight'' of @var{expr}, basically a count of the total
34479 number of objects and function calls that appear in @var{expr}. For
34480 ``primitive'' objects, this will be one.
34483 @defun expr-height expr
34484 Returns the ``height'' of @var{expr}, which is the deepest level to
34485 which function calls are nested. (Note that @samp{@var{a} + @var{b}}
34486 counts as a function call.) For primitive objects, this returns zero.
34489 @defun polynomial-p expr var
34490 Check if @var{expr} is a polynomial in variable (or sub-expression)
34491 @var{var}. If so, return the degree of the polynomial, that is, the
34492 highest power of @var{var} that appears in @var{expr}. For example,
34493 for @samp{(x^2 + 3)^3 + 4} this would return 6. This function returns
34494 @code{nil} unless @var{expr}, when expanded out by @kbd{a x}
34495 (@code{calc-expand}), would consist of a sum of terms in which @var{var}
34496 appears only raised to nonnegative integer powers. Note that if
34497 @var{var} does not occur in @var{expr}, then @var{expr} is considered
34498 a polynomial of degree 0.
34501 @defun is-polynomial expr var degree loose
34502 Check if @var{expr} is a polynomial in variable or sub-expression
34503 @var{var}, and, if so, return a list representation of the polynomial
34504 where the elements of the list are coefficients of successive powers of
34505 @var{var}: @samp{@var{a} + @var{b} x + @var{c} x^3} would produce the
34506 list @samp{(@var{a} @var{b} 0 @var{c})}, and @samp{(x + 1)^2} would
34507 produce the list @samp{(1 2 1)}. The highest element of the list will
34508 be non-zero, with the special exception that if @var{expr} is the
34509 constant zero, the returned value will be @samp{(0)}. Return @code{nil}
34510 if @var{expr} is not a polynomial in @var{var}. If @var{degree} is
34511 specified, this will not consider polynomials of degree higher than that
34512 value. This is a good precaution because otherwise an input of
34513 @samp{(x+1)^1000} will cause a huge coefficient list to be built. If
34514 @var{loose} is non-@code{nil}, then a looser definition of a polynomial
34515 is used in which coefficients are no longer required not to depend on
34516 @var{var}, but are only required not to take the form of polynomials
34517 themselves. For example, @samp{sin(x) x^2 + cos(x)} is a loose
34518 polynomial with coefficients @samp{((calcFunc-cos x) 0 (calcFunc-sin
34519 x))}. The result will never be @code{nil} in loose mode, since any
34520 expression can be interpreted as a ``constant'' loose polynomial.
34523 @defun polynomial-base expr pred
34524 Check if @var{expr} is a polynomial in any variable that occurs in it;
34525 if so, return that variable. (If @var{expr} is a multivariate polynomial,
34526 this chooses one variable arbitrarily.) If @var{pred} is specified, it should
34527 be a Lisp function which is called as @samp{(@var{pred} @var{subexpr})},
34528 and which should return true if @code{mpb-top-expr} (a global name for
34529 the original @var{expr}) is a suitable polynomial in @var{subexpr}.
34530 The default predicate uses @samp{(polynomial-p mpb-top-expr @var{subexpr})};
34531 you can use @var{pred} to specify additional conditions. Or, you could
34532 have @var{pred} build up a list of every suitable @var{subexpr} that
34536 @defun poly-simplify poly
34537 Simplify polynomial coefficient list @var{poly} by (destructively)
34538 clipping off trailing zeros.
34541 @defun poly-mix a ac b bc
34542 Mix two polynomial lists @var{a} and @var{b} (in the form returned by
34543 @code{is-polynomial}) in a linear combination with coefficient expressions
34544 @var{ac} and @var{bc}. The result is a (not necessarily simplified)
34545 polynomial list representing @samp{@var{ac} @var{a} + @var{bc} @var{b}}.
34548 @defun poly-mul a b
34549 Multiply two polynomial coefficient lists @var{a} and @var{b}. The
34550 result will be in simplified form if the inputs were simplified.
34553 @defun build-polynomial-expr poly var
34554 Construct a Calc formula which represents the polynomial coefficient
34555 list @var{poly} applied to variable @var{var}. The @kbd{a c}
34556 (@code{calc-collect}) command uses @code{is-polynomial} to turn an
34557 expression into a coefficient list, then @code{build-polynomial-expr}
34558 to turn the list back into an expression in regular form.
34561 @defun check-unit-name var
34562 Check if @var{var} is a variable which can be interpreted as a unit
34563 name. If so, return the units table entry for that unit. This
34564 will be a list whose first element is the unit name (not counting
34565 prefix characters) as a symbol and whose second element is the
34566 Calc expression which defines the unit. (Refer to the Calc sources
34567 for details on the remaining elements of this list.) If @var{var}
34568 is not a variable or is not a unit name, return @code{nil}.
34571 @defun units-in-expr-p expr sub-exprs
34572 Return true if @var{expr} contains any variables which can be
34573 interpreted as units. If @var{sub-exprs} is @code{t}, the entire
34574 expression is searched. If @var{sub-exprs} is @code{nil}, this
34575 checks whether @var{expr} is directly a units expression.
34578 @defun single-units-in-expr-p expr
34579 Check whether @var{expr} contains exactly one units variable. If so,
34580 return the units table entry for the variable. If @var{expr} does
34581 not contain any units, return @code{nil}. If @var{expr} contains
34582 two or more units, return the symbol @code{wrong}.
34585 @defun to-standard-units expr which
34586 Convert units expression @var{expr} to base units. If @var{which}
34587 is @code{nil}, use Calc's native base units. Otherwise, @var{which}
34588 can specify a units system, which is a list of two-element lists,
34589 where the first element is a Calc base symbol name and the second
34590 is an expression to substitute for it.
34593 @defun remove-units expr
34594 Return a copy of @var{expr} with all units variables replaced by ones.
34595 This expression is generally normalized before use.
34598 @defun extract-units expr
34599 Return a copy of @var{expr} with everything but units variables replaced
34603 @node Formatting Lisp Functions, Hooks, Symbolic Lisp Functions, Internals
34604 @subsubsection I/O and Formatting Functions
34607 The functions described here are responsible for parsing and formatting
34608 Calc numbers and formulas.
34610 @defun calc-eval str sep arg1 arg2 @dots{}
34611 This is the simplest interface to the Calculator from another Lisp program.
34612 @xref{Calling Calc from Your Programs}.
34615 @defun read-number str
34616 If string @var{str} contains a valid Calc number, either integer,
34617 fraction, float, or HMS form, this function parses and returns that
34618 number. Otherwise, it returns @code{nil}.
34621 @defun read-expr str
34622 Read an algebraic expression from string @var{str}. If @var{str} does
34623 not have the form of a valid expression, return a list of the form
34624 @samp{(error @var{pos} @var{msg})} where @var{pos} is an integer index
34625 into @var{str} of the general location of the error, and @var{msg} is
34626 a string describing the problem.
34629 @defun read-exprs str
34630 Read a list of expressions separated by commas, and return it as a
34631 Lisp list. If an error occurs in any expressions, an error list as
34632 shown above is returned instead.
34635 @defun calc-do-alg-entry initial prompt no-norm
34636 Read an algebraic formula or formulas using the minibuffer. All
34637 conventions of regular algebraic entry are observed. The return value
34638 is a list of Calc formulas; there will be more than one if the user
34639 entered a list of values separated by commas. The result is @code{nil}
34640 if the user presses Return with a blank line. If @var{initial} is
34641 given, it is a string which the minibuffer will initially contain.
34642 If @var{prompt} is given, it is the prompt string to use; the default
34643 is ``Algebraic:''. If @var{no-norm} is @code{t}, the formulas will
34644 be returned exactly as parsed; otherwise, they will be passed through
34645 @code{calc-normalize} first.
34647 To support the use of @kbd{$} characters in the algebraic entry, use
34648 @code{let} to bind @code{calc-dollar-values} to a list of the values
34649 to be substituted for @kbd{$}, @kbd{$$}, and so on, and bind
34650 @code{calc-dollar-used} to 0. Upon return, @code{calc-dollar-used}
34651 will have been changed to the highest number of consecutive @kbd{$}s
34652 that actually appeared in the input.
34655 @defun format-number a
34656 Convert the real or complex number or HMS form @var{a} to string form.
34659 @defun format-flat-expr a prec
34660 Convert the arbitrary Calc number or formula @var{a} to string form,
34661 in the style used by the trail buffer and the @code{calc-edit} command.
34662 This is a simple format designed
34663 mostly to guarantee the string is of a form that can be re-parsed by
34664 @code{read-expr}. Most formatting modes, such as digit grouping,
34665 complex number format, and point character, are ignored to ensure the
34666 result will be re-readable. The @var{prec} parameter is normally 0; if
34667 you pass a large integer like 1000 instead, the expression will be
34668 surrounded by parentheses unless it is a plain number or variable name.
34671 @defun format-nice-expr a width
34672 This is like @code{format-flat-expr} (with @var{prec} equal to 0),
34673 except that newlines will be inserted to keep lines down to the
34674 specified @var{width}, and vectors that look like matrices or rewrite
34675 rules are written in a pseudo-matrix format. The @code{calc-edit}
34676 command uses this when only one stack entry is being edited.
34679 @defun format-value a width
34680 Convert the Calc number or formula @var{a} to string form, using the
34681 format seen in the stack buffer. Beware the string returned may
34682 not be re-readable by @code{read-expr}, for example, because of digit
34683 grouping. Multi-line objects like matrices produce strings that
34684 contain newline characters to separate the lines. The @var{w}
34685 parameter, if given, is the target window size for which to format
34686 the expressions. If @var{w} is omitted, the width of the Calculator
34690 @defun compose-expr a prec
34691 Format the Calc number or formula @var{a} according to the current
34692 language mode, returning a ``composition.'' To learn about the
34693 structure of compositions, see the comments in the Calc source code.
34694 You can specify the format of a given type of function call by putting
34695 a @code{math-compose-@var{lang}} property on the function's symbol,
34696 whose value is a Lisp function that takes @var{a} and @var{prec} as
34697 arguments and returns a composition. Here @var{lang} is a language
34698 mode name, one of @code{normal}, @code{big}, @code{c}, @code{pascal},
34699 @code{fortran}, @code{tex}, @code{eqn}, @code{math}, or @code{maple}.
34700 In Big mode, Calc actually tries @code{math-compose-big} first, then
34701 tries @code{math-compose-normal}. If this property does not exist,
34702 or if the function returns @code{nil}, the function is written in the
34703 normal function-call notation for that language.
34706 @defun composition-to-string c w
34707 Convert a composition structure returned by @code{compose-expr} into
34708 a string. Multi-line compositions convert to strings containing
34709 newline characters. The target window size is given by @var{w}.
34710 The @code{format-value} function basically calls @code{compose-expr}
34711 followed by @code{composition-to-string}.
34714 @defun comp-width c
34715 Compute the width in characters of composition @var{c}.
34718 @defun comp-height c
34719 Compute the height in lines of composition @var{c}.
34722 @defun comp-ascent c
34723 Compute the portion of the height of composition @var{c} which is on or
34724 above the baseline. For a one-line composition, this will be one.
34727 @defun comp-descent c
34728 Compute the portion of the height of composition @var{c} which is below
34729 the baseline. For a one-line composition, this will be zero.
34732 @defun comp-first-char c
34733 If composition @var{c} is a ``flat'' composition, return the first
34734 (leftmost) character of the composition as an integer. Otherwise,
34738 @defun comp-last-char c
34739 If composition @var{c} is a ``flat'' composition, return the last
34740 (rightmost) character, otherwise return @code{nil}.
34743 @comment @node Lisp Variables, Hooks, Formatting Lisp Functions, Internals
34744 @comment @subsubsection Lisp Variables
34747 @comment (This section is currently unfinished.)
34749 @node Hooks, , Formatting Lisp Functions, Internals
34750 @subsubsection Hooks
34753 Hooks are variables which contain Lisp functions (or lists of functions)
34754 which are called at various times. Calc defines a number of hooks
34755 that help you to customize it in various ways. Calc uses the Lisp
34756 function @code{run-hooks} to invoke the hooks shown below. Several
34757 other customization-related variables are also described here.
34759 @defvar calc-load-hook
34760 This hook is called at the end of @file{calc.el}, after the file has
34761 been loaded, before any functions in it have been called, but after
34762 @code{calc-mode-map} and similar variables have been set up.
34765 @defvar calc-ext-load-hook
34766 This hook is called at the end of @file{calc-ext.el}.
34769 @defvar calc-start-hook
34770 This hook is called as the last step in a @kbd{M-x calc} command.
34771 At this point, the Calc buffer has been created and initialized if
34772 necessary, the Calc window and trail window have been created,
34773 and the ``Welcome to Calc'' message has been displayed.
34776 @defvar calc-mode-hook
34777 This hook is called when the Calc buffer is being created. Usually
34778 this will only happen once per Emacs session. The hook is called
34779 after Emacs has switched to the new buffer, the mode-settings file
34780 has been read if necessary, and all other buffer-local variables
34781 have been set up. After this hook returns, Calc will perform a
34782 @code{calc-refresh} operation, set up the mode line display, then
34783 evaluate any deferred @code{calc-define} properties that have not
34784 been evaluated yet.
34787 @defvar calc-trail-mode-hook
34788 This hook is called when the Calc Trail buffer is being created.
34789 It is called as the very last step of setting up the Trail buffer.
34790 Like @code{calc-mode-hook}, this will normally happen only once
34794 @defvar calc-end-hook
34795 This hook is called by @code{calc-quit}, generally because the user
34796 presses @kbd{q} or @kbd{C-x * c} while in Calc. The Calc buffer will
34797 be the current buffer. The hook is called as the very first
34798 step, before the Calc window is destroyed.
34801 @defvar calc-window-hook
34802 If this hook is non-@code{nil}, it is called to create the Calc window.
34803 Upon return, this new Calc window should be the current window.
34804 (The Calc buffer will already be the current buffer when the
34805 hook is called.) If the hook is not defined, Calc will
34806 generally use @code{split-window}, @code{set-window-buffer},
34807 and @code{select-window} to create the Calc window.
34810 @defvar calc-trail-window-hook
34811 If this hook is non-@code{nil}, it is called to create the Calc Trail
34812 window. The variable @code{calc-trail-buffer} will contain the buffer
34813 which the window should use. Unlike @code{calc-window-hook}, this hook
34814 must @emph{not} switch into the new window.
34817 @defvar calc-embedded-mode-hook
34818 This hook is called the first time that Embedded mode is entered.
34821 @defvar calc-embedded-new-buffer-hook
34822 This hook is called each time that Embedded mode is entered in a
34826 @defvar calc-embedded-new-formula-hook
34827 This hook is called each time that Embedded mode is enabled for a
34831 @defvar calc-edit-mode-hook
34832 This hook is called by @code{calc-edit} (and the other ``edit''
34833 commands) when the temporary editing buffer is being created.
34834 The buffer will have been selected and set up to be in
34835 @code{calc-edit-mode}, but will not yet have been filled with
34836 text. (In fact it may still have leftover text from a previous
34837 @code{calc-edit} command.)
34840 @defvar calc-mode-save-hook
34841 This hook is called by the @code{calc-save-modes} command,
34842 after Calc's own mode features have been inserted into the
34843 Calc init file and just before the ``End of mode settings''
34844 message is inserted.
34847 @defvar calc-reset-hook
34848 This hook is called after @kbd{C-x * 0} (@code{calc-reset}) has
34849 reset all modes. The Calc buffer will be the current buffer.
34852 @defvar calc-other-modes
34853 This variable contains a list of strings. The strings are
34854 concatenated at the end of the modes portion of the Calc
34855 mode line (after standard modes such as ``Deg'', ``Inv'' and
34856 ``Hyp''). Each string should be a short, single word followed
34857 by a space. The variable is @code{nil} by default.
34860 @defvar calc-mode-map
34861 This is the keymap that is used by Calc mode. The best time
34862 to adjust it is probably in a @code{calc-mode-hook}. If the
34863 Calc extensions package (@file{calc-ext.el}) has not yet been
34864 loaded, many of these keys will be bound to @code{calc-missing-key},
34865 which is a command that loads the extensions package and
34866 ``retypes'' the key. If your @code{calc-mode-hook} rebinds
34867 one of these keys, it will probably be overridden when the
34868 extensions are loaded.
34871 @defvar calc-digit-map
34872 This is the keymap that is used during numeric entry. Numeric
34873 entry uses the minibuffer, but this map binds every non-numeric
34874 key to @code{calcDigit-nondigit} which generally calls
34875 @code{exit-minibuffer} and ``retypes'' the key.
34878 @defvar calc-alg-ent-map
34879 This is the keymap that is used during algebraic entry. This is
34880 mostly a copy of @code{minibuffer-local-map}.
34883 @defvar calc-store-var-map
34884 This is the keymap that is used during entry of variable names for
34885 commands like @code{calc-store} and @code{calc-recall}. This is
34886 mostly a copy of @code{minibuffer-local-completion-map}.
34889 @defvar calc-edit-mode-map
34890 This is the (sparse) keymap used by @code{calc-edit} and other
34891 temporary editing commands. It binds @key{RET}, @key{LFD},
34892 and @kbd{C-c C-c} to @code{calc-edit-finish}.
34895 @defvar calc-mode-var-list
34896 This is a list of variables which are saved by @code{calc-save-modes}.
34897 Each entry is a list of two items, the variable (as a Lisp symbol)
34898 and its default value. When modes are being saved, each variable
34899 is compared with its default value (using @code{equal}) and any
34900 non-default variables are written out.
34903 @defvar calc-local-var-list
34904 This is a list of variables which should be buffer-local to the
34905 Calc buffer. Each entry is a variable name (as a Lisp symbol).
34906 These variables also have their default values manipulated by
34907 the @code{calc} and @code{calc-quit} commands; @pxref{Multiple Calculators}.
34908 Since @code{calc-mode-hook} is called after this list has been
34909 used the first time, your hook should add a variable to the
34910 list and also call @code{make-local-variable} itself.
34913 @node Copying, GNU Free Documentation License, Programming, Top
34914 @appendix GNU GENERAL PUBLIC LICENSE
34917 @node GNU Free Documentation License, Customizing Calc, Copying, Top
34918 @appendix GNU Free Documentation License
34919 @include doclicense.texi
34921 @node Customizing Calc, Reporting Bugs, GNU Free Documentation License, Top
34922 @appendix Customizing Calc
34924 The usual prefix for Calc is the key sequence @kbd{C-x *}. If you wish
34925 to use a different prefix, you can put
34928 (global-set-key "NEWPREFIX" 'calc-dispatch)
34932 in your .emacs file.
34933 (@xref{Key Bindings,,Customizing Key Bindings,emacs,
34934 The GNU Emacs Manual}, for more information on binding keys.)
34935 A convenient way to start Calc is with @kbd{C-x * *}; to make it equally
34936 convenient for users who use a different prefix, the prefix can be
34937 followed by @kbd{=}, @kbd{&}, @kbd{#}, @kbd{\}, @kbd{/}, @kbd{+} or
34938 @kbd{-} as well as @kbd{*} to start Calc, and so in many cases the last
34939 character of the prefix can simply be typed twice.
34941 Calc is controlled by many variables, most of which can be reset
34942 from within Calc. Some variables are less involved with actual
34943 calculation and can be set outside of Calc using Emacs's
34944 customization facilities. These variables are listed below.
34945 Typing @kbd{M-x customize-variable RET @var{variable-name} RET}
34946 will bring up a buffer in which the variable's value can be redefined.
34947 Typing @kbd{M-x customize-group RET calc RET} will bring up a buffer which
34948 contains all of Calc's customizable variables. (These variables can
34949 also be reset by putting the appropriate lines in your .emacs file;
34950 @xref{Init File, ,Init File, emacs, The GNU Emacs Manual}.)
34952 Some of the customizable variables are regular expressions. A regular
34953 expression is basically a pattern that Calc can search for.
34954 See @ref{Regexp Search,, Regular Expression Search, emacs, The GNU Emacs Manual}
34955 to see how regular expressions work.
34957 @defvar calc-settings-file
34958 The variable @code{calc-settings-file} holds the file name in
34959 which commands like @kbd{m m} and @kbd{Z P} store ``permanent''
34961 If @code{calc-settings-file} is not your user init file (typically
34962 @file{~/.emacs}) and if the variable @code{calc-loaded-settings-file} is
34963 @code{nil}, then Calc will automatically load your settings file (if it
34964 exists) the first time Calc is invoked.
34966 The default value for this variable is @code{"~/.emacs.d/calc.el"}
34967 unless the file @file{~/.calc.el} exists, in which case the default
34968 value will be @code{"~/.calc.el"}.
34971 @defvar calc-gnuplot-name
34972 See @ref{Graphics}.@*
34973 The variable @code{calc-gnuplot-name} should be the name of the
34974 GNUPLOT program (a string). If you have GNUPLOT installed on your
34975 system but Calc is unable to find it, you may need to set this
34976 variable. You may also need to set some Lisp variables to show Calc how
34977 to run GNUPLOT on your system, see @ref{Devices, ,Graphical Devices} .
34978 The default value of @code{calc-gnuplot-name} is @code{"gnuplot"}.
34981 @defvar calc-gnuplot-plot-command
34982 @defvarx calc-gnuplot-print-command
34983 See @ref{Devices, ,Graphical Devices}.@*
34984 The variables @code{calc-gnuplot-plot-command} and
34985 @code{calc-gnuplot-print-command} represent system commands to
34986 display and print the output of GNUPLOT, respectively. These may be
34987 @code{nil} if no command is necessary, or strings which can include
34988 @samp{%s} to signify the name of the file to be displayed or printed.
34989 Or, these variables may contain Lisp expressions which are evaluated
34990 to display or print the output.
34992 The default value of @code{calc-gnuplot-plot-command} is @code{nil},
34993 and the default value of @code{calc-gnuplot-print-command} is
34997 @defvar calc-language-alist
34998 See @ref{Basic Embedded Mode}.@*
34999 The variable @code{calc-language-alist} controls the languages that
35000 Calc will associate with major modes. When Calc embedded mode is
35001 enabled, it will try to use the current major mode to
35002 determine what language should be used. (This can be overridden using
35003 Calc's mode changing commands, @xref{Mode Settings in Embedded Mode}.)
35004 The variable @code{calc-language-alist} consists of a list of pairs of
35005 the form @code{(@var{MAJOR-MODE} . @var{LANGUAGE})}; for example,
35006 @code{(latex-mode . latex)} is one such pair. If Calc embedded is
35007 activated in a buffer whose major mode is @var{MAJOR-MODE}, it will set itself
35008 to use the language @var{LANGUAGE}.
35010 The default value of @code{calc-language-alist} is
35012 ((latex-mode . latex)
35014 (plain-tex-mode . tex)
35015 (context-mode . tex)
35017 (pascal-mode . pascal)
35020 (fortran-mode . fortran)
35021 (f90-mode . fortran))
35025 @defvar calc-embedded-announce-formula
35026 @defvarx calc-embedded-announce-formula-alist
35027 See @ref{Customizing Embedded Mode}.@*
35028 The variable @code{calc-embedded-announce-formula} helps determine
35029 what formulas @kbd{C-x * a} will activate in a buffer. It is a
35030 regular expression, and when activating embedded formulas with
35031 @kbd{C-x * a}, it will tell Calc that what follows is a formula to be
35032 activated. (Calc also uses other patterns to find formulas, such as
35033 @samp{=>} and @samp{:=}.)
35035 The default pattern is @code{"%Embed\n\\(% .*\n\\)*"}, which checks
35036 for @samp{%Embed} followed by any number of lines beginning with
35037 @samp{%} and a space.
35039 The variable @code{calc-embedded-announce-formula-alist} is used to
35040 set @code{calc-embedded-announce-formula} to different regular
35041 expressions depending on the major mode of the editing buffer.
35042 It consists of a list of pairs of the form @code{(@var{MAJOR-MODE} .
35043 @var{REGEXP})}, and its default value is
35045 ((c++-mode . "//Embed\n\\(// .*\n\\)*")
35046 (c-mode . "/\\*Embed\\*/\n\\(/\\* .*\\*/\n\\)*")
35047 (f90-mode . "!Embed\n\\(! .*\n\\)*")
35048 (fortran-mode . "C Embed\n\\(C .*\n\\)*")
35049 (html-helper-mode . "<!-- Embed -->\n\\(<!-- .* -->\n\\)*")
35050 (html-mode . "<!-- Embed -->\n\\(<!-- .* -->\n\\)*")
35051 (nroff-mode . "\\\\\"Embed\n\\(\\\\\" .*\n\\)*")
35052 (pascal-mode . "@{Embed@}\n\\(@{.*@}\n\\)*")
35053 (sgml-mode . "<!-- Embed -->\n\\(<!-- .* -->\n\\)*")
35054 (xml-mode . "<!-- Embed -->\n\\(<!-- .* -->\n\\)*")
35055 (texinfo-mode . "@@c Embed\n\\(@@c .*\n\\)*"))
35057 Any major modes added to @code{calc-embedded-announce-formula-alist}
35058 should also be added to @code{calc-embedded-open-close-plain-alist}
35059 and @code{calc-embedded-open-close-mode-alist}.
35062 @defvar calc-embedded-open-formula
35063 @defvarx calc-embedded-close-formula
35064 @defvarx calc-embedded-open-close-formula-alist
35065 See @ref{Customizing Embedded Mode}.@*
35066 The variables @code{calc-embedded-open-formula} and
35067 @code{calc-embedded-close-formula} control the region that Calc will
35068 activate as a formula when Embedded mode is entered with @kbd{C-x * e}.
35069 They are regular expressions;
35070 Calc normally scans backward and forward in the buffer for the
35071 nearest text matching these regular expressions to be the ``formula
35074 The simplest delimiters are blank lines. Other delimiters that
35075 Embedded mode understands by default are:
35078 The @TeX{} and La@TeX{} math delimiters @samp{$ $}, @samp{$$ $$},
35079 @samp{\[ \]}, and @samp{\( \)};
35081 Lines beginning with @samp{\begin} and @samp{\end} (except matrix delimiters);
35083 Lines beginning with @samp{@@} (Texinfo delimiters).
35085 Lines beginning with @samp{.EQ} and @samp{.EN} (@dfn{eqn} delimiters);
35087 Lines containing a single @samp{%} or @samp{.\"} symbol and nothing else.
35090 The variable @code{calc-embedded-open-close-formula-alist} is used to
35091 set @code{calc-embedded-open-formula} and
35092 @code{calc-embedded-close-formula} to different regular
35093 expressions depending on the major mode of the editing buffer.
35094 It consists of a list of lists of the form
35095 @code{(@var{MAJOR-MODE} @var{OPEN-FORMULA-REGEXP}
35096 @var{CLOSE-FORMULA-REGEXP})}, and its default value is
35100 @defvar calc-embedded-word-regexp
35101 @defvarx calc-embedded-word-regexp-alist
35102 See @ref{Customizing Embedded Mode}.@*
35103 The variable @code{calc-embedded-word-regexp} determines the expression
35104 that Calc will activate when Embedded mode is entered with @kbd{C-x *
35105 w}. It is a regular expressions.
35107 The default value of @code{calc-embedded-word-regexp} is
35108 @code{"[-+]?[0-9]+\\(\\.[0-9]+\\)?\\([eE][-+]?[0-9]+\\)?"}.
35110 The variable @code{calc-embedded-word-regexp-alist} is used to
35111 set @code{calc-embedded-word-regexp} to a different regular
35112 expression depending on the major mode of the editing buffer.
35113 It consists of a list of lists of the form
35114 @code{(@var{MAJOR-MODE} @var{WORD-REGEXP})}, and its default value is
35118 @defvar calc-embedded-open-plain
35119 @defvarx calc-embedded-close-plain
35120 @defvarx calc-embedded-open-close-plain-alist
35121 See @ref{Customizing Embedded Mode}.@*
35122 The variables @code{calc-embedded-open-plain} and
35123 @code{calc-embedded-open-plain} are used to delimit ``plain''
35124 formulas. Note that these are actual strings, not regular
35125 expressions, because Calc must be able to write these string into a
35126 buffer as well as to recognize them.
35128 The default string for @code{calc-embedded-open-plain} is
35129 @code{"%%% "}, note the trailing space. The default string for
35130 @code{calc-embedded-close-plain} is @code{" %%%\n"}, without
35131 the trailing newline here, the first line of a Big mode formula
35132 that followed might be shifted over with respect to the other lines.
35134 The variable @code{calc-embedded-open-close-plain-alist} is used to
35135 set @code{calc-embedded-open-plain} and
35136 @code{calc-embedded-close-plain} to different strings
35137 depending on the major mode of the editing buffer.
35138 It consists of a list of lists of the form
35139 @code{(@var{MAJOR-MODE} @var{OPEN-PLAIN-STRING}
35140 @var{CLOSE-PLAIN-STRING})}, and its default value is
35142 ((c++-mode "// %% " " %%\n")
35143 (c-mode "/* %% " " %% */\n")
35144 (f90-mode "! %% " " %%\n")
35145 (fortran-mode "C %% " " %%\n")
35146 (html-helper-mode "<!-- %% " " %% -->\n")
35147 (html-mode "<!-- %% " " %% -->\n")
35148 (nroff-mode "\\\" %% " " %%\n")
35149 (pascal-mode "@{%% " " %%@}\n")
35150 (sgml-mode "<!-- %% " " %% -->\n")
35151 (xml-mode "<!-- %% " " %% -->\n")
35152 (texinfo-mode "@@c %% " " %%\n"))
35154 Any major modes added to @code{calc-embedded-open-close-plain-alist}
35155 should also be added to @code{calc-embedded-announce-formula-alist}
35156 and @code{calc-embedded-open-close-mode-alist}.
35159 @defvar calc-embedded-open-new-formula
35160 @defvarx calc-embedded-close-new-formula
35161 @defvarx calc-embedded-open-close-new-formula-alist
35162 See @ref{Customizing Embedded Mode}.@*
35163 The variables @code{calc-embedded-open-new-formula} and
35164 @code{calc-embedded-close-new-formula} are strings which are
35165 inserted before and after a new formula when you type @kbd{C-x * f}.
35167 The default value of @code{calc-embedded-open-new-formula} is
35168 @code{"\n\n"}. If this string begins with a newline character and the
35169 @kbd{C-x * f} is typed at the beginning of a line, @kbd{C-x * f} will skip
35170 this first newline to avoid introducing unnecessary blank lines in the
35171 file. The default value of @code{calc-embedded-close-new-formula} is
35172 also @code{"\n\n"}. The final newline is omitted by @w{@kbd{C-x * f}}
35173 if typed at the end of a line. (It follows that if @kbd{C-x * f} is
35174 typed on a blank line, both a leading opening newline and a trailing
35175 closing newline are omitted.)
35177 The variable @code{calc-embedded-open-close-new-formula-alist} is used to
35178 set @code{calc-embedded-open-new-formula} and
35179 @code{calc-embedded-close-new-formula} to different strings
35180 depending on the major mode of the editing buffer.
35181 It consists of a list of lists of the form
35182 @code{(@var{MAJOR-MODE} @var{OPEN-NEW-FORMULA-STRING}
35183 @var{CLOSE-NEW-FORMULA-STRING})}, and its default value is
35187 @defvar calc-embedded-open-mode
35188 @defvarx calc-embedded-close-mode
35189 @defvarx calc-embedded-open-close-mode-alist
35190 See @ref{Customizing Embedded Mode}.@*
35191 The variables @code{calc-embedded-open-mode} and
35192 @code{calc-embedded-close-mode} are strings which Calc will place before
35193 and after any mode annotations that it inserts. Calc never scans for
35194 these strings; Calc always looks for the annotation itself, so it is not
35195 necessary to add them to user-written annotations.
35197 The default value of @code{calc-embedded-open-mode} is @code{"% "}
35198 and the default value of @code{calc-embedded-close-mode} is
35200 If you change the value of @code{calc-embedded-close-mode}, it is a good
35201 idea still to end with a newline so that mode annotations will appear on
35202 lines by themselves.
35204 The variable @code{calc-embedded-open-close-mode-alist} is used to
35205 set @code{calc-embedded-open-mode} and
35206 @code{calc-embedded-close-mode} to different strings
35207 expressions depending on the major mode of the editing buffer.
35208 It consists of a list of lists of the form
35209 @code{(@var{MAJOR-MODE} @var{OPEN-MODE-STRING}
35210 @var{CLOSE-MODE-STRING})}, and its default value is
35212 ((c++-mode "// " "\n")
35213 (c-mode "/* " " */\n")
35214 (f90-mode "! " "\n")
35215 (fortran-mode "C " "\n")
35216 (html-helper-mode "<!-- " " -->\n")
35217 (html-mode "<!-- " " -->\n")
35218 (nroff-mode "\\\" " "\n")
35219 (pascal-mode "@{ " " @}\n")
35220 (sgml-mode "<!-- " " -->\n")
35221 (xml-mode "<!-- " " -->\n")
35222 (texinfo-mode "@@c " "\n"))
35224 Any major modes added to @code{calc-embedded-open-close-mode-alist}
35225 should also be added to @code{calc-embedded-announce-formula-alist}
35226 and @code{calc-embedded-open-close-plain-alist}.
35229 @defvar calc-highlight-selections-with-faces
35230 @defvarx calc-selected-face
35231 @defvarx calc-nonselected-face
35232 See @ref{Displaying Selections}.@*
35233 The variable @code{calc-highlight-selections-with-faces}
35234 determines how selected sub-formulas are distinguished.
35235 If @code{calc-highlight-selections-with-faces} is nil, then
35236 a selected sub-formula is distinguished either by changing every
35237 character not part of the sub-formula with a dot or by changing every
35238 character in the sub-formula with a @samp{#} sign.
35239 If @code{calc-highlight-selections-with-faces} is t,
35240 then a selected sub-formula is distinguished either by displaying the
35241 non-selected portion of the formula with @code{calc-nonselected-face}
35242 or by displaying the selected sub-formula with
35243 @code{calc-nonselected-face}.
35246 @defvar calc-multiplication-has-precedence
35247 The variable @code{calc-multiplication-has-precedence} determines
35248 whether multiplication has precedence over division in algebraic
35249 formulas in normal language modes. If
35250 @code{calc-multiplication-has-precedence} is non-@code{nil}, then
35251 multiplication has precedence (and, for certain obscure reasons, is
35252 right associative), and so for example @samp{a/b*c} will be interpreted
35253 as @samp{a/(b*c)}. If @code{calc-multiplication-has-precedence} is
35254 @code{nil}, then multiplication has the same precedence as division
35255 (and, like division, is left associative), and so for example
35256 @samp{a/b*c} will be interpreted as @samp{(a/b)*c}. The default value
35257 of @code{calc-multiplication-has-precedence} is @code{t}.
35260 @defvar calc-undo-length
35261 The variable @code{calc-undo-length} determines the number of undo
35262 steps that Calc will keep track of when @code{calc-quit} is called.
35263 If @code{calc-undo-length} is a non-negative integer, then this is the
35264 number of undo steps that will be preserved; if
35265 @code{calc-undo-length} has any other value, then all undo steps will
35266 be preserved. The default value of @code{calc-undo-length} is @expr{100}.
35269 @node Reporting Bugs, Summary, Customizing Calc, Top
35270 @appendix Reporting Bugs
35273 If you find a bug in Calc, send e-mail to Jay Belanger,
35276 jay.p.belanger@@gmail.com
35280 There is an automatic command @kbd{M-x report-calc-bug} which helps
35281 you to report bugs. This command prompts you for a brief subject
35282 line, then leaves you in a mail editing buffer. Type @kbd{C-c C-c} to
35283 send your mail. Make sure your subject line indicates that you are
35284 reporting a Calc bug; this command sends mail to the maintainer's
35287 If you have suggestions for additional features for Calc, please send
35288 them. Some have dared to suggest that Calc is already top-heavy with
35289 features; this obviously cannot be the case, so if you have ideas, send
35292 At the front of the source file, @file{calc.el}, is a list of ideas for
35293 future work. If any enthusiastic souls wish to take it upon themselves
35294 to work on these, please send a message (using @kbd{M-x report-calc-bug})
35295 so any efforts can be coordinated.
35297 The latest version of Calc is available from Savannah, in the Emacs
35298 repository. See @uref{http://savannah.gnu.org/projects/emacs}.
35301 @node Summary, Key Index, Reporting Bugs, Top
35302 @appendix Calc Summary
35305 This section includes a complete list of Calc keystroke commands.
35306 Each line lists the stack entries used by the command (top-of-stack
35307 last), the keystrokes themselves, the prompts asked by the command,
35308 and the result of the command (also with top-of-stack last).
35309 The result is expressed using the equivalent algebraic function.
35310 Commands which put no results on the stack show the full @kbd{M-x}
35311 command name in that position. Numbers preceding the result or
35312 command name refer to notes at the end.
35314 Algebraic functions and @kbd{M-x} commands that don't have corresponding
35315 keystrokes are not listed in this summary.
35316 @xref{Command Index}. @xref{Function Index}.
35321 \vskip-2\baselineskip \null
35322 \gdef\sumrow#1{\sumrowx#1\relax}%
35323 \gdef\sumrowx#1\:#2\:#3\:#4\:#5\:#6\relax{%
35326 \hbox to5em{\sl\hss#1}%
35327 \hbox to5em{\tt#2\hss}%
35328 \hbox to4em{\sl#3\hss}%
35329 \hbox to5em{\rm\hss#4}%
35334 \gdef\sumlpar{{\rm(}}%
35335 \gdef\sumrpar{{\rm)}}%
35336 \gdef\sumcomma{{\rm,\thinspace}}%
35337 \gdef\sumexcl{{\rm!}}%
35338 \gdef\sumbreak{\vskip-2.5\baselineskip\goodbreak}%
35339 \gdef\minus#1{{\tt-}}%
35343 @catcode`@(=@active @let(=@sumlpar
35344 @catcode`@)=@active @let)=@sumrpar
35345 @catcode`@,=@active @let,=@sumcomma
35346 @catcode`@!=@active @let!=@sumexcl
35350 @advance@baselineskip-2.5pt
35353 @r{ @: C-x * a @: @: 33 @:calc-embedded-activate@:}
35354 @r{ @: C-x * b @: @: @:calc-big-or-small@:}
35355 @r{ @: C-x * c @: @: @:calc@:}
35356 @r{ @: C-x * d @: @: @:calc-embedded-duplicate@:}
35357 @r{ @: C-x * e @: @: 34 @:calc-embedded@:}
35358 @r{ @: C-x * f @:formula @: @:calc-embedded-new-formula@:}
35359 @r{ @: C-x * g @: @: 35 @:calc-grab-region@:}
35360 @r{ @: C-x * i @: @: @:calc-info@:}
35361 @r{ @: C-x * j @: @: @:calc-embedded-select@:}
35362 @r{ @: C-x * k @: @: @:calc-keypad@:}
35363 @r{ @: C-x * l @: @: @:calc-load-everything@:}
35364 @r{ @: C-x * m @: @: @:read-kbd-macro@:}
35365 @r{ @: C-x * n @: @: 4 @:calc-embedded-next@:}
35366 @r{ @: C-x * o @: @: @:calc-other-window@:}
35367 @r{ @: C-x * p @: @: 4 @:calc-embedded-previous@:}
35368 @r{ @: C-x * q @:formula @: @:quick-calc@:}
35369 @r{ @: C-x * r @: @: 36 @:calc-grab-rectangle@:}
35370 @r{ @: C-x * s @: @: @:calc-info-summary@:}
35371 @r{ @: C-x * t @: @: @:calc-tutorial@:}
35372 @r{ @: C-x * u @: @: @:calc-embedded-update-formula@:}
35373 @r{ @: C-x * w @: @: @:calc-embedded-word@:}
35374 @r{ @: C-x * x @: @: @:calc-quit@:}
35375 @r{ @: C-x * y @: @:1,28,49 @:calc-copy-to-buffer@:}
35376 @r{ @: C-x * z @: @: @:calc-user-invocation@:}
35377 @r{ @: C-x * : @: @: 36 @:calc-grab-sum-down@:}
35378 @r{ @: C-x * _ @: @: 36 @:calc-grab-sum-across@:}
35379 @r{ @: C-x * ` @:editing @: 30 @:calc-embedded-edit@:}
35380 @r{ @: C-x * 0 @:(zero) @: @:calc-reset@:}
35383 @r{ @: 0-9 @:number @: @:@:number}
35384 @r{ @: . @:number @: @:@:0.number}
35385 @r{ @: _ @:number @: @:-@:number}
35386 @r{ @: e @:number @: @:@:1e number}
35387 @r{ @: # @:number @: @:@:current-radix@tfn{#}number}
35388 @r{ @: P @:(in number) @: @:+/-@:}
35389 @r{ @: M @:(in number) @: @:mod@:}
35390 @r{ @: @@ ' " @: (in number)@: @:@:HMS form}
35391 @r{ @: h m s @: (in number)@: @:@:HMS form}
35394 @r{ @: ' @:formula @: 37,46 @:@:formula}
35395 @r{ @: $ @:formula @: 37,46 @:$@:formula}
35396 @r{ @: " @:string @: 37,46 @:@:string}
35399 @r{ a b@: + @: @: 2 @:add@:(a,b) a+b}
35400 @r{ a b@: - @: @: 2 @:sub@:(a,b) a@minus{}b}
35401 @r{ a b@: * @: @: 2 @:mul@:(a,b) a b, a*b}
35402 @r{ a b@: / @: @: 2 @:div@:(a,b) a/b}
35403 @r{ a b@: ^ @: @: 2 @:pow@:(a,b) a^b}
35404 @r{ a b@: I ^ @: @: 2 @:nroot@:(a,b) a^(1/b)}
35405 @r{ a b@: % @: @: 2 @:mod@:(a,b) a%b}
35406 @r{ a b@: \ @: @: 2 @:idiv@:(a,b) a\b}
35407 @r{ a b@: : @: @: 2 @:fdiv@:(a,b)}
35408 @r{ a b@: | @: @: 2 @:vconcat@:(a,b) a|b}
35409 @r{ a b@: I | @: @: @:vconcat@:(b,a) b|a}
35410 @r{ a b@: H | @: @: 2 @:append@:(a,b)}
35411 @r{ a b@: I H | @: @: @:append@:(b,a)}
35412 @r{ a@: & @: @: 1 @:inv@:(a) 1/a}
35413 @r{ a@: ! @: @: 1 @:fact@:(a) a!}
35414 @r{ a@: = @: @: 1 @:evalv@:(a)}
35415 @r{ a@: M-% @: @: @:percent@:(a) a%}
35418 @r{ ... a@: @summarykey{RET} @: @: 1 @:@:... a a}
35419 @r{ ... a@: @summarykey{SPC} @: @: 1 @:@:... a a}
35420 @r{... a b@: @summarykey{TAB} @: @: 3 @:@:... b a}
35421 @r{. a b c@: M-@summarykey{TAB} @: @: 3 @:@:... b c a}
35422 @r{... a b@: @summarykey{LFD} @: @: 1 @:@:... a b a}
35423 @r{ ... a@: @summarykey{DEL} @: @: 1 @:@:...}
35424 @r{... a b@: M-@summarykey{DEL} @: @: 1 @:@:... b}
35425 @r{ @: M-@summarykey{RET} @: @: 4 @:calc-last-args@:}
35426 @r{ a@: ` @:editing @: 1,30 @:calc-edit@:}
35429 @r{ ... a@: C-d @: @: 1 @:@:...}
35430 @r{ @: C-k @: @: 27 @:calc-kill@:}
35431 @r{ @: C-w @: @: 27 @:calc-kill-region@:}
35432 @r{ @: C-y @: @: @:calc-yank@:}
35433 @r{ @: C-_ @: @: 4 @:calc-undo@:}
35434 @r{ @: M-k @: @: 27 @:calc-copy-as-kill@:}
35435 @r{ @: M-w @: @: 27 @:calc-copy-region-as-kill@:}
35438 @r{ @: [ @: @: @:@:[...}
35439 @r{[.. a b@: ] @: @: @:@:[a,b]}
35440 @r{ @: ( @: @: @:@:(...}
35441 @r{(.. a b@: ) @: @: @:@:(a,b)}
35442 @r{ @: , @: @: @:@:vector or rect complex}
35443 @r{ @: ; @: @: @:@:matrix or polar complex}
35444 @r{ @: .. @: @: @:@:interval}
35447 @r{ @: ~ @: @: @:calc-num-prefix@:}
35448 @r{ @: < @: @: 4 @:calc-scroll-left@:}
35449 @r{ @: > @: @: 4 @:calc-scroll-right@:}
35450 @r{ @: @{ @: @: 4 @:calc-scroll-down@:}
35451 @r{ @: @} @: @: 4 @:calc-scroll-up@:}
35452 @r{ @: ? @: @: @:calc-help@:}
35455 @r{ a@: n @: @: 1 @:neg@:(a) @minus{}a}
35456 @r{ @: o @: @: 4 @:calc-realign@:}
35457 @r{ @: p @:precision @: 31 @:calc-precision@:}
35458 @r{ @: q @: @: @:calc-quit@:}
35459 @r{ @: w @: @: @:calc-why@:}
35460 @r{ @: x @:command @: @:M-x calc-@:command}
35461 @r{ a@: y @: @:1,28,49 @:calc-copy-to-buffer@:}
35464 @r{ a@: A @: @: 1 @:abs@:(a)}
35465 @r{ a b@: B @: @: 2 @:log@:(a,b)}
35466 @r{ a b@: I B @: @: 2 @:alog@:(a,b) b^a}
35467 @r{ a@: C @: @: 1 @:cos@:(a)}
35468 @r{ a@: I C @: @: 1 @:arccos@:(a)}
35469 @r{ a@: H C @: @: 1 @:cosh@:(a)}
35470 @r{ a@: I H C @: @: 1 @:arccosh@:(a)}
35471 @r{ @: D @: @: 4 @:calc-redo@:}
35472 @r{ a@: E @: @: 1 @:exp@:(a)}
35473 @r{ a@: H E @: @: 1 @:exp10@:(a) 10.^a}
35474 @r{ a@: F @: @: 1,11 @:floor@:(a,d)}
35475 @r{ a@: I F @: @: 1,11 @:ceil@:(a,d)}
35476 @r{ a@: H F @: @: 1,11 @:ffloor@:(a,d)}
35477 @r{ a@: I H F @: @: 1,11 @:fceil@:(a,d)}
35478 @r{ a@: G @: @: 1 @:arg@:(a)}
35479 @r{ @: H @:command @: 32 @:@:Hyperbolic}
35480 @r{ @: I @:command @: 32 @:@:Inverse}
35481 @r{ a@: J @: @: 1 @:conj@:(a)}
35482 @r{ @: K @:command @: 32 @:@:Keep-args}
35483 @r{ a@: L @: @: 1 @:ln@:(a)}
35484 @r{ a@: H L @: @: 1 @:log10@:(a)}
35485 @r{ @: M @: @: @:calc-more-recursion-depth@:}
35486 @r{ @: I M @: @: @:calc-less-recursion-depth@:}
35487 @r{ a@: N @: @: 5 @:evalvn@:(a)}
35488 @r{ @: O @:command @: 32 @:@:Option}
35489 @r{ @: P @: @: @:@:pi}
35490 @r{ @: I P @: @: @:@:gamma}
35491 @r{ @: H P @: @: @:@:e}
35492 @r{ @: I H P @: @: @:@:phi}
35493 @r{ a@: Q @: @: 1 @:sqrt@:(a)}
35494 @r{ a@: I Q @: @: 1 @:sqr@:(a) a^2}
35495 @r{ a@: R @: @: 1,11 @:round@:(a,d)}
35496 @r{ a@: I R @: @: 1,11 @:trunc@:(a,d)}
35497 @r{ a@: H R @: @: 1,11 @:fround@:(a,d)}
35498 @r{ a@: I H R @: @: 1,11 @:ftrunc@:(a,d)}
35499 @r{ a@: S @: @: 1 @:sin@:(a)}
35500 @r{ a@: I S @: @: 1 @:arcsin@:(a)}
35501 @r{ a@: H S @: @: 1 @:sinh@:(a)}
35502 @r{ a@: I H S @: @: 1 @:arcsinh@:(a)}
35503 @r{ a@: T @: @: 1 @:tan@:(a)}
35504 @r{ a@: I T @: @: 1 @:arctan@:(a)}
35505 @r{ a@: H T @: @: 1 @:tanh@:(a)}
35506 @r{ a@: I H T @: @: 1 @:arctanh@:(a)}
35507 @r{ @: U @: @: 4 @:calc-undo@:}
35508 @r{ @: X @: @: 4 @:calc-call-last-kbd-macro@:}
35511 @r{ a b@: a = @: @: 2 @:eq@:(a,b) a=b}
35512 @r{ a b@: a # @: @: 2 @:neq@:(a,b) a!=b}
35513 @r{ a b@: a < @: @: 2 @:lt@:(a,b) a<b}
35514 @r{ a b@: a > @: @: 2 @:gt@:(a,b) a>b}
35515 @r{ a b@: a [ @: @: 2 @:leq@:(a,b) a<=b}
35516 @r{ a b@: a ] @: @: 2 @:geq@:(a,b) a>=b}
35517 @r{ a b@: a @{ @: @: 2 @:in@:(a,b)}
35518 @r{ a b@: a & @: @: 2,45 @:land@:(a,b) a&&b}
35519 @r{ a b@: a | @: @: 2,45 @:lor@:(a,b) a||b}
35520 @r{ a@: a ! @: @: 1,45 @:lnot@:(a) !a}
35521 @r{ a b c@: a : @: @: 45 @:if@:(a,b,c) a?b:c}
35522 @r{ a@: a . @: @: 1 @:rmeq@:(a)}
35523 @r{ a@: a " @: @: 7,8 @:calc-expand-formula@:}
35526 @r{ a@: a + @:i, l, h @: 6,38 @:sum@:(a,i,l,h)}
35527 @r{ a@: a - @:i, l, h @: 6,38 @:asum@:(a,i,l,h)}
35528 @r{ a@: a * @:i, l, h @: 6,38 @:prod@:(a,i,l,h)}
35529 @r{ a b@: a _ @: @: 2 @:subscr@:(a,b) a_b}
35532 @r{ a b@: a \ @: @: 2 @:pdiv@:(a,b)}
35533 @r{ a b@: a % @: @: 2 @:prem@:(a,b)}
35534 @r{ a b@: a / @: @: 2 @:pdivrem@:(a,b) [q,r]}
35535 @r{ a b@: H a / @: @: 2 @:pdivide@:(a,b) q+r/b}
35538 @r{ a@: a a @: @: 1 @:apart@:(a)}
35539 @r{ a@: a b @:old, new @: 38 @:subst@:(a,old,new)}
35540 @r{ a@: a c @:v @: 38 @:collect@:(a,v)}
35541 @r{ a@: a d @:v @: 4,38 @:deriv@:(a,v)}
35542 @r{ a@: H a d @:v @: 4,38 @:tderiv@:(a,v)}
35543 @r{ a@: a e @: @: @:esimplify@:(a)}
35544 @r{ a@: a f @: @: 1 @:factor@:(a)}
35545 @r{ a@: H a f @: @: 1 @:factors@:(a)}
35546 @r{ a b@: a g @: @: 2 @:pgcd@:(a,b)}
35547 @r{ a@: a i @:v @: 38 @:integ@:(a,v)}
35548 @r{ a@: a m @:pats @: 38 @:match@:(a,pats)}
35549 @r{ a@: I a m @:pats @: 38 @:matchnot@:(a,pats)}
35550 @r{ data x@: a p @: @: 28 @:polint@:(data,x)}
35551 @r{ data x@: H a p @: @: 28 @:ratint@:(data,x)}
35552 @r{ a@: a n @: @: 1 @:nrat@:(a)}
35553 @r{ a@: a r @:rules @:4,8,38 @:rewrite@:(a,rules,n)}
35554 @r{ a@: a s @: @: @:simplify@:(a)}
35555 @r{ a@: a t @:v, n @: 31,39 @:taylor@:(a,v,n)}
35556 @r{ a@: a v @: @: 7,8 @:calc-alg-evaluate@:}
35557 @r{ a@: a x @: @: 4,8 @:expand@:(a)}
35560 @r{ data@: a F @:model, vars @: 48 @:fit@:(m,iv,pv,data)}
35561 @r{ data@: I a F @:model, vars @: 48 @:xfit@:(m,iv,pv,data)}
35562 @r{ data@: H a F @:model, vars @: 48 @:efit@:(m,iv,pv,data)}
35563 @r{ a@: a I @:v, l, h @: 38 @:ninteg@:(a,v,l,h)}
35564 @r{ a b@: a M @:op @: 22 @:mapeq@:(op,a,b)}
35565 @r{ a b@: I a M @:op @: 22 @:mapeqr@:(op,a,b)}
35566 @r{ a b@: H a M @:op @: 22 @:mapeqp@:(op,a,b)}
35567 @r{ a g@: a N @:v @: 38 @:minimize@:(a,v,g)}
35568 @r{ a g@: H a N @:v @: 38 @:wminimize@:(a,v,g)}
35569 @r{ a@: a P @:v @: 38 @:roots@:(a,v)}
35570 @r{ a g@: a R @:v @: 38 @:root@:(a,v,g)}
35571 @r{ a g@: H a R @:v @: 38 @:wroot@:(a,v,g)}
35572 @r{ a@: a S @:v @: 38 @:solve@:(a,v)}
35573 @r{ a@: I a S @:v @: 38 @:finv@:(a,v)}
35574 @r{ a@: H a S @:v @: 38 @:fsolve@:(a,v)}
35575 @r{ a@: I H a S @:v @: 38 @:ffinv@:(a,v)}
35576 @r{ a@: a T @:i, l, h @: 6,38 @:table@:(a,i,l,h)}
35577 @r{ a g@: a X @:v @: 38 @:maximize@:(a,v,g)}
35578 @r{ a g@: H a X @:v @: 38 @:wmaximize@:(a,v,g)}
35581 @r{ a b@: b a @: @: 9 @:and@:(a,b,w)}
35582 @r{ a@: b c @: @: 9 @:clip@:(a,w)}
35583 @r{ a b@: b d @: @: 9 @:diff@:(a,b,w)}
35584 @r{ a@: b l @: @: 10 @:lsh@:(a,n,w)}
35585 @r{ a n@: H b l @: @: 9 @:lsh@:(a,n,w)}
35586 @r{ a@: b n @: @: 9 @:not@:(a,w)}
35587 @r{ a b@: b o @: @: 9 @:or@:(a,b,w)}
35588 @r{ v@: b p @: @: 1 @:vpack@:(v)}
35589 @r{ a@: b r @: @: 10 @:rsh@:(a,n,w)}
35590 @r{ a n@: H b r @: @: 9 @:rsh@:(a,n,w)}
35591 @r{ a@: b t @: @: 10 @:rot@:(a,n,w)}
35592 @r{ a n@: H b t @: @: 9 @:rot@:(a,n,w)}
35593 @r{ a@: b u @: @: 1 @:vunpack@:(a)}
35594 @r{ @: b w @:w @: 9,50 @:calc-word-size@:}
35595 @r{ a b@: b x @: @: 9 @:xor@:(a,b,w)}
35598 @r{c s l p@: b D @: @: @:ddb@:(c,s,l,p)}
35599 @r{ r n p@: b F @: @: @:fv@:(r,n,p)}
35600 @r{ r n p@: I b F @: @: @:fvb@:(r,n,p)}
35601 @r{ r n p@: H b F @: @: @:fvl@:(r,n,p)}
35602 @r{ v@: b I @: @: 19 @:irr@:(v)}
35603 @r{ v@: I b I @: @: 19 @:irrb@:(v)}
35604 @r{ a@: b L @: @: 10 @:ash@:(a,n,w)}
35605 @r{ a n@: H b L @: @: 9 @:ash@:(a,n,w)}
35606 @r{ r n a@: b M @: @: @:pmt@:(r,n,a)}
35607 @r{ r n a@: I b M @: @: @:pmtb@:(r,n,a)}
35608 @r{ r n a@: H b M @: @: @:pmtl@:(r,n,a)}
35609 @r{ r v@: b N @: @: 19 @:npv@:(r,v)}
35610 @r{ r v@: I b N @: @: 19 @:npvb@:(r,v)}
35611 @r{ r n p@: b P @: @: @:pv@:(r,n,p)}
35612 @r{ r n p@: I b P @: @: @:pvb@:(r,n,p)}
35613 @r{ r n p@: H b P @: @: @:pvl@:(r,n,p)}
35614 @r{ a@: b R @: @: 10 @:rash@:(a,n,w)}
35615 @r{ a n@: H b R @: @: 9 @:rash@:(a,n,w)}
35616 @r{ c s l@: b S @: @: @:sln@:(c,s,l)}
35617 @r{ n p a@: b T @: @: @:rate@:(n,p,a)}
35618 @r{ n p a@: I b T @: @: @:rateb@:(n,p,a)}
35619 @r{ n p a@: H b T @: @: @:ratel@:(n,p,a)}
35620 @r{c s l p@: b Y @: @: @:syd@:(c,s,l,p)}
35622 @r{ r p a@: b # @: @: @:nper@:(r,p,a)}
35623 @r{ r p a@: I b # @: @: @:nperb@:(r,p,a)}
35624 @r{ r p a@: H b # @: @: @:nperl@:(r,p,a)}
35625 @r{ a b@: b % @: @: @:relch@:(a,b)}
35628 @r{ a@: c c @: @: 5 @:pclean@:(a,p)}
35629 @r{ a@: c 0-9 @: @: @:pclean@:(a,p)}
35630 @r{ a@: H c c @: @: 5 @:clean@:(a,p)}
35631 @r{ a@: H c 0-9 @: @: @:clean@:(a,p)}
35632 @r{ a@: c d @: @: 1 @:deg@:(a)}
35633 @r{ a@: c f @: @: 1 @:pfloat@:(a)}
35634 @r{ a@: H c f @: @: 1 @:float@:(a)}
35635 @r{ a@: c h @: @: 1 @:hms@:(a)}
35636 @r{ a@: c p @: @: @:polar@:(a)}
35637 @r{ a@: I c p @: @: @:rect@:(a)}
35638 @r{ a@: c r @: @: 1 @:rad@:(a)}
35641 @r{ a@: c F @: @: 5 @:pfrac@:(a,p)}
35642 @r{ a@: H c F @: @: 5 @:frac@:(a,p)}
35645 @r{ a@: c % @: @: @:percent@:(a*100)}
35648 @r{ @: d . @:char @: 50 @:calc-point-char@:}
35649 @r{ @: d , @:char @: 50 @:calc-group-char@:}
35650 @r{ @: d < @: @: 13,50 @:calc-left-justify@:}
35651 @r{ @: d = @: @: 13,50 @:calc-center-justify@:}
35652 @r{ @: d > @: @: 13,50 @:calc-right-justify@:}
35653 @r{ @: d @{ @:label @: 50 @:calc-left-label@:}
35654 @r{ @: d @} @:label @: 50 @:calc-right-label@:}
35655 @r{ @: d [ @: @: 4 @:calc-truncate-up@:}
35656 @r{ @: d ] @: @: 4 @:calc-truncate-down@:}
35657 @r{ @: d " @: @: 12,50 @:calc-display-strings@:}
35658 @r{ @: d @summarykey{SPC} @: @: @:calc-refresh@:}
35659 @r{ @: d @summarykey{RET} @: @: 1 @:calc-refresh-top@:}
35662 @r{ @: d 0 @: @: 50 @:calc-decimal-radix@:}
35663 @r{ @: d 2 @: @: 50 @:calc-binary-radix@:}
35664 @r{ @: d 6 @: @: 50 @:calc-hex-radix@:}
35665 @r{ @: d 8 @: @: 50 @:calc-octal-radix@:}
35668 @r{ @: d b @: @:12,13,50 @:calc-line-breaking@:}
35669 @r{ @: d c @: @: 50 @:calc-complex-notation@:}
35670 @r{ @: d d @:format @: 50 @:calc-date-notation@:}
35671 @r{ @: d e @: @: 5,50 @:calc-eng-notation@:}
35672 @r{ @: d f @:num @: 31,50 @:calc-fix-notation@:}
35673 @r{ @: d g @: @:12,13,50 @:calc-group-digits@:}
35674 @r{ @: d h @:format @: 50 @:calc-hms-notation@:}
35675 @r{ @: d i @: @: 50 @:calc-i-notation@:}
35676 @r{ @: d j @: @: 50 @:calc-j-notation@:}
35677 @r{ @: d l @: @: 12,50 @:calc-line-numbering@:}
35678 @r{ @: d n @: @: 5,50 @:calc-normal-notation@:}
35679 @r{ @: d o @:format @: 50 @:calc-over-notation@:}
35680 @r{ @: d p @: @: 12,50 @:calc-show-plain@:}
35681 @r{ @: d r @:radix @: 31,50 @:calc-radix@:}
35682 @r{ @: d s @: @: 5,50 @:calc-sci-notation@:}
35683 @r{ @: d t @: @: 27 @:calc-truncate-stack@:}
35684 @r{ @: d w @: @: 12,13 @:calc-auto-why@:}
35685 @r{ @: d z @: @: 12,50 @:calc-leading-zeros@:}
35688 @r{ @: d B @: @: 50 @:calc-big-language@:}
35689 @r{ @: d C @: @: 50 @:calc-c-language@:}
35690 @r{ @: d E @: @: 50 @:calc-eqn-language@:}
35691 @r{ @: d F @: @: 50 @:calc-fortran-language@:}
35692 @r{ @: d M @: @: 50 @:calc-mathematica-language@:}
35693 @r{ @: d N @: @: 50 @:calc-normal-language@:}
35694 @r{ @: d O @: @: 50 @:calc-flat-language@:}
35695 @r{ @: d P @: @: 50 @:calc-pascal-language@:}
35696 @r{ @: d T @: @: 50 @:calc-tex-language@:}
35697 @r{ @: d L @: @: 50 @:calc-latex-language@:}
35698 @r{ @: d U @: @: 50 @:calc-unformatted-language@:}
35699 @r{ @: d W @: @: 50 @:calc-maple-language@:}
35702 @r{ a@: f [ @: @: 4 @:decr@:(a,n)}
35703 @r{ a@: f ] @: @: 4 @:incr@:(a,n)}
35706 @r{ a b@: f b @: @: 2 @:beta@:(a,b)}
35707 @r{ a@: f e @: @: 1 @:erf@:(a)}
35708 @r{ a@: I f e @: @: 1 @:erfc@:(a)}
35709 @r{ a@: f g @: @: 1 @:gamma@:(a)}
35710 @r{ a b@: f h @: @: 2 @:hypot@:(a,b)}
35711 @r{ a@: f i @: @: 1 @:im@:(a)}
35712 @r{ n a@: f j @: @: 2 @:besJ@:(n,a)}
35713 @r{ a b@: f n @: @: 2 @:min@:(a,b)}
35714 @r{ a@: f r @: @: 1 @:re@:(a)}
35715 @r{ a@: f s @: @: 1 @:sign@:(a)}
35716 @r{ a b@: f x @: @: 2 @:max@:(a,b)}
35717 @r{ n a@: f y @: @: 2 @:besY@:(n,a)}
35720 @r{ a@: f A @: @: 1 @:abssqr@:(a)}
35721 @r{ x a b@: f B @: @: @:betaI@:(x,a,b)}
35722 @r{ x a b@: H f B @: @: @:betaB@:(x,a,b)}
35723 @r{ a@: f E @: @: 1 @:expm1@:(a)}
35724 @r{ a x@: f G @: @: 2 @:gammaP@:(a,x)}
35725 @r{ a x@: I f G @: @: 2 @:gammaQ@:(a,x)}
35726 @r{ a x@: H f G @: @: 2 @:gammag@:(a,x)}
35727 @r{ a x@: I H f G @: @: 2 @:gammaG@:(a,x)}
35728 @r{ a b@: f I @: @: 2 @:ilog@:(a,b)}
35729 @r{ a b@: I f I @: @: 2 @:alog@:(a,b) b^a}
35730 @r{ a@: f L @: @: 1 @:lnp1@:(a)}
35731 @r{ a@: f M @: @: 1 @:mant@:(a)}
35732 @r{ a@: f Q @: @: 1 @:isqrt@:(a)}
35733 @r{ a@: I f Q @: @: 1 @:sqr@:(a) a^2}
35734 @r{ a n@: f S @: @: 2 @:scf@:(a,n)}
35735 @r{ y x@: f T @: @: @:arctan2@:(y,x)}
35736 @r{ a@: f X @: @: 1 @:xpon@:(a)}
35739 @r{ x y@: g a @: @: 28,40 @:calc-graph-add@:}
35740 @r{ @: g b @: @: 12 @:calc-graph-border@:}
35741 @r{ @: g c @: @: @:calc-graph-clear@:}
35742 @r{ @: g d @: @: 41 @:calc-graph-delete@:}
35743 @r{ x y@: g f @: @: 28,40 @:calc-graph-fast@:}
35744 @r{ @: g g @: @: 12 @:calc-graph-grid@:}
35745 @r{ @: g h @:title @: @:calc-graph-header@:}
35746 @r{ @: g j @: @: 4 @:calc-graph-juggle@:}
35747 @r{ @: g k @: @: 12 @:calc-graph-key@:}
35748 @r{ @: g l @: @: 12 @:calc-graph-log-x@:}
35749 @r{ @: g n @:name @: @:calc-graph-name@:}
35750 @r{ @: g p @: @: 42 @:calc-graph-plot@:}
35751 @r{ @: g q @: @: @:calc-graph-quit@:}
35752 @r{ @: g r @:range @: @:calc-graph-range-x@:}
35753 @r{ @: g s @: @: 12,13 @:calc-graph-line-style@:}
35754 @r{ @: g t @:title @: @:calc-graph-title-x@:}
35755 @r{ @: g v @: @: @:calc-graph-view-commands@:}
35756 @r{ @: g x @:display @: @:calc-graph-display@:}
35757 @r{ @: g z @: @: 12 @:calc-graph-zero-x@:}
35760 @r{ x y z@: g A @: @: 28,40 @:calc-graph-add-3d@:}
35761 @r{ @: g C @:command @: @:calc-graph-command@:}
35762 @r{ @: g D @:device @: 43,44 @:calc-graph-device@:}
35763 @r{ x y z@: g F @: @: 28,40 @:calc-graph-fast-3d@:}
35764 @r{ @: g H @: @: 12 @:calc-graph-hide@:}
35765 @r{ @: g K @: @: @:calc-graph-kill@:}
35766 @r{ @: g L @: @: 12 @:calc-graph-log-y@:}
35767 @r{ @: g N @:number @: 43,51 @:calc-graph-num-points@:}
35768 @r{ @: g O @:filename @: 43,44 @:calc-graph-output@:}
35769 @r{ @: g P @: @: 42 @:calc-graph-print@:}
35770 @r{ @: g R @:range @: @:calc-graph-range-y@:}
35771 @r{ @: g S @: @: 12,13 @:calc-graph-point-style@:}
35772 @r{ @: g T @:title @: @:calc-graph-title-y@:}
35773 @r{ @: g V @: @: @:calc-graph-view-trail@:}
35774 @r{ @: g X @:format @: @:calc-graph-geometry@:}
35775 @r{ @: g Z @: @: 12 @:calc-graph-zero-y@:}
35778 @r{ @: g C-l @: @: 12 @:calc-graph-log-z@:}
35779 @r{ @: g C-r @:range @: @:calc-graph-range-z@:}
35780 @r{ @: g C-t @:title @: @:calc-graph-title-z@:}
35783 @r{ @: h b @: @: @:calc-describe-bindings@:}
35784 @r{ @: h c @:key @: @:calc-describe-key-briefly@:}
35785 @r{ @: h f @:function @: @:calc-describe-function@:}
35786 @r{ @: h h @: @: @:calc-full-help@:}
35787 @r{ @: h i @: @: @:calc-info@:}
35788 @r{ @: h k @:key @: @:calc-describe-key@:}
35789 @r{ @: h n @: @: @:calc-view-news@:}
35790 @r{ @: h s @: @: @:calc-info-summary@:}
35791 @r{ @: h t @: @: @:calc-tutorial@:}
35792 @r{ @: h v @:var @: @:calc-describe-variable@:}
35795 @r{ @: j 1-9 @: @: @:calc-select-part@:}
35796 @r{ @: j @summarykey{RET} @: @: 27 @:calc-copy-selection@:}
35797 @r{ @: j @summarykey{DEL} @: @: 27 @:calc-del-selection@:}
35798 @r{ @: j ' @:formula @: 27 @:calc-enter-selection@:}
35799 @r{ @: j ` @:editing @: 27,30 @:calc-edit-selection@:}
35800 @r{ @: j " @: @: 7,27 @:calc-sel-expand-formula@:}
35803 @r{ @: j + @:formula @: 27 @:calc-sel-add-both-sides@:}
35804 @r{ @: j - @:formula @: 27 @:calc-sel-sub-both-sides@:}
35805 @r{ @: j * @:formula @: 27 @:calc-sel-mul-both-sides@:}
35806 @r{ @: j / @:formula @: 27 @:calc-sel-div-both-sides@:}
35807 @r{ @: j & @: @: 27 @:calc-sel-invert@:}
35810 @r{ @: j a @: @: 27 @:calc-select-additional@:}
35811 @r{ @: j b @: @: 12 @:calc-break-selections@:}
35812 @r{ @: j c @: @: @:calc-clear-selections@:}
35813 @r{ @: j d @: @: 12,50 @:calc-show-selections@:}
35814 @r{ @: j e @: @: 12 @:calc-enable-selections@:}
35815 @r{ @: j l @: @: 4,27 @:calc-select-less@:}
35816 @r{ @: j m @: @: 4,27 @:calc-select-more@:}
35817 @r{ @: j n @: @: 4 @:calc-select-next@:}
35818 @r{ @: j o @: @: 4,27 @:calc-select-once@:}
35819 @r{ @: j p @: @: 4 @:calc-select-previous@:}
35820 @r{ @: j r @:rules @:4,8,27 @:calc-rewrite-selection@:}
35821 @r{ @: j s @: @: 4,27 @:calc-select-here@:}
35822 @r{ @: j u @: @: 27 @:calc-unselect@:}
35823 @r{ @: j v @: @: 7,27 @:calc-sel-evaluate@:}
35826 @r{ @: j C @: @: 27 @:calc-sel-commute@:}
35827 @r{ @: j D @: @: 4,27 @:calc-sel-distribute@:}
35828 @r{ @: j E @: @: 27 @:calc-sel-jump-equals@:}
35829 @r{ @: j I @: @: 27 @:calc-sel-isolate@:}
35830 @r{ @: H j I @: @: 27 @:calc-sel-isolate@: (full)}
35831 @r{ @: j L @: @: 4,27 @:calc-commute-left@:}
35832 @r{ @: j M @: @: 27 @:calc-sel-merge@:}
35833 @r{ @: j N @: @: 27 @:calc-sel-negate@:}
35834 @r{ @: j O @: @: 4,27 @:calc-select-once-maybe@:}
35835 @r{ @: j R @: @: 4,27 @:calc-commute-right@:}
35836 @r{ @: j S @: @: 4,27 @:calc-select-here-maybe@:}
35837 @r{ @: j U @: @: 27 @:calc-sel-unpack@:}
35840 @r{ @: k a @: @: @:calc-random-again@:}
35841 @r{ n@: k b @: @: 1 @:bern@:(n)}
35842 @r{ n x@: H k b @: @: 2 @:bern@:(n,x)}
35843 @r{ n m@: k c @: @: 2 @:choose@:(n,m)}
35844 @r{ n m@: H k c @: @: 2 @:perm@:(n,m)}
35845 @r{ n@: k d @: @: 1 @:dfact@:(n) n!!}
35846 @r{ n@: k e @: @: 1 @:euler@:(n)}
35847 @r{ n x@: H k e @: @: 2 @:euler@:(n,x)}
35848 @r{ n@: k f @: @: 4 @:prfac@:(n)}
35849 @r{ n m@: k g @: @: 2 @:gcd@:(n,m)}
35850 @r{ m n@: k h @: @: 14 @:shuffle@:(n,m)}
35851 @r{ n m@: k l @: @: 2 @:lcm@:(n,m)}
35852 @r{ n@: k m @: @: 1 @:moebius@:(n)}
35853 @r{ n@: k n @: @: 4 @:nextprime@:(n)}
35854 @r{ n@: I k n @: @: 4 @:prevprime@:(n)}
35855 @r{ n@: k p @: @: 4,28 @:calc-prime-test@:}
35856 @r{ m@: k r @: @: 14 @:random@:(m)}
35857 @r{ n m@: k s @: @: 2 @:stir1@:(n,m)}
35858 @r{ n m@: H k s @: @: 2 @:stir2@:(n,m)}
35859 @r{ n@: k t @: @: 1 @:totient@:(n)}
35862 @r{ n p x@: k B @: @: @:utpb@:(x,n,p)}
35863 @r{ n p x@: I k B @: @: @:ltpb@:(x,n,p)}
35864 @r{ v x@: k C @: @: @:utpc@:(x,v)}
35865 @r{ v x@: I k C @: @: @:ltpc@:(x,v)}
35866 @r{ n m@: k E @: @: @:egcd@:(n,m)}
35867 @r{v1 v2 x@: k F @: @: @:utpf@:(x,v1,v2)}
35868 @r{v1 v2 x@: I k F @: @: @:ltpf@:(x,v1,v2)}
35869 @r{ m s x@: k N @: @: @:utpn@:(x,m,s)}
35870 @r{ m s x@: I k N @: @: @:ltpn@:(x,m,s)}
35871 @r{ m x@: k P @: @: @:utpp@:(x,m)}
35872 @r{ m x@: I k P @: @: @:ltpp@:(x,m)}
35873 @r{ v x@: k T @: @: @:utpt@:(x,v)}
35874 @r{ v x@: I k T @: @: @:ltpt@:(x,v)}
35877 @r{ @: m a @: @: 12,13 @:calc-algebraic-mode@:}
35878 @r{ @: m d @: @: @:calc-degrees-mode@:}
35879 @r{ @: m e @: @: @:calc-embedded-preserve-modes@:}
35880 @r{ @: m f @: @: 12 @:calc-frac-mode@:}
35881 @r{ @: m g @: @: 52 @:calc-get-modes@:}
35882 @r{ @: m h @: @: @:calc-hms-mode@:}
35883 @r{ @: m i @: @: 12,13 @:calc-infinite-mode@:}
35884 @r{ @: m m @: @: @:calc-save-modes@:}
35885 @r{ @: m p @: @: 12 @:calc-polar-mode@:}
35886 @r{ @: m r @: @: @:calc-radians-mode@:}
35887 @r{ @: m s @: @: 12 @:calc-symbolic-mode@:}
35888 @r{ @: m t @: @: 12 @:calc-total-algebraic-mode@:}
35889 @r{ @: m v @: @: 12,13 @:calc-matrix-mode@:}
35890 @r{ @: m w @: @: 13 @:calc-working@:}
35891 @r{ @: m x @: @: @:calc-always-load-extensions@:}
35894 @r{ @: m A @: @: 12 @:calc-alg-simplify-mode@:}
35895 @r{ @: m B @: @: 12 @:calc-bin-simplify-mode@:}
35896 @r{ @: m C @: @: 12 @:calc-auto-recompute@:}
35897 @r{ @: m D @: @: @:calc-default-simplify-mode@:}
35898 @r{ @: m E @: @: 12 @:calc-ext-simplify-mode@:}
35899 @r{ @: m F @:filename @: 13 @:calc-settings-file-name@:}
35900 @r{ @: m N @: @: 12 @:calc-num-simplify-mode@:}
35901 @r{ @: m O @: @: 12 @:calc-no-simplify-mode@:}
35902 @r{ @: m R @: @: 12,13 @:calc-mode-record-mode@:}
35903 @r{ @: m S @: @: 12 @:calc-shift-prefix@:}
35904 @r{ @: m U @: @: 12 @:calc-units-simplify-mode@:}
35907 @r{ @: r s @:register @: 27 @:calc-copy-to-register@:}
35908 @r{ @: r i @:register @: @:calc-insert-register@:}
35911 @r{ @: s c @:var1, var2 @: 29 @:calc-copy-variable@:}
35912 @r{ @: s d @:var, decl @: @:calc-declare-variable@:}
35913 @r{ @: s e @:var, editing @: 29,30 @:calc-edit-variable@:}
35914 @r{ @: s i @:buffer @: @:calc-insert-variables@:}
35915 @r{ @: s k @:const, var @: 29 @:calc-copy-special-constant@:}
35916 @r{ a b@: s l @:var @: 29 @:@:a (letting var=b)}
35917 @r{ a ...@: s m @:op, var @: 22,29 @:calc-store-map@:}
35918 @r{ @: s n @:var @: 29,47 @:calc-store-neg@: (v/-1)}
35919 @r{ @: s p @:var @: 29 @:calc-permanent-variable@:}
35920 @r{ @: s r @:var @: 29 @:@:v (recalled value)}
35921 @r{ @: r 0-9 @: @: @:calc-recall-quick@:}
35922 @r{ a@: s s @:var @: 28,29 @:calc-store@:}
35923 @r{ a@: s 0-9 @: @: @:calc-store-quick@:}
35924 @r{ a@: s t @:var @: 29 @:calc-store-into@:}
35925 @r{ a@: t 0-9 @: @: @:calc-store-into-quick@:}
35926 @r{ @: s u @:var @: 29 @:calc-unstore@:}
35927 @r{ a@: s x @:var @: 29 @:calc-store-exchange@:}
35930 @r{ @: s A @:editing @: 30 @:calc-edit-AlgSimpRules@:}
35931 @r{ @: s D @:editing @: 30 @:calc-edit-Decls@:}
35932 @r{ @: s E @:editing @: 30 @:calc-edit-EvalRules@:}
35933 @r{ @: s F @:editing @: 30 @:calc-edit-FitRules@:}
35934 @r{ @: s G @:editing @: 30 @:calc-edit-GenCount@:}
35935 @r{ @: s H @:editing @: 30 @:calc-edit-Holidays@:}
35936 @r{ @: s I @:editing @: 30 @:calc-edit-IntegLimit@:}
35937 @r{ @: s L @:editing @: 30 @:calc-edit-LineStyles@:}
35938 @r{ @: s P @:editing @: 30 @:calc-edit-PointStyles@:}
35939 @r{ @: s R @:editing @: 30 @:calc-edit-PlotRejects@:}
35940 @r{ @: s T @:editing @: 30 @:calc-edit-TimeZone@:}
35941 @r{ @: s U @:editing @: 30 @:calc-edit-Units@:}
35942 @r{ @: s X @:editing @: 30 @:calc-edit-ExtSimpRules@:}
35945 @r{ a@: s + @:var @: 29,47 @:calc-store-plus@: (v+a)}
35946 @r{ a@: s - @:var @: 29,47 @:calc-store-minus@: (v-a)}
35947 @r{ a@: s * @:var @: 29,47 @:calc-store-times@: (v*a)}
35948 @r{ a@: s / @:var @: 29,47 @:calc-store-div@: (v/a)}
35949 @r{ a@: s ^ @:var @: 29,47 @:calc-store-power@: (v^a)}
35950 @r{ a@: s | @:var @: 29,47 @:calc-store-concat@: (v|a)}
35951 @r{ @: s & @:var @: 29,47 @:calc-store-inv@: (v^-1)}
35952 @r{ @: s [ @:var @: 29,47 @:calc-store-decr@: (v-1)}
35953 @r{ @: s ] @:var @: 29,47 @:calc-store-incr@: (v-(-1))}
35954 @r{ a b@: s : @: @: 2 @:assign@:(a,b) a @tfn{:=} b}
35955 @r{ a@: s = @: @: 1 @:evalto@:(a,b) a @tfn{=>}}
35958 @r{ @: t [ @: @: 4 @:calc-trail-first@:}
35959 @r{ @: t ] @: @: 4 @:calc-trail-last@:}
35960 @r{ @: t < @: @: 4 @:calc-trail-scroll-left@:}
35961 @r{ @: t > @: @: 4 @:calc-trail-scroll-right@:}
35962 @r{ @: t . @: @: 12 @:calc-full-trail-vectors@:}
35965 @r{ @: t b @: @: 4 @:calc-trail-backward@:}
35966 @r{ @: t d @: @: 12,50 @:calc-trail-display@:}
35967 @r{ @: t f @: @: 4 @:calc-trail-forward@:}
35968 @r{ @: t h @: @: @:calc-trail-here@:}
35969 @r{ @: t i @: @: @:calc-trail-in@:}
35970 @r{ @: t k @: @: 4 @:calc-trail-kill@:}
35971 @r{ @: t m @:string @: @:calc-trail-marker@:}
35972 @r{ @: t n @: @: 4 @:calc-trail-next@:}
35973 @r{ @: t o @: @: @:calc-trail-out@:}
35974 @r{ @: t p @: @: 4 @:calc-trail-previous@:}
35975 @r{ @: t r @:string @: @:calc-trail-isearch-backward@:}
35976 @r{ @: t s @:string @: @:calc-trail-isearch-forward@:}
35977 @r{ @: t y @: @: 4 @:calc-trail-yank@:}
35980 @r{ d@: t C @:oz, nz @: @:tzconv@:(d,oz,nz)}
35981 @r{d oz nz@: t C @:$ @: @:tzconv@:(d,oz,nz)}
35982 @r{ d@: t D @: @: 15 @:date@:(d)}
35983 @r{ d@: t I @: @: 4 @:incmonth@:(d,n)}
35984 @r{ d@: t J @: @: 16 @:julian@:(d,z)}
35985 @r{ d@: t M @: @: 17 @:newmonth@:(d,n)}
35986 @r{ @: t N @: @: 16 @:now@:(z)}
35987 @r{ d@: t P @:1 @: 31 @:year@:(d)}
35988 @r{ d@: t P @:2 @: 31 @:month@:(d)}
35989 @r{ d@: t P @:3 @: 31 @:day@:(d)}
35990 @r{ d@: t P @:4 @: 31 @:hour@:(d)}
35991 @r{ d@: t P @:5 @: 31 @:minute@:(d)}
35992 @r{ d@: t P @:6 @: 31 @:second@:(d)}
35993 @r{ d@: t P @:7 @: 31 @:weekday@:(d)}
35994 @r{ d@: t P @:8 @: 31 @:yearday@:(d)}
35995 @r{ d@: t P @:9 @: 31 @:time@:(d)}
35996 @r{ d@: t U @: @: 16 @:unixtime@:(d,z)}
35997 @r{ d@: t W @: @: 17 @:newweek@:(d,w)}
35998 @r{ d@: t Y @: @: 17 @:newyear@:(d,n)}
36001 @r{ a b@: t + @: @: 2 @:badd@:(a,b)}
36002 @r{ a b@: t - @: @: 2 @:bsub@:(a,b)}
36005 @r{ @: u a @: @: 12 @:calc-autorange-units@:}
36006 @r{ a@: u b @: @: @:calc-base-units@:}
36007 @r{ a@: u c @:units @: 18 @:calc-convert-units@:}
36008 @r{ defn@: u d @:unit, descr @: @:calc-define-unit@:}
36009 @r{ @: u e @: @: @:calc-explain-units@:}
36010 @r{ @: u g @:unit @: @:calc-get-unit-definition@:}
36011 @r{ @: u p @: @: @:calc-permanent-units@:}
36012 @r{ a@: u r @: @: @:calc-remove-units@:}
36013 @r{ a@: u s @: @: @:usimplify@:(a)}
36014 @r{ a@: u t @:units @: 18 @:calc-convert-temperature@:}
36015 @r{ @: u u @:unit @: @:calc-undefine-unit@:}
36016 @r{ @: u v @: @: @:calc-enter-units-table@:}
36017 @r{ a@: u x @: @: @:calc-extract-units@:}
36018 @r{ a@: u 0-9 @: @: @:calc-quick-units@:}
36021 @r{ v1 v2@: u C @: @: 20 @:vcov@:(v1,v2)}
36022 @r{ v1 v2@: I u C @: @: 20 @:vpcov@:(v1,v2)}
36023 @r{ v1 v2@: H u C @: @: 20 @:vcorr@:(v1,v2)}
36024 @r{ v@: u G @: @: 19 @:vgmean@:(v)}
36025 @r{ a b@: H u G @: @: 2 @:agmean@:(a,b)}
36026 @r{ v@: u M @: @: 19 @:vmean@:(v)}
36027 @r{ v@: I u M @: @: 19 @:vmeane@:(v)}
36028 @r{ v@: H u M @: @: 19 @:vmedian@:(v)}
36029 @r{ v@: I H u M @: @: 19 @:vhmean@:(v)}
36030 @r{ v@: u N @: @: 19 @:vmin@:(v)}
36031 @r{ v@: u S @: @: 19 @:vsdev@:(v)}
36032 @r{ v@: I u S @: @: 19 @:vpsdev@:(v)}
36033 @r{ v@: H u S @: @: 19 @:vvar@:(v)}
36034 @r{ v@: I H u S @: @: 19 @:vpvar@:(v)}
36035 @r{ @: u V @: @: @:calc-view-units-table@:}
36036 @r{ v@: u X @: @: 19 @:vmax@:(v)}
36039 @r{ v@: u + @: @: 19 @:vsum@:(v)}
36040 @r{ v@: u * @: @: 19 @:vprod@:(v)}
36041 @r{ v@: u # @: @: 19 @:vcount@:(v)}
36044 @r{ @: V ( @: @: 50 @:calc-vector-parens@:}
36045 @r{ @: V @{ @: @: 50 @:calc-vector-braces@:}
36046 @r{ @: V [ @: @: 50 @:calc-vector-brackets@:}
36047 @r{ @: V ] @:ROCP @: 50 @:calc-matrix-brackets@:}
36048 @r{ @: V , @: @: 50 @:calc-vector-commas@:}
36049 @r{ @: V < @: @: 50 @:calc-matrix-left-justify@:}
36050 @r{ @: V = @: @: 50 @:calc-matrix-center-justify@:}
36051 @r{ @: V > @: @: 50 @:calc-matrix-right-justify@:}
36052 @r{ @: V / @: @: 12,50 @:calc-break-vectors@:}
36053 @r{ @: V . @: @: 12,50 @:calc-full-vectors@:}
36056 @r{ s t@: V ^ @: @: 2 @:vint@:(s,t)}
36057 @r{ s t@: V - @: @: 2 @:vdiff@:(s,t)}
36058 @r{ s@: V ~ @: @: 1 @:vcompl@:(s)}
36059 @r{ s@: V # @: @: 1 @:vcard@:(s)}
36060 @r{ s@: V : @: @: 1 @:vspan@:(s)}
36061 @r{ s@: V + @: @: 1 @:rdup@:(s)}
36064 @r{ m@: V & @: @: 1 @:inv@:(m) 1/m}
36067 @r{ v@: v a @:n @: @:arrange@:(v,n)}
36068 @r{ a@: v b @:n @: @:cvec@:(a,n)}
36069 @r{ v@: v c @:n >0 @: 21,31 @:mcol@:(v,n)}
36070 @r{ v@: v c @:n <0 @: 31 @:mrcol@:(v,-n)}
36071 @r{ m@: v c @:0 @: 31 @:getdiag@:(m)}
36072 @r{ v@: v d @: @: 25 @:diag@:(v,n)}
36073 @r{ v m@: v e @: @: 2 @:vexp@:(v,m)}
36074 @r{ v m f@: H v e @: @: 2 @:vexp@:(v,m,f)}
36075 @r{ v a@: v f @: @: 26 @:find@:(v,a,n)}
36076 @r{ v@: v h @: @: 1 @:head@:(v)}
36077 @r{ v@: I v h @: @: 1 @:tail@:(v)}
36078 @r{ v@: H v h @: @: 1 @:rhead@:(v)}
36079 @r{ v@: I H v h @: @: 1 @:rtail@:(v)}
36080 @r{ @: v i @:n @: 31 @:idn@:(1,n)}
36081 @r{ @: v i @:0 @: 31 @:idn@:(1)}
36082 @r{ h t@: v k @: @: 2 @:cons@:(h,t)}
36083 @r{ h t@: H v k @: @: 2 @:rcons@:(h,t)}
36084 @r{ v@: v l @: @: 1 @:vlen@:(v)}
36085 @r{ v@: H v l @: @: 1 @:mdims@:(v)}
36086 @r{ v m@: v m @: @: 2 @:vmask@:(v,m)}
36087 @r{ v@: v n @: @: 1 @:rnorm@:(v)}
36088 @r{ a b c@: v p @: @: 24 @:calc-pack@:}
36089 @r{ v@: v r @:n >0 @: 21,31 @:mrow@:(v,n)}
36090 @r{ v@: v r @:n <0 @: 31 @:mrrow@:(v,-n)}
36091 @r{ m@: v r @:0 @: 31 @:getdiag@:(m)}
36092 @r{ v i j@: v s @: @: @:subvec@:(v,i,j)}
36093 @r{ v i j@: I v s @: @: @:rsubvec@:(v,i,j)}
36094 @r{ m@: v t @: @: 1 @:trn@:(m)}
36095 @r{ v@: v u @: @: 24 @:calc-unpack@:}
36096 @r{ v@: v v @: @: 1 @:rev@:(v)}
36097 @r{ @: v x @:n @: 31 @:index@:(n)}
36098 @r{ n s i@: C-u v x @: @: @:index@:(n,s,i)}
36101 @r{ v@: V A @:op @: 22 @:apply@:(op,v)}
36102 @r{ v1 v2@: V C @: @: 2 @:cross@:(v1,v2)}
36103 @r{ m@: V D @: @: 1 @:det@:(m)}
36104 @r{ s@: V E @: @: 1 @:venum@:(s)}
36105 @r{ s@: V F @: @: 1 @:vfloor@:(s)}
36106 @r{ v@: V G @: @: @:grade@:(v)}
36107 @r{ v@: I V G @: @: @:rgrade@:(v)}
36108 @r{ v@: V H @:n @: 31 @:histogram@:(v,n)}
36109 @r{ v w@: H V H @:n @: 31 @:histogram@:(v,w,n)}
36110 @r{ v1 v2@: V I @:mop aop @: 22 @:inner@:(mop,aop,v1,v2)}
36111 @r{ m@: V J @: @: 1 @:ctrn@:(m)}
36112 @r{ m1 m2@: V K @: @: @:kron@:(m1,m2)}
36113 @r{ m@: V L @: @: 1 @:lud@:(m)}
36114 @r{ v@: V M @:op @: 22,23 @:map@:(op,v)}
36115 @r{ v@: V N @: @: 1 @:cnorm@:(v)}
36116 @r{ v1 v2@: V O @:op @: 22 @:outer@:(op,v1,v2)}
36117 @r{ v@: V R @:op @: 22,23 @:reduce@:(op,v)}
36118 @r{ v@: I V R @:op @: 22,23 @:rreduce@:(op,v)}
36119 @r{ a n@: H V R @:op @: 22 @:nest@:(op,a,n)}
36120 @r{ a@: I H V R @:op @: 22 @:fixp@:(op,a)}
36121 @r{ v@: V S @: @: @:sort@:(v)}
36122 @r{ v@: I V S @: @: @:rsort@:(v)}
36123 @r{ m@: V T @: @: 1 @:tr@:(m)}
36124 @r{ v@: V U @:op @: 22 @:accum@:(op,v)}
36125 @r{ v@: I V U @:op @: 22 @:raccum@:(op,v)}
36126 @r{ a n@: H V U @:op @: 22 @:anest@:(op,a,n)}
36127 @r{ a@: I H V U @:op @: 22 @:afixp@:(op,a)}
36128 @r{ s t@: V V @: @: 2 @:vunion@:(s,t)}
36129 @r{ s t@: V X @: @: 2 @:vxor@:(s,t)}
36132 @r{ @: Y @: @: @:@:user commands}
36135 @r{ @: z @: @: @:@:user commands}
36138 @r{ c@: Z [ @: @: 45 @:calc-kbd-if@:}
36139 @r{ c@: Z | @: @: 45 @:calc-kbd-else-if@:}
36140 @r{ @: Z : @: @: @:calc-kbd-else@:}
36141 @r{ @: Z ] @: @: @:calc-kbd-end-if@:}
36144 @r{ @: Z @{ @: @: 4 @:calc-kbd-loop@:}
36145 @r{ c@: Z / @: @: 45 @:calc-kbd-break@:}
36146 @r{ @: Z @} @: @: @:calc-kbd-end-loop@:}
36147 @r{ n@: Z < @: @: @:calc-kbd-repeat@:}
36148 @r{ @: Z > @: @: @:calc-kbd-end-repeat@:}
36149 @r{ n m@: Z ( @: @: @:calc-kbd-for@:}
36150 @r{ s@: Z ) @: @: @:calc-kbd-end-for@:}
36153 @r{ @: Z C-g @: @: @:@:cancel if/loop command}
36156 @r{ @: Z ` @: @: @:calc-kbd-push@:}
36157 @r{ @: Z ' @: @: @:calc-kbd-pop@:}
36158 @r{ @: Z # @: @: @:calc-kbd-query@:}
36161 @r{ comp@: Z C @:func, args @: 50 @:calc-user-define-composition@:}
36162 @r{ @: Z D @:key, command @: @:calc-user-define@:}
36163 @r{ @: Z E @:key, editing @: 30 @:calc-user-define-edit@:}
36164 @r{ defn@: Z F @:k, c, f, a, n@: 28 @:calc-user-define-formula@:}
36165 @r{ @: Z G @:key @: @:calc-get-user-defn@:}
36166 @r{ @: Z I @: @: @:calc-user-define-invocation@:}
36167 @r{ @: Z K @:key, command @: @:calc-user-define-kbd-macro@:}
36168 @r{ @: Z P @:key @: @:calc-user-define-permanent@:}
36169 @r{ @: Z S @: @: 30 @:calc-edit-user-syntax@:}
36170 @r{ @: Z T @: @: 12 @:calc-timing@:}
36171 @r{ @: Z U @:key @: @:calc-user-undefine@:}
36181 Positive prefix arguments apply to @expr{n} stack entries.
36182 Negative prefix arguments apply to the @expr{-n}th stack entry.
36183 A prefix of zero applies to the entire stack. (For @key{LFD} and
36184 @kbd{M-@key{DEL}}, the meaning of the sign is reversed.)
36188 Positive prefix arguments apply to @expr{n} stack entries.
36189 Negative prefix arguments apply to the top stack entry
36190 and the next @expr{-n} stack entries.
36194 Positive prefix arguments rotate top @expr{n} stack entries by one.
36195 Negative prefix arguments rotate the entire stack by @expr{-n}.
36196 A prefix of zero reverses the entire stack.
36200 Prefix argument specifies a repeat count or distance.
36204 Positive prefix arguments specify a precision @expr{p}.
36205 Negative prefix arguments reduce the current precision by @expr{-p}.
36209 A prefix argument is interpreted as an additional step-size parameter.
36210 A plain @kbd{C-u} prefix means to prompt for the step size.
36214 A prefix argument specifies simplification level and depth.
36215 1=Default, 2=like @kbd{a s}, 3=like @kbd{a e}.
36219 A negative prefix operates only on the top level of the input formula.
36223 Positive prefix arguments specify a word size of @expr{w} bits, unsigned.
36224 Negative prefix arguments specify a word size of @expr{w} bits, signed.
36228 Prefix arguments specify the shift amount @expr{n}. The @expr{w} argument
36229 cannot be specified in the keyboard version of this command.
36233 From the keyboard, @expr{d} is omitted and defaults to zero.
36237 Mode is toggled; a positive prefix always sets the mode, and a negative
36238 prefix always clears the mode.
36242 Some prefix argument values provide special variations of the mode.
36246 A prefix argument, if any, is used for @expr{m} instead of taking
36247 @expr{m} from the stack. @expr{M} may take any of these values:
36249 {@advance@tableindent10pt
36253 Random integer in the interval @expr{[0 .. m)}.
36255 Random floating-point number in the interval @expr{[0 .. m)}.
36257 Gaussian with mean 1 and standard deviation 0.
36259 Gaussian with specified mean and standard deviation.
36261 Random integer or floating-point number in that interval.
36263 Random element from the vector.
36271 A prefix argument from 1 to 6 specifies number of date components
36272 to remove from the stack. @xref{Date Conversions}.
36276 A prefix argument specifies a time zone; @kbd{C-u} says to take the
36277 time zone number or name from the top of the stack. @xref{Time Zones}.
36281 A prefix argument specifies a day number (0-6, 0-31, or 0-366).
36285 If the input has no units, you will be prompted for both the old and
36290 With a prefix argument, collect that many stack entries to form the
36291 input data set. Each entry may be a single value or a vector of values.
36295 With a prefix argument of 1, take a single
36296 @texline @var{n}@math{\times2}
36297 @infoline @mathit{@var{N}x2}
36298 matrix from the stack instead of two separate data vectors.
36302 The row or column number @expr{n} may be given as a numeric prefix
36303 argument instead. A plain @kbd{C-u} prefix says to take @expr{n}
36304 from the top of the stack. If @expr{n} is a vector or interval,
36305 a subvector/submatrix of the input is created.
36309 The @expr{op} prompt can be answered with the key sequence for the
36310 desired function, or with @kbd{x} or @kbd{z} followed by a function name,
36311 or with @kbd{$} to take a formula from the top of the stack, or with
36312 @kbd{'} and a typed formula. In the last two cases, the formula may
36313 be a nameless function like @samp{<#1+#2>} or @samp{<x, y : x+y>}, or it
36314 may include @kbd{$}, @kbd{$$}, etc. (where @kbd{$} will correspond to the
36315 last argument of the created function), or otherwise you will be
36316 prompted for an argument list. The number of vectors popped from the
36317 stack by @kbd{V M} depends on the number of arguments of the function.
36321 One of the mapping direction keys @kbd{_} (horizontal, i.e., map
36322 by rows or reduce across), @kbd{:} (vertical, i.e., map by columns or
36323 reduce down), or @kbd{=} (map or reduce by rows) may be used before
36324 entering @expr{op}; these modify the function name by adding the letter
36325 @code{r} for ``rows,'' @code{c} for ``columns,'' @code{a} for ``across,''
36326 or @code{d} for ``down.''
36330 The prefix argument specifies a packing mode. A nonnegative mode
36331 is the number of items (for @kbd{v p}) or the number of levels
36332 (for @kbd{v u}). A negative mode is as described below. With no
36333 prefix argument, the mode is taken from the top of the stack and
36334 may be an integer or a vector of integers.
36336 {@advance@tableindent-20pt
36340 (@var{2}) Rectangular complex number.
36342 (@var{2}) Polar complex number.
36344 (@var{3}) HMS form.
36346 (@var{2}) Error form.
36348 (@var{2}) Modulo form.
36350 (@var{2}) Closed interval.
36352 (@var{2}) Closed .. open interval.
36354 (@var{2}) Open .. closed interval.
36356 (@var{2}) Open interval.
36358 (@var{2}) Fraction.
36360 (@var{2}) Float with integer mantissa.
36362 (@var{2}) Float with mantissa in @expr{[1 .. 10)}.
36364 (@var{1}) Date form (using date numbers).
36366 (@var{3}) Date form (using year, month, day).
36368 (@var{6}) Date form (using year, month, day, hour, minute, second).
36376 A prefix argument specifies the size @expr{n} of the matrix. With no
36377 prefix argument, @expr{n} is omitted and the size is inferred from
36382 The prefix argument specifies the starting position @expr{n} (default 1).
36386 Cursor position within stack buffer affects this command.
36390 Arguments are not actually removed from the stack by this command.
36394 Variable name may be a single digit or a full name.
36398 Editing occurs in a separate buffer. Press @kbd{C-c C-c} (or
36399 @key{LFD}, or in some cases @key{RET}) to finish the edit, or kill the
36400 buffer with @kbd{C-x k} to cancel the edit. The @key{LFD} key prevents evaluation
36401 of the result of the edit.
36405 The number prompted for can also be provided as a prefix argument.
36409 Press this key a second time to cancel the prefix.
36413 With a negative prefix, deactivate all formulas. With a positive
36414 prefix, deactivate and then reactivate from scratch.
36418 Default is to scan for nearest formula delimiter symbols. With a
36419 prefix of zero, formula is delimited by mark and point. With a
36420 non-zero prefix, formula is delimited by scanning forward or
36421 backward by that many lines.
36425 Parse the region between point and mark as a vector. A nonzero prefix
36426 parses @var{n} lines before or after point as a vector. A zero prefix
36427 parses the current line as a vector. A @kbd{C-u} prefix parses the
36428 region between point and mark as a single formula.
36432 Parse the rectangle defined by point and mark as a matrix. A positive
36433 prefix @var{n} divides the rectangle into columns of width @var{n}.
36434 A zero or @kbd{C-u} prefix parses each line as one formula. A negative
36435 prefix suppresses special treatment of bracketed portions of a line.
36439 A numeric prefix causes the current language mode to be ignored.
36443 Responding to a prompt with a blank line answers that and all
36444 later prompts by popping additional stack entries.
36448 Answer for @expr{v} may also be of the form @expr{v = v_0} or
36453 With a positive prefix argument, stack contains many @expr{y}'s and one
36454 common @expr{x}. With a zero prefix, stack contains a vector of
36455 @expr{y}s and a common @expr{x}. With a negative prefix, stack
36456 contains many @expr{[x,y]} vectors. (For 3D plots, substitute
36457 @expr{z} for @expr{y} and @expr{x,y} for @expr{x}.)
36461 With any prefix argument, all curves in the graph are deleted.
36465 With a positive prefix, refines an existing plot with more data points.
36466 With a negative prefix, forces recomputation of the plot data.
36470 With any prefix argument, set the default value instead of the
36471 value for this graph.
36475 With a negative prefix argument, set the value for the printer.
36479 Condition is considered ``true'' if it is a nonzero real or complex
36480 number, or a formula whose value is known to be nonzero; it is ``false''
36485 Several formulas separated by commas are pushed as multiple stack
36486 entries. Trailing @kbd{)}, @kbd{]}, @kbd{@}}, @kbd{>}, and @kbd{"}
36487 delimiters may be omitted. The notation @kbd{$$$} refers to the value
36488 in stack level three, and causes the formula to replace the top three
36489 stack levels. The notation @kbd{$3} refers to stack level three without
36490 causing that value to be removed from the stack. Use @key{LFD} in place
36491 of @key{RET} to prevent evaluation; use @kbd{M-=} in place of @key{RET}
36492 to evaluate variables.
36496 The variable is replaced by the formula shown on the right. The
36497 Inverse flag reverses the order of the operands, e.g., @kbd{I s - x}
36499 @texline @math{x \coloneq a-x}.
36500 @infoline @expr{x := a-x}.
36504 Press @kbd{?} repeatedly to see how to choose a model. Answer the
36505 variables prompt with @expr{iv} or @expr{iv;pv} to specify
36506 independent and parameter variables. A positive prefix argument
36507 takes @mathit{@var{n}+1} vectors from the stack; a zero prefix takes a matrix
36508 and a vector from the stack.
36512 With a plain @kbd{C-u} prefix, replace the current region of the
36513 destination buffer with the yanked text instead of inserting.
36517 All stack entries are reformatted; the @kbd{H} prefix inhibits this.
36518 The @kbd{I} prefix sets the mode temporarily, redraws the top stack
36519 entry, then restores the original setting of the mode.
36523 A negative prefix sets the default 3D resolution instead of the
36524 default 2D resolution.
36528 This grabs a vector of the form [@var{prec}, @var{wsize}, @var{ssize},
36529 @var{radix}, @var{flfmt}, @var{ang}, @var{frac}, @var{symb}, @var{polar},
36530 @var{matrix}, @var{simp}, @var{inf}]. A prefix argument from 1 to 12
36531 grabs the @var{n}th mode value only.
36535 (Space is provided below for you to keep your own written notes.)
36543 @node Key Index, Command Index, Summary, Top
36544 @unnumbered Index of Key Sequences
36548 @node Command Index, Function Index, Key Index, Top
36549 @unnumbered Index of Calculator Commands
36551 Since all Calculator commands begin with the prefix @samp{calc-}, the
36552 @kbd{x} key has been provided as a variant of @kbd{M-x} which automatically
36553 types @samp{calc-} for you. Thus, @kbd{x last-args} is short for
36554 @kbd{M-x calc-last-args}.
36558 @node Function Index, Concept Index, Command Index, Top
36559 @unnumbered Index of Algebraic Functions
36561 This is a list of built-in functions and operators usable in algebraic
36562 expressions. Their full Lisp names are derived by adding the prefix
36563 @samp{calcFunc-}, as in @code{calcFunc-sqrt}.
36565 All functions except those noted with ``*'' have corresponding
36566 Calc keystrokes and can also be found in the Calc Summary.
36571 @node Concept Index, Variable Index, Function Index, Top
36572 @unnumbered Concept Index
36576 @node Variable Index, Lisp Function Index, Concept Index, Top
36577 @unnumbered Index of Variables
36579 The variables in this list that do not contain dashes are accessible
36580 as Calc variables. Add a @samp{var-} prefix to get the name of the
36581 corresponding Lisp variable.
36583 The remaining variables are Lisp variables suitable for @code{setq}ing
36584 in your Calc init file or @file{.emacs} file.
36588 @node Lisp Function Index, , Variable Index, Top
36589 @unnumbered Index of Lisp Math Functions
36591 The following functions are meant to be used with @code{defmath}, not
36592 @code{defun} definitions. For names that do not start with @samp{calc-},
36593 the corresponding full Lisp name is derived by adding a prefix of