]> code.delx.au - gnu-emacs/blob - man/calc.texi
* calc.texi, cl.texi, gnus.texi, idlwave.texi, reftex.texi: Replace
[gnu-emacs] / man / calc.texi
1 \input texinfo @c -*-texinfo-*-
2 @comment %**start of header (This is for running Texinfo on a region.)
3 @c smallbook
4 @setfilename ../info/calc
5 @c [title]
6 @settitle GNU Emacs Calc 2.02g Manual
7 @setchapternewpage odd
8 @comment %**end of header (This is for running Texinfo on a region.)
9
10 @c The following macros are used for conditional output for single lines.
11 @c @texline foo
12 @c `foo' will appear only in TeX output
13 @c @infoline foo
14 @c `foo' will appear only in non-TeX output
15
16 @c @expr{expr} will typeset an expression;
17 @c $x$ in TeX, @samp{x} otherwise.
18
19 @iftex
20 @macro texline
21 @end macro
22 @alias infoline=comment
23 @alias expr=math
24 @alias tfn=code
25 @alias mathit=expr
26 @macro cpi{}
27 @math{@pi{}}
28 @end macro
29 @macro cpiover{den}
30 @math{@pi/\den\}
31 @end macro
32 @end iftex
33
34 @ifnottex
35 @alias texline=comment
36 @macro infoline{stuff}
37 \stuff\
38 @end macro
39 @alias expr=samp
40 @alias tfn=t
41 @alias mathit=i
42 @macro cpi{}
43 @expr{pi}
44 @end macro
45 @macro cpiover{den}
46 @expr{pi/\den\}
47 @end macro
48 @end ifnottex
49
50
51 @tex
52 % Suggested by Karl Berry <karl@@freefriends.org>
53 \gdef\!{\mskip-\thinmuskip}
54 @end tex
55
56 @c Fix some other things specifically for this manual.
57 @iftex
58 @finalout
59 @mathcode`@:=`@: @c Make Calc fractions come out right in math mode
60 @tex
61 \gdef\coloneq{\mathrel{\mathord:\mathord=}}
62
63 \gdef\beforedisplay{\vskip-10pt}
64 \gdef\afterdisplay{\vskip-5pt}
65 \gdef\beforedisplayh{\vskip-25pt}
66 \gdef\afterdisplayh{\vskip-10pt}
67 @end tex
68 @newdimen@kyvpos @kyvpos=0pt
69 @newdimen@kyhpos @kyhpos=0pt
70 @newcount@calcclubpenalty @calcclubpenalty=1000
71 @ignore
72 @newcount@calcpageno
73 @newtoks@calcoldeverypar @calcoldeverypar=@everypar
74 @everypar={@calceverypar@the@calcoldeverypar}
75 @ifx@turnoffactive@undefinedzzz@def@turnoffactive{}@fi
76 @ifx@ninett@undefinedzzz@font@ninett=cmtt9@fi
77 @catcode`@\=0 \catcode`\@=11
78 \r@ggedbottomtrue
79 \catcode`\@=0 @catcode`@\=@active
80 @end ignore
81 @end iftex
82
83 @copying
84 This file documents Calc, the GNU Emacs calculator.
85
86 Copyright (C) 1990, 1991, 2001, 2002, 2005 Free Software Foundation, Inc.
87
88 @quotation
89 Permission is granted to copy, distribute and/or modify this document
90 under the terms of the GNU Free Documentation License, Version 1.1 or
91 any later version published by the Free Software Foundation; with the
92 Invariant Sections being just ``GNU GENERAL PUBLIC LICENSE'', with the
93 Front-Cover texts being ``A GNU Manual,'' and with the Back-Cover
94 Texts as in (a) below.
95
96 (a) The FSF's Back-Cover Text is: ``You have freedom to copy and modify
97 this GNU Manual, like GNU software. Copies published by the Free
98 Software Foundation raise funds for GNU development.''
99 @end quotation
100 @end copying
101
102 @dircategory Emacs
103 @direntry
104 * Calc: (calc). Advanced desk calculator and mathematical tool.
105 @end direntry
106
107 @titlepage
108 @sp 6
109 @center @titlefont{Calc Manual}
110 @sp 4
111 @center GNU Emacs Calc Version 2.02g
112 @c [volume]
113 @sp 1
114 @center March 2005
115 @sp 5
116 @center Dave Gillespie
117 @center daveg@@synaptics.com
118 @page
119
120 @vskip 0pt plus 1filll
121 Copyright @copyright{} 1990, 1991, 2001, 2002, 2005
122 Free Software Foundation, Inc.
123 @insertcopying
124 @end titlepage
125
126 @c [begin]
127 @ifinfo
128 @node Top, , (dir), (dir)
129 @chapter The GNU Emacs Calculator
130
131 @noindent
132 @dfn{Calc} is an advanced desk calculator and mathematical tool
133 that runs as part of the GNU Emacs environment.
134
135 This manual is divided into three major parts: ``Getting Started,''
136 the ``Calc Tutorial,'' and the ``Calc Reference.'' The Tutorial
137 introduces all the major aspects of Calculator use in an easy,
138 hands-on way. The remainder of the manual is a complete reference to
139 the features of the Calculator.
140
141 For help in the Emacs Info system (which you are using to read this
142 file), type @kbd{?}. (You can also type @kbd{h} to run through a
143 longer Info tutorial.)
144
145 @end ifinfo
146 @menu
147 * Copying:: How you can copy and share Calc.
148
149 * Getting Started:: General description and overview.
150 * Interactive Tutorial::
151 * Tutorial:: A step-by-step introduction for beginners.
152
153 * Introduction:: Introduction to the Calc reference manual.
154 * Data Types:: Types of objects manipulated by Calc.
155 * Stack and Trail:: Manipulating the stack and trail buffers.
156 * Mode Settings:: Adjusting display format and other modes.
157 * Arithmetic:: Basic arithmetic functions.
158 * Scientific Functions:: Transcendentals and other scientific functions.
159 * Matrix Functions:: Operations on vectors and matrices.
160 * Algebra:: Manipulating expressions algebraically.
161 * Units:: Operations on numbers with units.
162 * Store and Recall:: Storing and recalling variables.
163 * Graphics:: Commands for making graphs of data.
164 * Kill and Yank:: Moving data into and out of Calc.
165 * Embedded Mode:: Working with formulas embedded in a file.
166 * Programming:: Calc as a programmable calculator.
167
168 * Installation:: Installing Calc as a part of GNU Emacs.
169 * Reporting Bugs:: How to report bugs and make suggestions.
170
171 * Summary:: Summary of Calc commands and functions.
172
173 * Key Index:: The standard Calc key sequences.
174 * Command Index:: The interactive Calc commands.
175 * Function Index:: Functions (in algebraic formulas).
176 * Concept Index:: General concepts.
177 * Variable Index:: Variables used by Calc (both user and internal).
178 * Lisp Function Index:: Internal Lisp math functions.
179 @end menu
180
181 @node Copying, Getting Started, Top, Top
182 @unnumbered GNU GENERAL PUBLIC LICENSE
183 @center Version 1, February 1989
184
185 @display
186 Copyright @copyright{} 1989 Free Software Foundation, Inc.
187 675 Mass Ave, Cambridge, MA 02139, USA
188
189 Everyone is permitted to copy and distribute verbatim copies
190 of this license document, but changing it is not allowed.
191 @end display
192
193 @unnumberedsec Preamble
194
195 The license agreements of most software companies try to keep users
196 at the mercy of those companies. By contrast, our General Public
197 License is intended to guarantee your freedom to share and change free
198 software---to make sure the software is free for all its users. The
199 General Public License applies to the Free Software Foundation's
200 software and to any other program whose authors commit to using it.
201 You can use it for your programs, too.
202
203 When we speak of free software, we are referring to freedom, not
204 price. Specifically, the General Public License is designed to make
205 sure that you have the freedom to give away or sell copies of free
206 software, that you receive source code or can get it if you want it,
207 that you can change the software or use pieces of it in new free
208 programs; and that you know you can do these things.
209
210 To protect your rights, we need to make restrictions that forbid
211 anyone to deny you these rights or to ask you to surrender the rights.
212 These restrictions translate to certain responsibilities for you if you
213 distribute copies of the software, or if you modify it.
214
215 For example, if you distribute copies of a such a program, whether
216 gratis or for a fee, you must give the recipients all the rights that
217 you have. You must make sure that they, too, receive or can get the
218 source code. And you must tell them their rights.
219
220 We protect your rights with two steps: (1) copyright the software, and
221 (2) offer you this license which gives you legal permission to copy,
222 distribute and/or modify the software.
223
224 Also, for each author's protection and ours, we want to make certain
225 that everyone understands that there is no warranty for this free
226 software. If the software is modified by someone else and passed on, we
227 want its recipients to know that what they have is not the original, so
228 that any problems introduced by others will not reflect on the original
229 authors' reputations.
230
231 The precise terms and conditions for copying, distribution and
232 modification follow.
233
234 @iftex
235 @unnumberedsec TERMS AND CONDITIONS
236 @end iftex
237 @ifinfo
238 @center TERMS AND CONDITIONS
239 @end ifinfo
240
241 @enumerate
242 @item
243 This License Agreement applies to any program or other work which
244 contains a notice placed by the copyright holder saying it may be
245 distributed under the terms of this General Public License. The
246 ``Program'', below, refers to any such program or work, and a ``work based
247 on the Program'' means either the Program or any work containing the
248 Program or a portion of it, either verbatim or with modifications. Each
249 licensee is addressed as ``you''.
250
251 @item
252 You may copy and distribute verbatim copies of the Program's source
253 code as you receive it, in any medium, provided that you conspicuously and
254 appropriately publish on each copy an appropriate copyright notice and
255 disclaimer of warranty; keep intact all the notices that refer to this
256 General Public License and to the absence of any warranty; and give any
257 other recipients of the Program a copy of this General Public License
258 along with the Program. You may charge a fee for the physical act of
259 transferring a copy.
260
261 @item
262 You may modify your copy or copies of the Program or any portion of
263 it, and copy and distribute such modifications under the terms of Paragraph
264 1 above, provided that you also do the following:
265
266 @itemize @bullet
267 @item
268 cause the modified files to carry prominent notices stating that
269 you changed the files and the date of any change; and
270
271 @item
272 cause the whole of any work that you distribute or publish, that
273 in whole or in part contains the Program or any part thereof, either
274 with or without modifications, to be licensed at no charge to all
275 third parties under the terms of this General Public License (except
276 that you may choose to grant warranty protection to some or all
277 third parties, at your option).
278
279 @item
280 If the modified program normally reads commands interactively when
281 run, you must cause it, when started running for such interactive use
282 in the simplest and most usual way, to print or display an
283 announcement including an appropriate copyright notice and a notice
284 that there is no warranty (or else, saying that you provide a
285 warranty) and that users may redistribute the program under these
286 conditions, and telling the user how to view a copy of this General
287 Public License.
288
289 @item
290 You may charge a fee for the physical act of transferring a
291 copy, and you may at your option offer warranty protection in
292 exchange for a fee.
293 @end itemize
294
295 Mere aggregation of another independent work with the Program (or its
296 derivative) on a volume of a storage or distribution medium does not bring
297 the other work under the scope of these terms.
298
299 @item
300 You may copy and distribute the Program (or a portion or derivative of
301 it, under Paragraph 2) in object code or executable form under the terms of
302 Paragraphs 1 and 2 above provided that you also do one of the following:
303
304 @itemize @bullet
305 @item
306 accompany it with the complete corresponding machine-readable
307 source code, which must be distributed under the terms of
308 Paragraphs 1 and 2 above; or,
309
310 @item
311 accompany it with a written offer, valid for at least three
312 years, to give any third party free (except for a nominal charge
313 for the cost of distribution) a complete machine-readable copy of the
314 corresponding source code, to be distributed under the terms of
315 Paragraphs 1 and 2 above; or,
316
317 @item
318 accompany it with the information you received as to where the
319 corresponding source code may be obtained. (This alternative is
320 allowed only for noncommercial distribution and only if you
321 received the program in object code or executable form alone.)
322 @end itemize
323
324 Source code for a work means the preferred form of the work for making
325 modifications to it. For an executable file, complete source code means
326 all the source code for all modules it contains; but, as a special
327 exception, it need not include source code for modules which are standard
328 libraries that accompany the operating system on which the executable
329 file runs, or for standard header files or definitions files that
330 accompany that operating system.
331
332 @item
333 You may not copy, modify, sublicense, distribute or transfer the
334 Program except as expressly provided under this General Public License.
335 Any attempt otherwise to copy, modify, sublicense, distribute or transfer
336 the Program is void, and will automatically terminate your rights to use
337 the Program under this License. However, parties who have received
338 copies, or rights to use copies, from you under this General Public
339 License will not have their licenses terminated so long as such parties
340 remain in full compliance.
341
342 @item
343 By copying, distributing or modifying the Program (or any work based
344 on the Program) you indicate your acceptance of this license to do so,
345 and all its terms and conditions.
346
347 @item
348 Each time you redistribute the Program (or any work based on the
349 Program), the recipient automatically receives a license from the original
350 licensor to copy, distribute or modify the Program subject to these
351 terms and conditions. You may not impose any further restrictions on the
352 recipients' exercise of the rights granted herein.
353
354 @item
355 The Free Software Foundation may publish revised and/or new versions
356 of the General Public License from time to time. Such new versions will
357 be similar in spirit to the present version, but may differ in detail to
358 address new problems or concerns.
359
360 Each version is given a distinguishing version number. If the Program
361 specifies a version number of the license which applies to it and ``any
362 later version'', you have the option of following the terms and conditions
363 either of that version or of any later version published by the Free
364 Software Foundation. If the Program does not specify a version number of
365 the license, you may choose any version ever published by the Free Software
366 Foundation.
367
368 @item
369 If you wish to incorporate parts of the Program into other free
370 programs whose distribution conditions are different, write to the author
371 to ask for permission. For software which is copyrighted by the Free
372 Software Foundation, write to the Free Software Foundation; we sometimes
373 make exceptions for this. Our decision will be guided by the two goals
374 of preserving the free status of all derivatives of our free software and
375 of promoting the sharing and reuse of software generally.
376
377 @iftex
378 @heading NO WARRANTY
379 @end iftex
380 @ifinfo
381 @center NO WARRANTY
382 @end ifinfo
383
384 @item
385 BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
386 FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
387 OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
388 PROVIDE THE PROGRAM ``AS IS'' WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
389 OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
390 MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
391 TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
392 PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
393 REPAIR OR CORRECTION.
394
395 @item
396 IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL
397 ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
398 REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
399 INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES
400 ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT
401 LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES
402 SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE
403 WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN
404 ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
405 @end enumerate
406
407 @node Getting Started, Tutorial, Copying, Top
408 @chapter Getting Started
409 @noindent
410 This chapter provides a general overview of Calc, the GNU Emacs
411 Calculator: What it is, how to start it and how to exit from it,
412 and what are the various ways that it can be used.
413
414 @menu
415 * What is Calc::
416 * About This Manual::
417 * Notations Used in This Manual::
418 * Using Calc::
419 * Demonstration of Calc::
420 * History and Acknowledgements::
421 @end menu
422
423 @node What is Calc, About This Manual, Getting Started, Getting Started
424 @section What is Calc?
425
426 @noindent
427 @dfn{Calc} is an advanced calculator and mathematical tool that runs as
428 part of the GNU Emacs environment. Very roughly based on the HP-28/48
429 series of calculators, its many features include:
430
431 @itemize @bullet
432 @item
433 Choice of algebraic or RPN (stack-based) entry of calculations.
434
435 @item
436 Arbitrary precision integers and floating-point numbers.
437
438 @item
439 Arithmetic on rational numbers, complex numbers (rectangular and polar),
440 error forms with standard deviations, open and closed intervals, vectors
441 and matrices, dates and times, infinities, sets, quantities with units,
442 and algebraic formulas.
443
444 @item
445 Mathematical operations such as logarithms and trigonometric functions.
446
447 @item
448 Programmer's features (bitwise operations, non-decimal numbers).
449
450 @item
451 Financial functions such as future value and internal rate of return.
452
453 @item
454 Number theoretical features such as prime factorization and arithmetic
455 modulo @var{m} for any @var{m}.
456
457 @item
458 Algebraic manipulation features, including symbolic calculus.
459
460 @item
461 Moving data to and from regular editing buffers.
462
463 @item
464 Embedded mode for manipulating Calc formulas and data directly
465 inside any editing buffer.
466
467 @item
468 Graphics using GNUPLOT, a versatile (and free) plotting program.
469
470 @item
471 Easy programming using keyboard macros, algebraic formulas,
472 algebraic rewrite rules, or extended Emacs Lisp.
473 @end itemize
474
475 Calc tries to include a little something for everyone; as a result it is
476 large and might be intimidating to the first-time user. If you plan to
477 use Calc only as a traditional desk calculator, all you really need to
478 read is the ``Getting Started'' chapter of this manual and possibly the
479 first few sections of the tutorial. As you become more comfortable with
480 the program you can learn its additional features. Calc does not
481 have the scope and depth of a fully-functional symbolic math package,
482 but Calc has the advantages of convenience, portability, and freedom.
483
484 @node About This Manual, Notations Used in This Manual, What is Calc, Getting Started
485 @section About This Manual
486
487 @noindent
488 This document serves as a complete description of the GNU Emacs
489 Calculator. It works both as an introduction for novices, and as
490 a reference for experienced users. While it helps to have some
491 experience with GNU Emacs in order to get the most out of Calc,
492 this manual ought to be readable even if you don't know or use Emacs
493 regularly.
494
495 @ifinfo
496 The manual is divided into three major parts:@: the ``Getting
497 Started'' chapter you are reading now, the Calc tutorial (chapter 2),
498 and the Calc reference manual (the remaining chapters and appendices).
499 @end ifinfo
500 @iftex
501 The manual is divided into three major parts:@: the ``Getting
502 Started'' chapter you are reading now, the Calc tutorial (chapter 2),
503 and the Calc reference manual (the remaining chapters and appendices).
504 @c [when-split]
505 @c This manual has been printed in two volumes, the @dfn{Tutorial} and the
506 @c @dfn{Reference}. Both volumes include a copy of the ``Getting Started''
507 @c chapter.
508 @end iftex
509
510 If you are in a hurry to use Calc, there is a brief ``demonstration''
511 below which illustrates the major features of Calc in just a couple of
512 pages. If you don't have time to go through the full tutorial, this
513 will show you everything you need to know to begin.
514 @xref{Demonstration of Calc}.
515
516 The tutorial chapter walks you through the various parts of Calc
517 with lots of hands-on examples and explanations. If you are new
518 to Calc and you have some time, try going through at least the
519 beginning of the tutorial. The tutorial includes about 70 exercises
520 with answers. These exercises give you some guided practice with
521 Calc, as well as pointing out some interesting and unusual ways
522 to use its features.
523
524 The reference section discusses Calc in complete depth. You can read
525 the reference from start to finish if you want to learn every aspect
526 of Calc. Or, you can look in the table of contents or the Concept
527 Index to find the parts of the manual that discuss the things you
528 need to know.
529
530 @cindex Marginal notes
531 Every Calc keyboard command is listed in the Calc Summary, and also
532 in the Key Index. Algebraic functions, @kbd{M-x} commands, and
533 variables also have their own indices.
534 @texline Each
535 @infoline In the printed manual, each
536 paragraph that is referenced in the Key or Function Index is marked
537 in the margin with its index entry.
538
539 @c [fix-ref Help Commands]
540 You can access this manual on-line at any time within Calc by
541 pressing the @kbd{h i} key sequence. Outside of the Calc window,
542 you can press @kbd{M-# i} to read the manual on-line. Also, you
543 can jump directly to the Tutorial by pressing @kbd{h t} or @kbd{M-# t},
544 or to the Summary by pressing @kbd{h s} or @kbd{M-# s}. Within Calc,
545 you can also go to the part of the manual describing any Calc key,
546 function, or variable using @w{@kbd{h k}}, @kbd{h f}, or @kbd{h v},
547 respectively. @xref{Help Commands}.
548
549 Printed copies of this manual are also available from the Free Software
550 Foundation.
551
552 @node Notations Used in This Manual, Demonstration of Calc, About This Manual, Getting Started
553 @section Notations Used in This Manual
554
555 @noindent
556 This section describes the various notations that are used
557 throughout the Calc manual.
558
559 In keystroke sequences, uppercase letters mean you must hold down
560 the shift key while typing the letter. Keys pressed with Control
561 held down are shown as @kbd{C-x}. Keys pressed with Meta held down
562 are shown as @kbd{M-x}. Other notations are @key{RET} for the
563 Return key, @key{SPC} for the space bar, @key{TAB} for the Tab key,
564 @key{DEL} for the Delete key, and @key{LFD} for the Line-Feed key.
565 The @key{DEL} key is called Backspace on some keyboards, it is
566 whatever key you would use to correct a simple typing error when
567 regularly using Emacs.
568
569 (If you don't have the @key{LFD} or @key{TAB} keys on your keyboard,
570 the @kbd{C-j} and @kbd{C-i} keys are equivalent to them, respectively.
571 If you don't have a Meta key, look for Alt or Extend Char. You can
572 also press @key{ESC} or @key{C-[} first to get the same effect, so
573 that @kbd{M-x}, @kbd{@key{ESC} x}, and @kbd{C-[ x} are all equivalent.)
574
575 Sometimes the @key{RET} key is not shown when it is ``obvious''
576 that you must press @key{RET} to proceed. For example, the @key{RET}
577 is usually omitted in key sequences like @kbd{M-x calc-keypad @key{RET}}.
578
579 Commands are generally shown like this: @kbd{p} (@code{calc-precision})
580 or @kbd{M-# k} (@code{calc-keypad}). This means that the command is
581 normally used by pressing the @kbd{p} key or @kbd{M-# k} key sequence,
582 but it also has the full-name equivalent shown, e.g., @kbd{M-x calc-precision}.
583
584 Commands that correspond to functions in algebraic notation
585 are written: @kbd{C} (@code{calc-cos}) [@code{cos}]. This means
586 the @kbd{C} key is equivalent to @kbd{M-x calc-cos}, and that
587 the corresponding function in an algebraic-style formula would
588 be @samp{cos(@var{x})}.
589
590 A few commands don't have key equivalents: @code{calc-sincos}
591 [@code{sincos}].
592
593 @node Demonstration of Calc, Using Calc, Notations Used in This Manual, Getting Started
594 @section A Demonstration of Calc
595
596 @noindent
597 @cindex Demonstration of Calc
598 This section will show some typical small problems being solved with
599 Calc. The focus is more on demonstration than explanation, but
600 everything you see here will be covered more thoroughly in the
601 Tutorial.
602
603 To begin, start Emacs if necessary (usually the command @code{emacs}
604 does this), and type @kbd{M-# c} (or @kbd{@key{ESC} # c}) to start the
605 Calculator. (@xref{Starting Calc}, if this doesn't work for you.)
606
607 Be sure to type all the sample input exactly, especially noting the
608 difference between lower-case and upper-case letters. Remember,
609 @key{RET}, @key{TAB}, @key{DEL}, and @key{SPC} are the Return, Tab,
610 Delete, and Space keys.
611
612 @strong{RPN calculation.} In RPN, you type the input number(s) first,
613 then the command to operate on the numbers.
614
615 @noindent
616 Type @kbd{2 @key{RET} 3 + Q} to compute
617 @texline @math{\sqrt{2+3} = 2.2360679775}.
618 @infoline the square root of 2+3, which is 2.2360679775.
619
620 @noindent
621 Type @kbd{P 2 ^} to compute
622 @texline @math{\pi^2 = 9.86960440109}.
623 @infoline the value of `pi' squared, 9.86960440109.
624
625 @noindent
626 Type @key{TAB} to exchange the order of these two results.
627
628 @noindent
629 Type @kbd{- I H S} to subtract these results and compute the Inverse
630 Hyperbolic sine of the difference, 2.72996136574.
631
632 @noindent
633 Type @key{DEL} to erase this result.
634
635 @strong{Algebraic calculation.} You can also enter calculations using
636 conventional ``algebraic'' notation. To enter an algebraic formula,
637 use the apostrophe key.
638
639 @noindent
640 Type @kbd{' sqrt(2+3) @key{RET}} to compute
641 @texline @math{\sqrt{2+3}}.
642 @infoline the square root of 2+3.
643
644 @noindent
645 Type @kbd{' pi^2 @key{RET}} to enter
646 @texline @math{\pi^2}.
647 @infoline `pi' squared.
648 To evaluate this symbolic formula as a number, type @kbd{=}.
649
650 @noindent
651 Type @kbd{' arcsinh($ - $$) @key{RET}} to subtract the second-most-recent
652 result from the most-recent and compute the Inverse Hyperbolic sine.
653
654 @strong{Keypad mode.} If you are using the X window system, press
655 @w{@kbd{M-# k}} to get Keypad mode. (If you don't use X, skip to
656 the next section.)
657
658 @noindent
659 Click on the @key{2}, @key{ENTER}, @key{3}, @key{+}, and @key{SQRT}
660 ``buttons'' using your left mouse button.
661
662 @noindent
663 Click on @key{PI}, @key{2}, and @tfn{y^x}.
664
665 @noindent
666 Click on @key{INV}, then @key{ENTER} to swap the two results.
667
668 @noindent
669 Click on @key{-}, @key{INV}, @key{HYP}, and @key{SIN}.
670
671 @noindent
672 Click on @key{<-} to erase the result, then click @key{OFF} to turn
673 the Keypad Calculator off.
674
675 @strong{Grabbing data.} Type @kbd{M-# x} if necessary to exit Calc.
676 Now select the following numbers as an Emacs region: ``Mark'' the
677 front of the list by typing @kbd{C-@key{SPC}} or @kbd{C-@@} there,
678 then move to the other end of the list. (Either get this list from
679 the on-line copy of this manual, accessed by @w{@kbd{M-# i}}, or just
680 type these numbers into a scratch file.) Now type @kbd{M-# g} to
681 ``grab'' these numbers into Calc.
682
683 @example
684 @group
685 1.23 1.97
686 1.6 2
687 1.19 1.08
688 @end group
689 @end example
690
691 @noindent
692 The result @samp{[1.23, 1.97, 1.6, 2, 1.19, 1.08]} is a Calc ``vector.''
693 Type @w{@kbd{V R +}} to compute the sum of these numbers.
694
695 @noindent
696 Type @kbd{U} to Undo this command, then type @kbd{V R *} to compute
697 the product of the numbers.
698
699 @noindent
700 You can also grab data as a rectangular matrix. Place the cursor on
701 the upper-leftmost @samp{1} and set the mark, then move to just after
702 the lower-right @samp{8} and press @kbd{M-# r}.
703
704 @noindent
705 Type @kbd{v t} to transpose this
706 @texline @math{3\times2}
707 @infoline 3x2
708 matrix into a
709 @texline @math{2\times3}
710 @infoline 2x3
711 matrix. Type @w{@kbd{v u}} to unpack the rows into two separate
712 vectors. Now type @w{@kbd{V R + @key{TAB} V R +}} to compute the sums
713 of the two original columns. (There is also a special
714 grab-and-sum-columns command, @kbd{M-# :}.)
715
716 @strong{Units conversion.} Units are entered algebraically.
717 Type @w{@kbd{' 43 mi/hr @key{RET}}} to enter the quantity 43 miles-per-hour.
718 Type @w{@kbd{u c km/hr @key{RET}}}. Type @w{@kbd{u c m/s @key{RET}}}.
719
720 @strong{Date arithmetic.} Type @kbd{t N} to get the current date and
721 time. Type @kbd{90 +} to find the date 90 days from now. Type
722 @kbd{' <25 dec 87> @key{RET}} to enter a date, then @kbd{- 7 /} to see how
723 many weeks have passed since then.
724
725 @strong{Algebra.} Algebraic entries can also include formulas
726 or equations involving variables. Type @kbd{@w{' [x + y} = a, x y = 1] @key{RET}}
727 to enter a pair of equations involving three variables.
728 (Note the leading apostrophe in this example; also, note that the space
729 between @samp{x y} is required.) Type @w{@kbd{a S x,y @key{RET}}} to solve
730 these equations for the variables @expr{x} and @expr{y}.
731
732 @noindent
733 Type @kbd{d B} to view the solutions in more readable notation.
734 Type @w{@kbd{d C}} to view them in C language notation, @kbd{d T}
735 to view them in the notation for the @TeX{} typesetting system,
736 and @kbd{d L} to view them in the notation for the La@TeX{} typesetting
737 system. Type @kbd{d N} to return to normal notation.
738
739 @noindent
740 Type @kbd{7.5}, then @kbd{s l a @key{RET}} to let @expr{a = 7.5} in these formulas.
741 (That's a letter @kbd{l}, not a numeral @kbd{1}.)
742
743 @iftex
744 @strong{Help functions.} You can read about any command in the on-line
745 manual. Type @kbd{M-# c} to return to Calc after each of these
746 commands: @kbd{h k t N} to read about the @kbd{t N} command,
747 @kbd{h f sqrt @key{RET}} to read about the @code{sqrt} function, and
748 @kbd{h s} to read the Calc summary.
749 @end iftex
750 @ifinfo
751 @strong{Help functions.} You can read about any command in the on-line
752 manual. Remember to type the letter @kbd{l}, then @kbd{M-# c}, to
753 return here after each of these commands: @w{@kbd{h k t N}} to read
754 about the @w{@kbd{t N}} command, @kbd{h f sqrt @key{RET}} to read about the
755 @code{sqrt} function, and @kbd{h s} to read the Calc summary.
756 @end ifinfo
757
758 Press @key{DEL} repeatedly to remove any leftover results from the stack.
759 To exit from Calc, press @kbd{q} or @kbd{M-# c} again.
760
761 @node Using Calc, History and Acknowledgements, Demonstration of Calc, Getting Started
762 @section Using Calc
763
764 @noindent
765 Calc has several user interfaces that are specialized for
766 different kinds of tasks. As well as Calc's standard interface,
767 there are Quick mode, Keypad mode, and Embedded mode.
768
769 @menu
770 * Starting Calc::
771 * The Standard Interface::
772 * Quick Mode Overview::
773 * Keypad Mode Overview::
774 * Standalone Operation::
775 * Embedded Mode Overview::
776 * Other M-# Commands::
777 @end menu
778
779 @node Starting Calc, The Standard Interface, Using Calc, Using Calc
780 @subsection Starting Calc
781
782 @noindent
783 On most systems, you can type @kbd{M-#} to start the Calculator.
784 The notation @kbd{M-#} is short for Meta-@kbd{#}. On most
785 keyboards this means holding down the Meta (or Alt) and
786 Shift keys while typing @kbd{3}.
787
788 @cindex META key
789 Once again, if you don't have a Meta key on your keyboard you can type
790 @key{ESC} first, then @kbd{#}, to accomplish the same thing. If you
791 don't even have an @key{ESC} key, you can fake it by holding down
792 Control or @key{CTRL} while typing a left square bracket
793 (that's @kbd{C-[} in Emacs notation).
794
795 @kbd{M-#} is a @dfn{prefix key}; when you press it, Emacs waits for
796 you to press a second key to complete the command. In this case,
797 you will follow @kbd{M-#} with a letter (upper- or lower-case, it
798 doesn't matter for @kbd{M-#}) that says which Calc interface you
799 want to use.
800
801 To get Calc's standard interface, type @kbd{M-# c}. To get
802 Keypad mode, type @kbd{M-# k}. Type @kbd{M-# ?} to get a brief
803 list of the available options, and type a second @kbd{?} to get
804 a complete list.
805
806 To ease typing, @kbd{M-# M-#} (or @kbd{M-# #} if that's easier)
807 also works to start Calc. It starts the same interface (either
808 @kbd{M-# c} or @w{@kbd{M-# k}}) that you last used, selecting the
809 @kbd{M-# c} interface by default. (If your installation has
810 a special function key set up to act like @kbd{M-#}, hitting that
811 function key twice is just like hitting @kbd{M-# M-#}.)
812
813 If @kbd{M-#} doesn't work for you, you can always type explicit
814 commands like @kbd{M-x calc} (for the standard user interface) or
815 @w{@kbd{M-x calc-keypad}} (for Keypad mode). First type @kbd{M-x}
816 (that's Meta with the letter @kbd{x}), then, at the prompt,
817 type the full command (like @kbd{calc-keypad}) and press Return.
818
819 The same commands (like @kbd{M-# c} or @kbd{M-# M-#}) that start
820 the Calculator also turn it off if it is already on.
821
822 @node The Standard Interface, Quick Mode Overview, Starting Calc, Using Calc
823 @subsection The Standard Calc Interface
824
825 @noindent
826 @cindex Standard user interface
827 Calc's standard interface acts like a traditional RPN calculator,
828 operated by the normal Emacs keyboard. When you type @kbd{M-# c}
829 to start the Calculator, the Emacs screen splits into two windows
830 with the file you were editing on top and Calc on the bottom.
831
832 @smallexample
833 @group
834
835 ...
836 --**-Emacs: myfile (Fundamental)----All----------------------
837 --- Emacs Calculator Mode --- |Emacs Calc Mode v2.00...
838 2: 17.3 | 17.3
839 1: -5 | 3
840 . | 2
841 | 4
842 | * 8
843 | ->-5
844 |
845 --%%-Calc: 12 Deg (Calculator)----All----- --%%-Emacs: *Calc Trail*
846 @end group
847 @end smallexample
848
849 In this figure, the mode-line for @file{myfile} has moved up and the
850 ``Calculator'' window has appeared below it. As you can see, Calc
851 actually makes two windows side-by-side. The lefthand one is
852 called the @dfn{stack window} and the righthand one is called the
853 @dfn{trail window.} The stack holds the numbers involved in the
854 calculation you are currently performing. The trail holds a complete
855 record of all calculations you have done. In a desk calculator with
856 a printer, the trail corresponds to the paper tape that records what
857 you do.
858
859 In this case, the trail shows that four numbers (17.3, 3, 2, and 4)
860 were first entered into the Calculator, then the 2 and 4 were
861 multiplied to get 8, then the 3 and 8 were subtracted to get @mathit{-5}.
862 (The @samp{>} symbol shows that this was the most recent calculation.)
863 The net result is the two numbers 17.3 and @mathit{-5} sitting on the stack.
864
865 Most Calculator commands deal explicitly with the stack only, but
866 there is a set of commands that allow you to search back through
867 the trail and retrieve any previous result.
868
869 Calc commands use the digits, letters, and punctuation keys.
870 Shifted (i.e., upper-case) letters are different from lowercase
871 letters. Some letters are @dfn{prefix} keys that begin two-letter
872 commands. For example, @kbd{e} means ``enter exponent'' and shifted
873 @kbd{E} means @expr{e^x}. With the @kbd{d} (``display modes'') prefix
874 the letter ``e'' takes on very different meanings: @kbd{d e} means
875 ``engineering notation'' and @kbd{d E} means ``@dfn{eqn} language mode.''
876
877 There is nothing stopping you from switching out of the Calc
878 window and back into your editing window, say by using the Emacs
879 @w{@kbd{C-x o}} (@code{other-window}) command. When the cursor is
880 inside a regular window, Emacs acts just like normal. When the
881 cursor is in the Calc stack or trail windows, keys are interpreted
882 as Calc commands.
883
884 When you quit by pressing @kbd{M-# c} a second time, the Calculator
885 windows go away but the actual Stack and Trail are not gone, just
886 hidden. When you press @kbd{M-# c} once again you will get the
887 same stack and trail contents you had when you last used the
888 Calculator.
889
890 The Calculator does not remember its state between Emacs sessions.
891 Thus if you quit Emacs and start it again, @kbd{M-# c} will give you
892 a fresh stack and trail. There is a command (@kbd{m m}) that lets
893 you save your favorite mode settings between sessions, though.
894 One of the things it saves is which user interface (standard or
895 Keypad) you last used; otherwise, a freshly started Emacs will
896 always treat @kbd{M-# M-#} the same as @kbd{M-# c}.
897
898 The @kbd{q} key is another equivalent way to turn the Calculator off.
899
900 If you type @kbd{M-# b} first and then @kbd{M-# c}, you get a
901 full-screen version of Calc (@code{full-calc}) in which the stack and
902 trail windows are still side-by-side but are now as tall as the whole
903 Emacs screen. When you press @kbd{q} or @kbd{M-# c} again to quit,
904 the file you were editing before reappears. The @kbd{M-# b} key
905 switches back and forth between ``big'' full-screen mode and the
906 normal partial-screen mode.
907
908 Finally, @kbd{M-# o} (@code{calc-other-window}) is like @kbd{M-# c}
909 except that the Calc window is not selected. The buffer you were
910 editing before remains selected instead. @kbd{M-# o} is a handy
911 way to switch out of Calc momentarily to edit your file; type
912 @kbd{M-# c} to switch back into Calc when you are done.
913
914 @node Quick Mode Overview, Keypad Mode Overview, The Standard Interface, Using Calc
915 @subsection Quick Mode (Overview)
916
917 @noindent
918 @dfn{Quick mode} is a quick way to use Calc when you don't need the
919 full complexity of the stack and trail. To use it, type @kbd{M-# q}
920 (@code{quick-calc}) in any regular editing buffer.
921
922 Quick mode is very simple: It prompts you to type any formula in
923 standard algebraic notation (like @samp{4 - 2/3}) and then displays
924 the result at the bottom of the Emacs screen (@mathit{3.33333333333}
925 in this case). You are then back in the same editing buffer you
926 were in before, ready to continue editing or to type @kbd{M-# q}
927 again to do another quick calculation. The result of the calculation
928 will also be in the Emacs ``kill ring'' so that a @kbd{C-y} command
929 at this point will yank the result into your editing buffer.
930
931 Calc mode settings affect Quick mode, too, though you will have to
932 go into regular Calc (with @kbd{M-# c}) to change the mode settings.
933
934 @c [fix-ref Quick Calculator mode]
935 @xref{Quick Calculator}, for further information.
936
937 @node Keypad Mode Overview, Standalone Operation, Quick Mode Overview, Using Calc
938 @subsection Keypad Mode (Overview)
939
940 @noindent
941 @dfn{Keypad mode} is a mouse-based interface to the Calculator.
942 It is designed for use with terminals that support a mouse. If you
943 don't have a mouse, you will have to operate Keypad mode with your
944 arrow keys (which is probably more trouble than it's worth).
945
946 Type @kbd{M-# k} to turn Keypad mode on or off. Once again you
947 get two new windows, this time on the righthand side of the screen
948 instead of at the bottom. The upper window is the familiar Calc
949 Stack; the lower window is a picture of a typical calculator keypad.
950
951 @tex
952 \dimen0=\pagetotal%
953 \advance \dimen0 by 24\baselineskip%
954 \ifdim \dimen0>\pagegoal \vfill\eject \fi%
955 \medskip
956 @end tex
957 @smallexample
958 |--- Emacs Calculator Mode ---
959 |2: 17.3
960 |1: -5
961 | .
962 |--%%-Calc: 12 Deg (Calcul
963 |----+-----Calc 2.00-----+----1
964 |FLR |CEIL|RND |TRNC|CLN2|FLT |
965 |----+----+----+----+----+----|
966 | LN |EXP | |ABS |IDIV|MOD |
967 |----+----+----+----+----+----|
968 |SIN |COS |TAN |SQRT|y^x |1/x |
969 |----+----+----+----+----+----|
970 | ENTER |+/- |EEX |UNDO| <- |
971 |-----+---+-+--+--+-+---++----|
972 | INV | 7 | 8 | 9 | / |
973 |-----+-----+-----+-----+-----|
974 | HYP | 4 | 5 | 6 | * |
975 |-----+-----+-----+-----+-----|
976 |EXEC | 1 | 2 | 3 | - |
977 |-----+-----+-----+-----+-----|
978 | OFF | 0 | . | PI | + |
979 |-----+-----+-----+-----+-----+
980 @end smallexample
981
982 Keypad mode is much easier for beginners to learn, because there
983 is no need to memorize lots of obscure key sequences. But not all
984 commands in regular Calc are available on the Keypad. You can
985 always switch the cursor into the Calc stack window to use
986 standard Calc commands if you need. Serious Calc users, though,
987 often find they prefer the standard interface over Keypad mode.
988
989 To operate the Calculator, just click on the ``buttons'' of the
990 keypad using your left mouse button. To enter the two numbers
991 shown here you would click @w{@kbd{1 7 .@: 3 ENTER 5 +/- ENTER}}; to
992 add them together you would then click @kbd{+} (to get 12.3 on
993 the stack).
994
995 If you click the right mouse button, the top three rows of the
996 keypad change to show other sets of commands, such as advanced
997 math functions, vector operations, and operations on binary
998 numbers.
999
1000 Because Keypad mode doesn't use the regular keyboard, Calc leaves
1001 the cursor in your original editing buffer. You can type in
1002 this buffer in the usual way while also clicking on the Calculator
1003 keypad. One advantage of Keypad mode is that you don't need an
1004 explicit command to switch between editing and calculating.
1005
1006 If you press @kbd{M-# b} first, you get a full-screen Keypad mode
1007 (@code{full-calc-keypad}) with three windows: The keypad in the lower
1008 left, the stack in the lower right, and the trail on top.
1009
1010 @c [fix-ref Keypad Mode]
1011 @xref{Keypad Mode}, for further information.
1012
1013 @node Standalone Operation, Embedded Mode Overview, Keypad Mode Overview, Using Calc
1014 @subsection Standalone Operation
1015
1016 @noindent
1017 @cindex Standalone Operation
1018 If you are not in Emacs at the moment but you wish to use Calc,
1019 you must start Emacs first. If all you want is to run Calc, you
1020 can give the commands:
1021
1022 @example
1023 emacs -f full-calc
1024 @end example
1025
1026 @noindent
1027 or
1028
1029 @example
1030 emacs -f full-calc-keypad
1031 @end example
1032
1033 @noindent
1034 which run a full-screen Calculator (as if by @kbd{M-# b M-# c}) or
1035 a full-screen X-based Calculator (as if by @kbd{M-# b M-# k}).
1036 In standalone operation, quitting the Calculator (by pressing
1037 @kbd{q} or clicking on the keypad @key{EXIT} button) quits Emacs
1038 itself.
1039
1040 @node Embedded Mode Overview, Other M-# Commands, Standalone Operation, Using Calc
1041 @subsection Embedded Mode (Overview)
1042
1043 @noindent
1044 @dfn{Embedded mode} is a way to use Calc directly from inside an
1045 editing buffer. Suppose you have a formula written as part of a
1046 document like this:
1047
1048 @smallexample
1049 @group
1050 The derivative of
1051
1052 ln(ln(x))
1053
1054 is
1055 @end group
1056 @end smallexample
1057
1058 @noindent
1059 and you wish to have Calc compute and format the derivative for
1060 you and store this derivative in the buffer automatically. To
1061 do this with Embedded mode, first copy the formula down to where
1062 you want the result to be:
1063
1064 @smallexample
1065 @group
1066 The derivative of
1067
1068 ln(ln(x))
1069
1070 is
1071
1072 ln(ln(x))
1073 @end group
1074 @end smallexample
1075
1076 Now, move the cursor onto this new formula and press @kbd{M-# e}.
1077 Calc will read the formula (using the surrounding blank lines to
1078 tell how much text to read), then push this formula (invisibly)
1079 onto the Calc stack. The cursor will stay on the formula in the
1080 editing buffer, but the buffer's mode line will change to look
1081 like the Calc mode line (with mode indicators like @samp{12 Deg}
1082 and so on). Even though you are still in your editing buffer,
1083 the keyboard now acts like the Calc keyboard, and any new result
1084 you get is copied from the stack back into the buffer. To take
1085 the derivative, you would type @kbd{a d x @key{RET}}.
1086
1087 @smallexample
1088 @group
1089 The derivative of
1090
1091 ln(ln(x))
1092
1093 is
1094
1095 1 / ln(x) x
1096 @end group
1097 @end smallexample
1098
1099 To make this look nicer, you might want to press @kbd{d =} to center
1100 the formula, and even @kbd{d B} to use Big display mode.
1101
1102 @smallexample
1103 @group
1104 The derivative of
1105
1106 ln(ln(x))
1107
1108 is
1109 % [calc-mode: justify: center]
1110 % [calc-mode: language: big]
1111
1112 1
1113 -------
1114 ln(x) x
1115 @end group
1116 @end smallexample
1117
1118 Calc has added annotations to the file to help it remember the modes
1119 that were used for this formula. They are formatted like comments
1120 in the @TeX{} typesetting language, just in case you are using @TeX{} or
1121 La@TeX{}. (In this example @TeX{} is not being used, so you might want
1122 to move these comments up to the top of the file or otherwise put them
1123 out of the way.)
1124
1125 As an extra flourish, we can add an equation number using a
1126 righthand label: Type @kbd{d @} (1) @key{RET}}.
1127
1128 @smallexample
1129 @group
1130 % [calc-mode: justify: center]
1131 % [calc-mode: language: big]
1132 % [calc-mode: right-label: " (1)"]
1133
1134 1
1135 ------- (1)
1136 ln(x) x
1137 @end group
1138 @end smallexample
1139
1140 To leave Embedded mode, type @kbd{M-# e} again. The mode line
1141 and keyboard will revert to the way they were before. (If you have
1142 actually been trying this as you read along, you'll want to press
1143 @kbd{M-# 0} [with the digit zero] now to reset the modes you changed.)
1144
1145 The related command @kbd{M-# w} operates on a single word, which
1146 generally means a single number, inside text. It uses any
1147 non-numeric characters rather than blank lines to delimit the
1148 formula it reads. Here's an example of its use:
1149
1150 @smallexample
1151 A slope of one-third corresponds to an angle of 1 degrees.
1152 @end smallexample
1153
1154 Place the cursor on the @samp{1}, then type @kbd{M-# w} to enable
1155 Embedded mode on that number. Now type @kbd{3 /} (to get one-third),
1156 and @kbd{I T} (the Inverse Tangent converts a slope into an angle),
1157 then @w{@kbd{M-# w}} again to exit Embedded mode.
1158
1159 @smallexample
1160 A slope of one-third corresponds to an angle of 18.4349488229 degrees.
1161 @end smallexample
1162
1163 @c [fix-ref Embedded Mode]
1164 @xref{Embedded Mode}, for full details.
1165
1166 @node Other M-# Commands, , Embedded Mode Overview, Using Calc
1167 @subsection Other @kbd{M-#} Commands
1168
1169 @noindent
1170 Two more Calc-related commands are @kbd{M-# g} and @kbd{M-# r},
1171 which ``grab'' data from a selected region of a buffer into the
1172 Calculator. The region is defined in the usual Emacs way, by
1173 a ``mark'' placed at one end of the region, and the Emacs
1174 cursor or ``point'' placed at the other.
1175
1176 The @kbd{M-# g} command reads the region in the usual left-to-right,
1177 top-to-bottom order. The result is packaged into a Calc vector
1178 of numbers and placed on the stack. Calc (in its standard
1179 user interface) is then started. Type @kbd{v u} if you want
1180 to unpack this vector into separate numbers on the stack. Also,
1181 @kbd{C-u M-# g} interprets the region as a single number or
1182 formula.
1183
1184 The @kbd{M-# r} command reads a rectangle, with the point and
1185 mark defining opposite corners of the rectangle. The result
1186 is a matrix of numbers on the Calculator stack.
1187
1188 Complementary to these is @kbd{M-# y}, which ``yanks'' the
1189 value at the top of the Calc stack back into an editing buffer.
1190 If you type @w{@kbd{M-# y}} while in such a buffer, the value is
1191 yanked at the current position. If you type @kbd{M-# y} while
1192 in the Calc buffer, Calc makes an educated guess as to which
1193 editing buffer you want to use. The Calc window does not have
1194 to be visible in order to use this command, as long as there
1195 is something on the Calc stack.
1196
1197 Here, for reference, is the complete list of @kbd{M-#} commands.
1198 The shift, control, and meta keys are ignored for the keystroke
1199 following @kbd{M-#}.
1200
1201 @noindent
1202 Commands for turning Calc on and off:
1203
1204 @table @kbd
1205 @item #
1206 Turn Calc on or off, employing the same user interface as last time.
1207
1208 @item C
1209 Turn Calc on or off using its standard bottom-of-the-screen
1210 interface. If Calc is already turned on but the cursor is not
1211 in the Calc window, move the cursor into the window.
1212
1213 @item O
1214 Same as @kbd{C}, but don't select the new Calc window. If
1215 Calc is already turned on and the cursor is in the Calc window,
1216 move it out of that window.
1217
1218 @item B
1219 Control whether @kbd{M-# c} and @kbd{M-# k} use the full screen.
1220
1221 @item Q
1222 Use Quick mode for a single short calculation.
1223
1224 @item K
1225 Turn Calc Keypad mode on or off.
1226
1227 @item E
1228 Turn Calc Embedded mode on or off at the current formula.
1229
1230 @item J
1231 Turn Calc Embedded mode on or off, select the interesting part.
1232
1233 @item W
1234 Turn Calc Embedded mode on or off at the current word (number).
1235
1236 @item Z
1237 Turn Calc on in a user-defined way, as defined by a @kbd{Z I} command.
1238
1239 @item X
1240 Quit Calc; turn off standard, Keypad, or Embedded mode if on.
1241 (This is like @kbd{q} or @key{OFF} inside of Calc.)
1242 @end table
1243 @iftex
1244 @sp 2
1245 @end iftex
1246
1247 @noindent
1248 Commands for moving data into and out of the Calculator:
1249
1250 @table @kbd
1251 @item G
1252 Grab the region into the Calculator as a vector.
1253
1254 @item R
1255 Grab the rectangular region into the Calculator as a matrix.
1256
1257 @item :
1258 Grab the rectangular region and compute the sums of its columns.
1259
1260 @item _
1261 Grab the rectangular region and compute the sums of its rows.
1262
1263 @item Y
1264 Yank a value from the Calculator into the current editing buffer.
1265 @end table
1266 @iftex
1267 @sp 2
1268 @end iftex
1269
1270 @noindent
1271 Commands for use with Embedded mode:
1272
1273 @table @kbd
1274 @item A
1275 ``Activate'' the current buffer. Locate all formulas that
1276 contain @samp{:=} or @samp{=>} symbols and record their locations
1277 so that they can be updated automatically as variables are changed.
1278
1279 @item D
1280 Duplicate the current formula immediately below and select
1281 the duplicate.
1282
1283 @item F
1284 Insert a new formula at the current point.
1285
1286 @item N
1287 Move the cursor to the next active formula in the buffer.
1288
1289 @item P
1290 Move the cursor to the previous active formula in the buffer.
1291
1292 @item U
1293 Update (i.e., as if by the @kbd{=} key) the formula at the current point.
1294
1295 @item `
1296 Edit (as if by @code{calc-edit}) the formula at the current point.
1297 @end table
1298 @iftex
1299 @sp 2
1300 @end iftex
1301
1302 @noindent
1303 Miscellaneous commands:
1304
1305 @table @kbd
1306 @item I
1307 Run the Emacs Info system to read the Calc manual.
1308 (This is the same as @kbd{h i} inside of Calc.)
1309
1310 @item T
1311 Run the Emacs Info system to read the Calc Tutorial.
1312
1313 @item S
1314 Run the Emacs Info system to read the Calc Summary.
1315
1316 @item L
1317 Load Calc entirely into memory. (Normally the various parts
1318 are loaded only as they are needed.)
1319
1320 @item M
1321 Read a region of written keystroke names (like @kbd{C-n a b c @key{RET}})
1322 and record them as the current keyboard macro.
1323
1324 @item 0
1325 (This is the ``zero'' digit key.) Reset the Calculator to
1326 its default state: Empty stack, and default mode settings.
1327 With any prefix argument, reset everything but the stack.
1328 @end table
1329
1330 @node History and Acknowledgements, , Using Calc, Getting Started
1331 @section History and Acknowledgements
1332
1333 @noindent
1334 Calc was originally started as a two-week project to occupy a lull
1335 in the author's schedule. Basically, a friend asked if I remembered
1336 the value of
1337 @texline @math{2^{32}}.
1338 @infoline @expr{2^32}.
1339 I didn't offhand, but I said, ``that's easy, just call up an
1340 @code{xcalc}.'' @code{Xcalc} duly reported that the answer to our
1341 question was @samp{4.294967e+09}---with no way to see the full ten
1342 digits even though we knew they were there in the program's memory! I
1343 was so annoyed, I vowed to write a calculator of my own, once and for
1344 all.
1345
1346 I chose Emacs Lisp, a) because I had always been curious about it
1347 and b) because, being only a text editor extension language after
1348 all, Emacs Lisp would surely reach its limits long before the project
1349 got too far out of hand.
1350
1351 To make a long story short, Emacs Lisp turned out to be a distressingly
1352 solid implementation of Lisp, and the humble task of calculating
1353 turned out to be more open-ended than one might have expected.
1354
1355 Emacs Lisp doesn't have built-in floating point math, so it had to be
1356 simulated in software. In fact, Emacs integers will only comfortably
1357 fit six decimal digits or so---not enough for a decent calculator. So
1358 I had to write my own high-precision integer code as well, and once I had
1359 this I figured that arbitrary-size integers were just as easy as large
1360 integers. Arbitrary floating-point precision was the logical next step.
1361 Also, since the large integer arithmetic was there anyway it seemed only
1362 fair to give the user direct access to it, which in turn made it practical
1363 to support fractions as well as floats. All these features inspired me
1364 to look around for other data types that might be worth having.
1365
1366 Around this time, my friend Rick Koshi showed me his nifty new HP-28
1367 calculator. It allowed the user to manipulate formulas as well as
1368 numerical quantities, and it could also operate on matrices. I
1369 decided that these would be good for Calc to have, too. And once
1370 things had gone this far, I figured I might as well take a look at
1371 serious algebra systems for further ideas. Since these systems did
1372 far more than I could ever hope to implement, I decided to focus on
1373 rewrite rules and other programming features so that users could
1374 implement what they needed for themselves.
1375
1376 Rick complained that matrices were hard to read, so I put in code to
1377 format them in a 2D style. Once these routines were in place, Big mode
1378 was obligatory. Gee, what other language modes would be useful?
1379
1380 Scott Hemphill and Allen Knutson, two friends with a strong mathematical
1381 bent, contributed ideas and algorithms for a number of Calc features
1382 including modulo forms, primality testing, and float-to-fraction conversion.
1383
1384 Units were added at the eager insistence of Mass Sivilotti. Later,
1385 Ulrich Mueller at CERN and Przemek Klosowski at NIST provided invaluable
1386 expert assistance with the units table. As far as I can remember, the
1387 idea of using algebraic formulas and variables to represent units dates
1388 back to an ancient article in Byte magazine about muMath, an early
1389 algebra system for microcomputers.
1390
1391 Many people have contributed to Calc by reporting bugs and suggesting
1392 features, large and small. A few deserve special mention: Tim Peters,
1393 who helped develop the ideas that led to the selection commands, rewrite
1394 rules, and many other algebra features;
1395 @texline Fran\c cois
1396 @infoline Francois
1397 Pinard, who contributed an early prototype of the Calc Summary appendix
1398 as well as providing valuable suggestions in many other areas of Calc;
1399 Carl Witty, whose eagle eyes discovered many typographical and factual
1400 errors in the Calc manual; Tim Kay, who drove the development of
1401 Embedded mode; Ove Ewerlid, who made many suggestions relating to the
1402 algebra commands and contributed some code for polynomial operations;
1403 Randal Schwartz, who suggested the @code{calc-eval} function; Robert
1404 J. Chassell, who suggested the Calc Tutorial and exercises; and Juha
1405 Sarlin, who first worked out how to split Calc into quickly-loading
1406 parts. Bob Weiner helped immensely with the Lucid Emacs port.
1407
1408 @cindex Bibliography
1409 @cindex Knuth, Art of Computer Programming
1410 @cindex Numerical Recipes
1411 @c Should these be expanded into more complete references?
1412 Among the books used in the development of Calc were Knuth's @emph{Art
1413 of Computer Programming} (especially volume II, @emph{Seminumerical
1414 Algorithms}); @emph{Numerical Recipes} by Press, Flannery, Teukolsky,
1415 and Vetterling; Bevington's @emph{Data Reduction and Error Analysis
1416 for the Physical Sciences}; @emph{Concrete Mathematics} by Graham,
1417 Knuth, and Patashnik; Steele's @emph{Common Lisp, the Language}; the
1418 @emph{CRC Standard Math Tables} (William H. Beyer, ed.); and
1419 Abramowitz and Stegun's venerable @emph{Handbook of Mathematical
1420 Functions}. Also, of course, Calc could not have been written without
1421 the excellent @emph{GNU Emacs Lisp Reference Manual}, by Bil Lewis and
1422 Dan LaLiberte.
1423
1424 Final thanks go to Richard Stallman, without whose fine implementations
1425 of the Emacs editor, language, and environment, Calc would have been
1426 finished in two weeks.
1427
1428 @c [tutorial]
1429
1430 @ifinfo
1431 @c This node is accessed by the `M-# t' command.
1432 @node Interactive Tutorial, , , Top
1433 @chapter Tutorial
1434
1435 @noindent
1436 Some brief instructions on using the Emacs Info system for this tutorial:
1437
1438 Press the space bar and Delete keys to go forward and backward in a
1439 section by screenfuls (or use the regular Emacs scrolling commands
1440 for this).
1441
1442 Press @kbd{n} or @kbd{p} to go to the Next or Previous section.
1443 If the section has a @dfn{menu}, press a digit key like @kbd{1}
1444 or @kbd{2} to go to a sub-section from the menu. Press @kbd{u} to
1445 go back up from a sub-section to the menu it is part of.
1446
1447 Exercises in the tutorial all have cross-references to the
1448 appropriate page of the ``answers'' section. Press @kbd{f}, then
1449 the exercise number, to see the answer to an exercise. After
1450 you have followed a cross-reference, you can press the letter
1451 @kbd{l} to return to where you were before.
1452
1453 You can press @kbd{?} at any time for a brief summary of Info commands.
1454
1455 Press @kbd{1} now to enter the first section of the Tutorial.
1456
1457 @menu
1458 * Tutorial::
1459 @end menu
1460 @end ifinfo
1461
1462 @node Tutorial, Introduction, Getting Started, Top
1463 @chapter Tutorial
1464
1465 @noindent
1466 This chapter explains how to use Calc and its many features, in
1467 a step-by-step, tutorial way. You are encouraged to run Calc and
1468 work along with the examples as you read (@pxref{Starting Calc}).
1469 If you are already familiar with advanced calculators, you may wish
1470 @c [not-split]
1471 to skip on to the rest of this manual.
1472 @c [when-split]
1473 @c to skip on to volume II of this manual, the @dfn{Calc Reference}.
1474
1475 @c [fix-ref Embedded Mode]
1476 This tutorial describes the standard user interface of Calc only.
1477 The Quick mode and Keypad mode interfaces are fairly
1478 self-explanatory. @xref{Embedded Mode}, for a description of
1479 the Embedded mode interface.
1480
1481 @ifinfo
1482 The easiest way to read this tutorial on-line is to have two windows on
1483 your Emacs screen, one with Calc and one with the Info system. (If you
1484 have a printed copy of the manual you can use that instead.) Press
1485 @kbd{M-# c} to turn Calc on or to switch into the Calc window, and
1486 press @kbd{M-# i} to start the Info system or to switch into its window.
1487 Or, you may prefer to use the tutorial in printed form.
1488 @end ifinfo
1489 @iftex
1490 The easiest way to read this tutorial on-line is to have two windows on
1491 your Emacs screen, one with Calc and one with the Info system. (If you
1492 have a printed copy of the manual you can use that instead.) Press
1493 @kbd{M-# c} to turn Calc on or to switch into the Calc window, and
1494 press @kbd{M-# i} to start the Info system or to switch into its window.
1495 @end iftex
1496
1497 This tutorial is designed to be done in sequence. But the rest of this
1498 manual does not assume you have gone through the tutorial. The tutorial
1499 does not cover everything in the Calculator, but it touches on most
1500 general areas.
1501
1502 @ifinfo
1503 You may wish to print out a copy of the Calc Summary and keep notes on
1504 it as you learn Calc. @xref{Installation}, to see how to make a printed
1505 summary. @xref{Summary}.
1506 @end ifinfo
1507 @iftex
1508 The Calc Summary at the end of the reference manual includes some blank
1509 space for your own use. You may wish to keep notes there as you learn
1510 Calc.
1511 @end iftex
1512
1513 @menu
1514 * Basic Tutorial::
1515 * Arithmetic Tutorial::
1516 * Vector/Matrix Tutorial::
1517 * Types Tutorial::
1518 * Algebra Tutorial::
1519 * Programming Tutorial::
1520
1521 * Answers to Exercises::
1522 @end menu
1523
1524 @node Basic Tutorial, Arithmetic Tutorial, Tutorial, Tutorial
1525 @section Basic Tutorial
1526
1527 @noindent
1528 In this section, we learn how RPN and algebraic-style calculations
1529 work, how to undo and redo an operation done by mistake, and how
1530 to control various modes of the Calculator.
1531
1532 @menu
1533 * RPN Tutorial:: Basic operations with the stack.
1534 * Algebraic Tutorial:: Algebraic entry; variables.
1535 * Undo Tutorial:: If you make a mistake: Undo and the trail.
1536 * Modes Tutorial:: Common mode-setting commands.
1537 @end menu
1538
1539 @node RPN Tutorial, Algebraic Tutorial, Basic Tutorial, Basic Tutorial
1540 @subsection RPN Calculations and the Stack
1541
1542 @cindex RPN notation
1543 @ifinfo
1544 @noindent
1545 Calc normally uses RPN notation. You may be familiar with the RPN
1546 system from Hewlett-Packard calculators, FORTH, or PostScript.
1547 (Reverse Polish Notation, RPN, is named after the Polish mathematician
1548 Jan Lukasiewicz.)
1549 @end ifinfo
1550 @tex
1551 \noindent
1552 Calc normally uses RPN notation. You may be familiar with the RPN
1553 system from Hewlett-Packard calculators, FORTH, or PostScript.
1554 (Reverse Polish Notation, RPN, is named after the Polish mathematician
1555 Jan \L ukasiewicz.)
1556 @end tex
1557
1558 The central component of an RPN calculator is the @dfn{stack}. A
1559 calculator stack is like a stack of dishes. New dishes (numbers) are
1560 added at the top of the stack, and numbers are normally only removed
1561 from the top of the stack.
1562
1563 @cindex Operators
1564 @cindex Operands
1565 In an operation like @expr{2+3}, the 2 and 3 are called the @dfn{operands}
1566 and the @expr{+} is the @dfn{operator}. In an RPN calculator you always
1567 enter the operands first, then the operator. Each time you type a
1568 number, Calc adds or @dfn{pushes} it onto the top of the Stack.
1569 When you press an operator key like @kbd{+}, Calc @dfn{pops} the appropriate
1570 number of operands from the stack and pushes back the result.
1571
1572 Thus we could add the numbers 2 and 3 in an RPN calculator by typing:
1573 @kbd{2 @key{RET} 3 @key{RET} +}. (The @key{RET} key, Return, corresponds to
1574 the @key{ENTER} key on traditional RPN calculators.) Try this now if
1575 you wish; type @kbd{M-# c} to switch into the Calc window (you can type
1576 @kbd{M-# c} again or @kbd{M-# o} to switch back to the Tutorial window).
1577 The first four keystrokes ``push'' the numbers 2 and 3 onto the stack.
1578 The @kbd{+} key ``pops'' the top two numbers from the stack, adds them,
1579 and pushes the result (5) back onto the stack. Here's how the stack
1580 will look at various points throughout the calculation:
1581
1582 @smallexample
1583 @group
1584 . 1: 2 2: 2 1: 5 .
1585 . 1: 3 .
1586 .
1587
1588 M-# c 2 @key{RET} 3 @key{RET} + @key{DEL}
1589 @end group
1590 @end smallexample
1591
1592 The @samp{.} symbol is a marker that represents the top of the stack.
1593 Note that the ``top'' of the stack is really shown at the bottom of
1594 the Stack window. This may seem backwards, but it turns out to be
1595 less distracting in regular use.
1596
1597 @cindex Stack levels
1598 @cindex Levels of stack
1599 The numbers @samp{1:} and @samp{2:} on the left are @dfn{stack level
1600 numbers}. Old RPN calculators always had four stack levels called
1601 @expr{x}, @expr{y}, @expr{z}, and @expr{t}. Calc's stack can grow
1602 as large as you like, so it uses numbers instead of letters. Some
1603 stack-manipulation commands accept a numeric argument that says
1604 which stack level to work on. Normal commands like @kbd{+} always
1605 work on the top few levels of the stack.
1606
1607 @c [fix-ref Truncating the Stack]
1608 The Stack buffer is just an Emacs buffer, and you can move around in
1609 it using the regular Emacs motion commands. But no matter where the
1610 cursor is, even if you have scrolled the @samp{.} marker out of
1611 view, most Calc commands always move the cursor back down to level 1
1612 before doing anything. It is possible to move the @samp{.} marker
1613 upwards through the stack, temporarily ``hiding'' some numbers from
1614 commands like @kbd{+}. This is called @dfn{stack truncation} and
1615 we will not cover it in this tutorial; @pxref{Truncating the Stack},
1616 if you are interested.
1617
1618 You don't really need the second @key{RET} in @kbd{2 @key{RET} 3
1619 @key{RET} +}. That's because if you type any operator name or
1620 other non-numeric key when you are entering a number, the Calculator
1621 automatically enters that number and then does the requested command.
1622 Thus @kbd{2 @key{RET} 3 +} will work just as well.
1623
1624 Examples in this tutorial will often omit @key{RET} even when the
1625 stack displays shown would only happen if you did press @key{RET}:
1626
1627 @smallexample
1628 @group
1629 1: 2 2: 2 1: 5
1630 . 1: 3 .
1631 .
1632
1633 2 @key{RET} 3 +
1634 @end group
1635 @end smallexample
1636
1637 @noindent
1638 Here, after pressing @kbd{3} the stack would really show @samp{1: 2}
1639 with @samp{Calc:@: 3} in the minibuffer. In these situations, you can
1640 press the optional @key{RET} to see the stack as the figure shows.
1641
1642 (@bullet{}) @strong{Exercise 1.} (This tutorial will include exercises
1643 at various points. Try them if you wish. Answers to all the exercises
1644 are located at the end of the Tutorial chapter. Each exercise will
1645 include a cross-reference to its particular answer. If you are
1646 reading with the Emacs Info system, press @kbd{f} and the
1647 exercise number to go to the answer, then the letter @kbd{l} to
1648 return to where you were.)
1649
1650 @noindent
1651 Here's the first exercise: What will the keystrokes @kbd{1 @key{RET} 2
1652 @key{RET} 3 @key{RET} 4 + * -} compute? (@samp{*} is the symbol for
1653 multiplication.) Figure it out by hand, then try it with Calc to see
1654 if you're right. @xref{RPN Answer 1, 1}. (@bullet{})
1655
1656 (@bullet{}) @strong{Exercise 2.} Compute
1657 @texline @math{(2\times4) + (7\times9.4) + {5\over4}}
1658 @infoline @expr{2*4 + 7*9.5 + 5/4}
1659 using the stack. @xref{RPN Answer 2, 2}. (@bullet{})
1660
1661 The @key{DEL} key is called Backspace on some keyboards. It is
1662 whatever key you would use to correct a simple typing error when
1663 regularly using Emacs. The @key{DEL} key pops and throws away the
1664 top value on the stack. (You can still get that value back from
1665 the Trail if you should need it later on.) There are many places
1666 in this tutorial where we assume you have used @key{DEL} to erase the
1667 results of the previous example at the beginning of a new example.
1668 In the few places where it is really important to use @key{DEL} to
1669 clear away old results, the text will remind you to do so.
1670
1671 (It won't hurt to let things accumulate on the stack, except that
1672 whenever you give a display-mode-changing command Calc will have to
1673 spend a long time reformatting such a large stack.)
1674
1675 Since the @kbd{-} key is also an operator (it subtracts the top two
1676 stack elements), how does one enter a negative number? Calc uses
1677 the @kbd{_} (underscore) key to act like the minus sign in a number.
1678 So, typing @kbd{-5 @key{RET}} won't work because the @kbd{-} key
1679 will try to do a subtraction, but @kbd{_5 @key{RET}} works just fine.
1680
1681 You can also press @kbd{n}, which means ``change sign.'' It changes
1682 the number at the top of the stack (or the number being entered)
1683 from positive to negative or vice-versa: @kbd{5 n @key{RET}}.
1684
1685 @cindex Duplicating a stack entry
1686 If you press @key{RET} when you're not entering a number, the effect
1687 is to duplicate the top number on the stack. Consider this calculation:
1688
1689 @smallexample
1690 @group
1691 1: 3 2: 3 1: 9 2: 9 1: 81
1692 . 1: 3 . 1: 9 .
1693 . .
1694
1695 3 @key{RET} @key{RET} * @key{RET} *
1696 @end group
1697 @end smallexample
1698
1699 @noindent
1700 (Of course, an easier way to do this would be @kbd{3 @key{RET} 4 ^},
1701 to raise 3 to the fourth power.)
1702
1703 The space-bar key (denoted @key{SPC} here) performs the same function
1704 as @key{RET}; you could replace all three occurrences of @key{RET} in
1705 the above example with @key{SPC} and the effect would be the same.
1706
1707 @cindex Exchanging stack entries
1708 Another stack manipulation key is @key{TAB}. This exchanges the top
1709 two stack entries. Suppose you have computed @kbd{2 @key{RET} 3 +}
1710 to get 5, and then you realize what you really wanted to compute
1711 was @expr{20 / (2+3)}.
1712
1713 @smallexample
1714 @group
1715 1: 5 2: 5 2: 20 1: 4
1716 . 1: 20 1: 5 .
1717 . .
1718
1719 2 @key{RET} 3 + 20 @key{TAB} /
1720 @end group
1721 @end smallexample
1722
1723 @noindent
1724 Planning ahead, the calculation would have gone like this:
1725
1726 @smallexample
1727 @group
1728 1: 20 2: 20 3: 20 2: 20 1: 4
1729 . 1: 2 2: 2 1: 5 .
1730 . 1: 3 .
1731 .
1732
1733 20 @key{RET} 2 @key{RET} 3 + /
1734 @end group
1735 @end smallexample
1736
1737 A related stack command is @kbd{M-@key{TAB}} (hold @key{META} and type
1738 @key{TAB}). It rotates the top three elements of the stack upward,
1739 bringing the object in level 3 to the top.
1740
1741 @smallexample
1742 @group
1743 1: 10 2: 10 3: 10 3: 20 3: 30
1744 . 1: 20 2: 20 2: 30 2: 10
1745 . 1: 30 1: 10 1: 20
1746 . . .
1747
1748 10 @key{RET} 20 @key{RET} 30 @key{RET} M-@key{TAB} M-@key{TAB}
1749 @end group
1750 @end smallexample
1751
1752 (@bullet{}) @strong{Exercise 3.} Suppose the numbers 10, 20, and 30 are
1753 on the stack. Figure out how to add one to the number in level 2
1754 without affecting the rest of the stack. Also figure out how to add
1755 one to the number in level 3. @xref{RPN Answer 3, 3}. (@bullet{})
1756
1757 Operations like @kbd{+}, @kbd{-}, @kbd{*}, @kbd{/}, and @kbd{^} pop two
1758 arguments from the stack and push a result. Operations like @kbd{n} and
1759 @kbd{Q} (square root) pop a single number and push the result. You can
1760 think of them as simply operating on the top element of the stack.
1761
1762 @smallexample
1763 @group
1764 1: 3 1: 9 2: 9 1: 25 1: 5
1765 . . 1: 16 . .
1766 .
1767
1768 3 @key{RET} @key{RET} * 4 @key{RET} @key{RET} * + Q
1769 @end group
1770 @end smallexample
1771
1772 @noindent
1773 (Note that capital @kbd{Q} means to hold down the Shift key while
1774 typing @kbd{q}. Remember, plain unshifted @kbd{q} is the Quit command.)
1775
1776 @cindex Pythagorean Theorem
1777 Here we've used the Pythagorean Theorem to determine the hypotenuse of a
1778 right triangle. Calc actually has a built-in command for that called
1779 @kbd{f h}, but let's suppose we can't remember the necessary keystrokes.
1780 We can still enter it by its full name using @kbd{M-x} notation:
1781
1782 @smallexample
1783 @group
1784 1: 3 2: 3 1: 5
1785 . 1: 4 .
1786 .
1787
1788 3 @key{RET} 4 @key{RET} M-x calc-hypot
1789 @end group
1790 @end smallexample
1791
1792 All Calculator commands begin with the word @samp{calc-}. Since it
1793 gets tiring to type this, Calc provides an @kbd{x} key which is just
1794 like the regular Emacs @kbd{M-x} key except that it types the @samp{calc-}
1795 prefix for you:
1796
1797 @smallexample
1798 @group
1799 1: 3 2: 3 1: 5
1800 . 1: 4 .
1801 .
1802
1803 3 @key{RET} 4 @key{RET} x hypot
1804 @end group
1805 @end smallexample
1806
1807 What happens if you take the square root of a negative number?
1808
1809 @smallexample
1810 @group
1811 1: 4 1: -4 1: (0, 2)
1812 . . .
1813
1814 4 @key{RET} n Q
1815 @end group
1816 @end smallexample
1817
1818 @noindent
1819 The notation @expr{(a, b)} represents a complex number.
1820 Complex numbers are more traditionally written @expr{a + b i};
1821 Calc can display in this format, too, but for now we'll stick to the
1822 @expr{(a, b)} notation.
1823
1824 If you don't know how complex numbers work, you can safely ignore this
1825 feature. Complex numbers only arise from operations that would be
1826 errors in a calculator that didn't have complex numbers. (For example,
1827 taking the square root or logarithm of a negative number produces a
1828 complex result.)
1829
1830 Complex numbers are entered in the notation shown. The @kbd{(} and
1831 @kbd{,} and @kbd{)} keys manipulate ``incomplete complex numbers.''
1832
1833 @smallexample
1834 @group
1835 1: ( ... 2: ( ... 1: (2, ... 1: (2, ... 1: (2, 3)
1836 . 1: 2 . 3 .
1837 . .
1838
1839 ( 2 , 3 )
1840 @end group
1841 @end smallexample
1842
1843 You can perform calculations while entering parts of incomplete objects.
1844 However, an incomplete object cannot actually participate in a calculation:
1845
1846 @smallexample
1847 @group
1848 1: ( ... 2: ( ... 3: ( ... 1: ( ... 1: ( ...
1849 . 1: 2 2: 2 5 5
1850 . 1: 3 . .
1851 .
1852 (error)
1853 ( 2 @key{RET} 3 + +
1854 @end group
1855 @end smallexample
1856
1857 @noindent
1858 Adding 5 to an incomplete object makes no sense, so the last command
1859 produces an error message and leaves the stack the same.
1860
1861 Incomplete objects can't participate in arithmetic, but they can be
1862 moved around by the regular stack commands.
1863
1864 @smallexample
1865 @group
1866 2: 2 3: 2 3: 3 1: ( ... 1: (2, 3)
1867 1: 3 2: 3 2: ( ... 2 .
1868 . 1: ( ... 1: 2 3
1869 . . .
1870
1871 2 @key{RET} 3 @key{RET} ( M-@key{TAB} M-@key{TAB} )
1872 @end group
1873 @end smallexample
1874
1875 @noindent
1876 Note that the @kbd{,} (comma) key did not have to be used here.
1877 When you press @kbd{)} all the stack entries between the incomplete
1878 entry and the top are collected, so there's never really a reason
1879 to use the comma. It's up to you.
1880
1881 (@bullet{}) @strong{Exercise 4.} To enter the complex number @expr{(2, 3)},
1882 your friend Joe typed @kbd{( 2 , @key{SPC} 3 )}. What happened?
1883 (Joe thought of a clever way to correct his mistake in only two
1884 keystrokes, but it didn't quite work. Try it to find out why.)
1885 @xref{RPN Answer 4, 4}. (@bullet{})
1886
1887 Vectors are entered the same way as complex numbers, but with square
1888 brackets in place of parentheses. We'll meet vectors again later in
1889 the tutorial.
1890
1891 Any Emacs command can be given a @dfn{numeric prefix argument} by
1892 typing a series of @key{META}-digits beforehand. If @key{META} is
1893 awkward for you, you can instead type @kbd{C-u} followed by the
1894 necessary digits. Numeric prefix arguments can be negative, as in
1895 @kbd{M-- M-3 M-5} or @w{@kbd{C-u - 3 5}}. Calc commands use numeric
1896 prefix arguments in a variety of ways. For example, a numeric prefix
1897 on the @kbd{+} operator adds any number of stack entries at once:
1898
1899 @smallexample
1900 @group
1901 1: 10 2: 10 3: 10 3: 10 1: 60
1902 . 1: 20 2: 20 2: 20 .
1903 . 1: 30 1: 30
1904 . .
1905
1906 10 @key{RET} 20 @key{RET} 30 @key{RET} C-u 3 +
1907 @end group
1908 @end smallexample
1909
1910 For stack manipulation commands like @key{RET}, a positive numeric
1911 prefix argument operates on the top @var{n} stack entries at once. A
1912 negative argument operates on the entry in level @var{n} only. An
1913 argument of zero operates on the entire stack. In this example, we copy
1914 the second-to-top element of the stack:
1915
1916 @smallexample
1917 @group
1918 1: 10 2: 10 3: 10 3: 10 4: 10
1919 . 1: 20 2: 20 2: 20 3: 20
1920 . 1: 30 1: 30 2: 30
1921 . . 1: 20
1922 .
1923
1924 10 @key{RET} 20 @key{RET} 30 @key{RET} C-u -2 @key{RET}
1925 @end group
1926 @end smallexample
1927
1928 @cindex Clearing the stack
1929 @cindex Emptying the stack
1930 Another common idiom is @kbd{M-0 @key{DEL}}, which clears the stack.
1931 (The @kbd{M-0} numeric prefix tells @key{DEL} to operate on the
1932 entire stack.)
1933
1934 @node Algebraic Tutorial, Undo Tutorial, RPN Tutorial, Basic Tutorial
1935 @subsection Algebraic-Style Calculations
1936
1937 @noindent
1938 If you are not used to RPN notation, you may prefer to operate the
1939 Calculator in Algebraic mode, which is closer to the way
1940 non-RPN calculators work. In Algebraic mode, you enter formulas
1941 in traditional @expr{2+3} notation.
1942
1943 You don't really need any special ``mode'' to enter algebraic formulas.
1944 You can enter a formula at any time by pressing the apostrophe (@kbd{'})
1945 key. Answer the prompt with the desired formula, then press @key{RET}.
1946 The formula is evaluated and the result is pushed onto the RPN stack.
1947 If you don't want to think in RPN at all, you can enter your whole
1948 computation as a formula, read the result from the stack, then press
1949 @key{DEL} to delete it from the stack.
1950
1951 Try pressing the apostrophe key, then @kbd{2+3+4}, then @key{RET}.
1952 The result should be the number 9.
1953
1954 Algebraic formulas use the operators @samp{+}, @samp{-}, @samp{*},
1955 @samp{/}, and @samp{^}. You can use parentheses to make the order
1956 of evaluation clear. In the absence of parentheses, @samp{^} is
1957 evaluated first, then @samp{*}, then @samp{/}, then finally
1958 @samp{+} and @samp{-}. For example, the expression
1959
1960 @example
1961 2 + 3*4*5 / 6*7^8 - 9
1962 @end example
1963
1964 @noindent
1965 is equivalent to
1966
1967 @example
1968 2 + ((3*4*5) / (6*(7^8)) - 9
1969 @end example
1970
1971 @noindent
1972 or, in large mathematical notation,
1973
1974 @ifinfo
1975 @example
1976 @group
1977 3 * 4 * 5
1978 2 + --------- - 9
1979 8
1980 6 * 7
1981 @end group
1982 @end example
1983 @end ifinfo
1984 @tex
1985 \turnoffactive
1986 \beforedisplay
1987 $$ 2 + { 3 \times 4 \times 5 \over 6 \times 7^8 } - 9 $$
1988 \afterdisplay
1989 @end tex
1990
1991 @noindent
1992 The result of this expression will be the number @mathit{-6.99999826533}.
1993
1994 Calc's order of evaluation is the same as for most computer languages,
1995 except that @samp{*} binds more strongly than @samp{/}, as the above
1996 example shows. As in normal mathematical notation, the @samp{*} symbol
1997 can often be omitted: @samp{2 a} is the same as @samp{2*a}.
1998
1999 Operators at the same level are evaluated from left to right, except
2000 that @samp{^} is evaluated from right to left. Thus, @samp{2-3-4} is
2001 equivalent to @samp{(2-3)-4} or @mathit{-5}, whereas @samp{2^3^4} is equivalent
2002 to @samp{2^(3^4)} (a very large integer; try it!).
2003
2004 If you tire of typing the apostrophe all the time, there is
2005 Algebraic mode, where Calc automatically senses
2006 when you are about to type an algebraic expression. To enter this
2007 mode, press the two letters @w{@kbd{m a}}. (An @samp{Alg} indicator
2008 should appear in the Calc window's mode line.)
2009
2010 Press @kbd{m a}, then @kbd{2+3+4} with no apostrophe, then @key{RET}.
2011
2012 In Algebraic mode, when you press any key that would normally begin
2013 entering a number (such as a digit, a decimal point, or the @kbd{_}
2014 key), or if you press @kbd{(} or @kbd{[}, Calc automatically begins
2015 an algebraic entry.
2016
2017 Functions which do not have operator symbols like @samp{+} and @samp{*}
2018 must be entered in formulas using function-call notation. For example,
2019 the function name corresponding to the square-root key @kbd{Q} is
2020 @code{sqrt}. To compute a square root in a formula, you would use
2021 the notation @samp{sqrt(@var{x})}.
2022
2023 Press the apostrophe, then type @kbd{sqrt(5*2) - 3}. The result should
2024 be @expr{0.16227766017}.
2025
2026 Note that if the formula begins with a function name, you need to use
2027 the apostrophe even if you are in Algebraic mode. If you type @kbd{arcsin}
2028 out of the blue, the @kbd{a r} will be taken as an Algebraic Rewrite
2029 command, and the @kbd{csin} will be taken as the name of the rewrite
2030 rule to use!
2031
2032 Some people prefer to enter complex numbers and vectors in algebraic
2033 form because they find RPN entry with incomplete objects to be too
2034 distracting, even though they otherwise use Calc as an RPN calculator.
2035
2036 Still in Algebraic mode, type:
2037
2038 @smallexample
2039 @group
2040 1: (2, 3) 2: (2, 3) 1: (8, -1) 2: (8, -1) 1: (9, -1)
2041 . 1: (1, -2) . 1: 1 .
2042 . .
2043
2044 (2,3) @key{RET} (1,-2) @key{RET} * 1 @key{RET} +
2045 @end group
2046 @end smallexample
2047
2048 Algebraic mode allows us to enter complex numbers without pressing
2049 an apostrophe first, but it also means we need to press @key{RET}
2050 after every entry, even for a simple number like @expr{1}.
2051
2052 (You can type @kbd{C-u m a} to enable a special Incomplete Algebraic
2053 mode in which the @kbd{(} and @kbd{[} keys use algebraic entry even
2054 though regular numeric keys still use RPN numeric entry. There is also
2055 Total Algebraic mode, started by typing @kbd{m t}, in which all
2056 normal keys begin algebraic entry. You must then use the @key{META} key
2057 to type Calc commands: @kbd{M-m t} to get back out of Total Algebraic
2058 mode, @kbd{M-q} to quit, etc.)
2059
2060 If you're still in Algebraic mode, press @kbd{m a} again to turn it off.
2061
2062 Actual non-RPN calculators use a mixture of algebraic and RPN styles.
2063 In general, operators of two numbers (like @kbd{+} and @kbd{*})
2064 use algebraic form, but operators of one number (like @kbd{n} and @kbd{Q})
2065 use RPN form. Also, a non-RPN calculator allows you to see the
2066 intermediate results of a calculation as you go along. You can
2067 accomplish this in Calc by performing your calculation as a series
2068 of algebraic entries, using the @kbd{$} sign to tie them together.
2069 In an algebraic formula, @kbd{$} represents the number on the top
2070 of the stack. Here, we perform the calculation
2071 @texline @math{\sqrt{2\times4+1}},
2072 @infoline @expr{sqrt(2*4+1)},
2073 which on a traditional calculator would be done by pressing
2074 @kbd{2 * 4 + 1 =} and then the square-root key.
2075
2076 @smallexample
2077 @group
2078 1: 8 1: 9 1: 3
2079 . . .
2080
2081 ' 2*4 @key{RET} $+1 @key{RET} Q
2082 @end group
2083 @end smallexample
2084
2085 @noindent
2086 Notice that we didn't need to press an apostrophe for the @kbd{$+1},
2087 because the dollar sign always begins an algebraic entry.
2088
2089 (@bullet{}) @strong{Exercise 1.} How could you get the same effect as
2090 pressing @kbd{Q} but using an algebraic entry instead? How about
2091 if the @kbd{Q} key on your keyboard were broken?
2092 @xref{Algebraic Answer 1, 1}. (@bullet{})
2093
2094 The notations @kbd{$$}, @kbd{$$$}, and so on stand for higher stack
2095 entries. For example, @kbd{' $$+$ @key{RET}} is just like typing @kbd{+}.
2096
2097 Algebraic formulas can include @dfn{variables}. To store in a
2098 variable, press @kbd{s s}, then type the variable name, then press
2099 @key{RET}. (There are actually two flavors of store command:
2100 @kbd{s s} stores a number in a variable but also leaves the number
2101 on the stack, while @w{@kbd{s t}} removes a number from the stack and
2102 stores it in the variable.) A variable name should consist of one
2103 or more letters or digits, beginning with a letter.
2104
2105 @smallexample
2106 @group
2107 1: 17 . 1: a + a^2 1: 306
2108 . . .
2109
2110 17 s t a @key{RET} ' a+a^2 @key{RET} =
2111 @end group
2112 @end smallexample
2113
2114 @noindent
2115 The @kbd{=} key @dfn{evaluates} a formula by replacing all its
2116 variables by the values that were stored in them.
2117
2118 For RPN calculations, you can recall a variable's value on the
2119 stack either by entering its name as a formula and pressing @kbd{=},
2120 or by using the @kbd{s r} command.
2121
2122 @smallexample
2123 @group
2124 1: 17 2: 17 3: 17 2: 17 1: 306
2125 . 1: 17 2: 17 1: 289 .
2126 . 1: 2 .
2127 .
2128
2129 s r a @key{RET} ' a @key{RET} = 2 ^ +
2130 @end group
2131 @end smallexample
2132
2133 If you press a single digit for a variable name (as in @kbd{s t 3}, you
2134 get one of ten @dfn{quick variables} @code{q0} through @code{q9}.
2135 They are ``quick'' simply because you don't have to type the letter
2136 @code{q} or the @key{RET} after their names. In fact, you can type
2137 simply @kbd{s 3} as a shorthand for @kbd{s s 3}, and likewise for
2138 @kbd{t 3} and @w{@kbd{r 3}}.
2139
2140 Any variables in an algebraic formula for which you have not stored
2141 values are left alone, even when you evaluate the formula.
2142
2143 @smallexample
2144 @group
2145 1: 2 a + 2 b 1: 34 + 2 b
2146 . .
2147
2148 ' 2a+2b @key{RET} =
2149 @end group
2150 @end smallexample
2151
2152 Calls to function names which are undefined in Calc are also left
2153 alone, as are calls for which the value is undefined.
2154
2155 @smallexample
2156 @group
2157 1: 2 + log10(0) + log10(x) + log10(5, 6) + foo(3)
2158 .
2159
2160 ' log10(100) + log10(0) + log10(x) + log10(5,6) + foo(3) @key{RET}
2161 @end group
2162 @end smallexample
2163
2164 @noindent
2165 In this example, the first call to @code{log10} works, but the other
2166 calls are not evaluated. In the second call, the logarithm is
2167 undefined for that value of the argument; in the third, the argument
2168 is symbolic, and in the fourth, there are too many arguments. In the
2169 fifth case, there is no function called @code{foo}. You will see a
2170 ``Wrong number of arguments'' message referring to @samp{log10(5,6)}.
2171 Press the @kbd{w} (``why'') key to see any other messages that may
2172 have arisen from the last calculation. In this case you will get
2173 ``logarithm of zero,'' then ``number expected: @code{x}''. Calc
2174 automatically displays the first message only if the message is
2175 sufficiently important; for example, Calc considers ``wrong number
2176 of arguments'' and ``logarithm of zero'' to be important enough to
2177 report automatically, while a message like ``number expected: @code{x}''
2178 will only show up if you explicitly press the @kbd{w} key.
2179
2180 (@bullet{}) @strong{Exercise 2.} Joe entered the formula @samp{2 x y},
2181 stored 5 in @code{x}, pressed @kbd{=}, and got the expected result,
2182 @samp{10 y}. He then tried the same for the formula @samp{2 x (1+y)},
2183 expecting @samp{10 (1+y)}, but it didn't work. Why not?
2184 @xref{Algebraic Answer 2, 2}. (@bullet{})
2185
2186 (@bullet{}) @strong{Exercise 3.} What result would you expect
2187 @kbd{1 @key{RET} 0 /} to give? What if you then type @kbd{0 *}?
2188 @xref{Algebraic Answer 3, 3}. (@bullet{})
2189
2190 One interesting way to work with variables is to use the
2191 @dfn{evaluates-to} (@samp{=>}) operator. It works like this:
2192 Enter a formula algebraically in the usual way, but follow
2193 the formula with an @samp{=>} symbol. (There is also an @kbd{s =}
2194 command which builds an @samp{=>} formula using the stack.) On
2195 the stack, you will see two copies of the formula with an @samp{=>}
2196 between them. The lefthand formula is exactly like you typed it;
2197 the righthand formula has been evaluated as if by typing @kbd{=}.
2198
2199 @smallexample
2200 @group
2201 2: 2 + 3 => 5 2: 2 + 3 => 5
2202 1: 2 a + 2 b => 34 + 2 b 1: 2 a + 2 b => 20 + 2 b
2203 . .
2204
2205 ' 2+3 => @key{RET} ' 2a+2b @key{RET} s = 10 s t a @key{RET}
2206 @end group
2207 @end smallexample
2208
2209 @noindent
2210 Notice that the instant we stored a new value in @code{a}, all
2211 @samp{=>} operators already on the stack that referred to @expr{a}
2212 were updated to use the new value. With @samp{=>}, you can push a
2213 set of formulas on the stack, then change the variables experimentally
2214 to see the effects on the formulas' values.
2215
2216 You can also ``unstore'' a variable when you are through with it:
2217
2218 @smallexample
2219 @group
2220 2: 2 + 5 => 5
2221 1: 2 a + 2 b => 2 a + 2 b
2222 .
2223
2224 s u a @key{RET}
2225 @end group
2226 @end smallexample
2227
2228 We will encounter formulas involving variables and functions again
2229 when we discuss the algebra and calculus features of the Calculator.
2230
2231 @node Undo Tutorial, Modes Tutorial, Algebraic Tutorial, Basic Tutorial
2232 @subsection Undo and Redo
2233
2234 @noindent
2235 If you make a mistake, you can usually correct it by pressing shift-@kbd{U},
2236 the ``undo'' command. First, clear the stack (@kbd{M-0 @key{DEL}}) and exit
2237 and restart Calc (@kbd{M-# M-# M-# M-#}) to make sure things start off
2238 with a clean slate. Now:
2239
2240 @smallexample
2241 @group
2242 1: 2 2: 2 1: 8 2: 2 1: 6
2243 . 1: 3 . 1: 3 .
2244 . .
2245
2246 2 @key{RET} 3 ^ U *
2247 @end group
2248 @end smallexample
2249
2250 You can undo any number of times. Calc keeps a complete record of
2251 all you have done since you last opened the Calc window. After the
2252 above example, you could type:
2253
2254 @smallexample
2255 @group
2256 1: 6 2: 2 1: 2 . .
2257 . 1: 3 .
2258 .
2259 (error)
2260 U U U U
2261 @end group
2262 @end smallexample
2263
2264 You can also type @kbd{D} to ``redo'' a command that you have undone
2265 mistakenly.
2266
2267 @smallexample
2268 @group
2269 . 1: 2 2: 2 1: 6 1: 6
2270 . 1: 3 . .
2271 .
2272 (error)
2273 D D D D
2274 @end group
2275 @end smallexample
2276
2277 @noindent
2278 It was not possible to redo past the @expr{6}, since that was placed there
2279 by something other than an undo command.
2280
2281 @cindex Time travel
2282 You can think of undo and redo as a sort of ``time machine.'' Press
2283 @kbd{U} to go backward in time, @kbd{D} to go forward. If you go
2284 backward and do something (like @kbd{*}) then, as any science fiction
2285 reader knows, you have changed your future and you cannot go forward
2286 again. Thus, the inability to redo past the @expr{6} even though there
2287 was an earlier undo command.
2288
2289 You can always recall an earlier result using the Trail. We've ignored
2290 the trail so far, but it has been faithfully recording everything we
2291 did since we loaded the Calculator. If the Trail is not displayed,
2292 press @kbd{t d} now to turn it on.
2293
2294 Let's try grabbing an earlier result. The @expr{8} we computed was
2295 undone by a @kbd{U} command, and was lost even to Redo when we pressed
2296 @kbd{*}, but it's still there in the trail. There should be a little
2297 @samp{>} arrow (the @dfn{trail pointer}) resting on the last trail
2298 entry. If there isn't, press @kbd{t ]} to reset the trail pointer.
2299 Now, press @w{@kbd{t p}} to move the arrow onto the line containing
2300 @expr{8}, and press @w{@kbd{t y}} to ``yank'' that number back onto the
2301 stack.
2302
2303 If you press @kbd{t ]} again, you will see that even our Yank command
2304 went into the trail.
2305
2306 Let's go further back in time. Earlier in the tutorial we computed
2307 a huge integer using the formula @samp{2^3^4}. We don't remember
2308 what it was, but the first digits were ``241''. Press @kbd{t r}
2309 (which stands for trail-search-reverse), then type @kbd{241}.
2310 The trail cursor will jump back to the next previous occurrence of
2311 the string ``241'' in the trail. This is just a regular Emacs
2312 incremental search; you can now press @kbd{C-s} or @kbd{C-r} to
2313 continue the search forwards or backwards as you like.
2314
2315 To finish the search, press @key{RET}. This halts the incremental
2316 search and leaves the trail pointer at the thing we found. Now we
2317 can type @kbd{t y} to yank that number onto the stack. If we hadn't
2318 remembered the ``241'', we could simply have searched for @kbd{2^3^4},
2319 then pressed @kbd{@key{RET} t n} to halt and then move to the next item.
2320
2321 You may have noticed that all the trail-related commands begin with
2322 the letter @kbd{t}. (The store-and-recall commands, on the other hand,
2323 all began with @kbd{s}.) Calc has so many commands that there aren't
2324 enough keys for all of them, so various commands are grouped into
2325 two-letter sequences where the first letter is called the @dfn{prefix}
2326 key. If you type a prefix key by accident, you can press @kbd{C-g}
2327 to cancel it. (In fact, you can press @kbd{C-g} to cancel almost
2328 anything in Emacs.) To get help on a prefix key, press that key
2329 followed by @kbd{?}. Some prefixes have several lines of help,
2330 so you need to press @kbd{?} repeatedly to see them all.
2331 You can also type @kbd{h h} to see all the help at once.
2332
2333 Try pressing @kbd{t ?} now. You will see a line of the form,
2334
2335 @smallexample
2336 trail/time: Display; Fwd, Back; Next, Prev, Here, [, ]; Yank: [MORE] t-
2337 @end smallexample
2338
2339 @noindent
2340 The word ``trail'' indicates that the @kbd{t} prefix key contains
2341 trail-related commands. Each entry on the line shows one command,
2342 with a single capital letter showing which letter you press to get
2343 that command. We have used @kbd{t n}, @kbd{t p}, @kbd{t ]}, and
2344 @kbd{t y} so far. The @samp{[MORE]} means you can press @kbd{?}
2345 again to see more @kbd{t}-prefix commands. Notice that the commands
2346 are roughly divided (by semicolons) into related groups.
2347
2348 When you are in the help display for a prefix key, the prefix is
2349 still active. If you press another key, like @kbd{y} for example,
2350 it will be interpreted as a @kbd{t y} command. If all you wanted
2351 was to look at the help messages, press @kbd{C-g} afterwards to cancel
2352 the prefix.
2353
2354 One more way to correct an error is by editing the stack entries.
2355 The actual Stack buffer is marked read-only and must not be edited
2356 directly, but you can press @kbd{`} (the backquote or accent grave)
2357 to edit a stack entry.
2358
2359 Try entering @samp{3.141439} now. If this is supposed to represent
2360 @cpi{}, it's got several errors. Press @kbd{`} to edit this number.
2361 Now use the normal Emacs cursor motion and editing keys to change
2362 the second 4 to a 5, and to transpose the 3 and the 9. When you
2363 press @key{RET}, the number on the stack will be replaced by your
2364 new number. This works for formulas, vectors, and all other types
2365 of values you can put on the stack. The @kbd{`} key also works
2366 during entry of a number or algebraic formula.
2367
2368 @node Modes Tutorial, , Undo Tutorial, Basic Tutorial
2369 @subsection Mode-Setting Commands
2370
2371 @noindent
2372 Calc has many types of @dfn{modes} that affect the way it interprets
2373 your commands or the way it displays data. We have already seen one
2374 mode, namely Algebraic mode. There are many others, too; we'll
2375 try some of the most common ones here.
2376
2377 Perhaps the most fundamental mode in Calc is the current @dfn{precision}.
2378 Notice the @samp{12} on the Calc window's mode line:
2379
2380 @smallexample
2381 --%%-Calc: 12 Deg (Calculator)----All------
2382 @end smallexample
2383
2384 @noindent
2385 Most of the symbols there are Emacs things you don't need to worry
2386 about, but the @samp{12} and the @samp{Deg} are mode indicators.
2387 The @samp{12} means that calculations should always be carried to
2388 12 significant figures. That is why, when we type @kbd{1 @key{RET} 7 /},
2389 we get @expr{0.142857142857} with exactly 12 digits, not counting
2390 leading and trailing zeros.
2391
2392 You can set the precision to anything you like by pressing @kbd{p},
2393 then entering a suitable number. Try pressing @kbd{p 30 @key{RET}},
2394 then doing @kbd{1 @key{RET} 7 /} again:
2395
2396 @smallexample
2397 @group
2398 1: 0.142857142857
2399 2: 0.142857142857142857142857142857
2400 .
2401 @end group
2402 @end smallexample
2403
2404 Although the precision can be set arbitrarily high, Calc always
2405 has to have @emph{some} value for the current precision. After
2406 all, the true value @expr{1/7} is an infinitely repeating decimal;
2407 Calc has to stop somewhere.
2408
2409 Of course, calculations are slower the more digits you request.
2410 Press @w{@kbd{p 12}} now to set the precision back down to the default.
2411
2412 Calculations always use the current precision. For example, even
2413 though we have a 30-digit value for @expr{1/7} on the stack, if
2414 we use it in a calculation in 12-digit mode it will be rounded
2415 down to 12 digits before it is used. Try it; press @key{RET} to
2416 duplicate the number, then @w{@kbd{1 +}}. Notice that the @key{RET}
2417 key didn't round the number, because it doesn't do any calculation.
2418 But the instant we pressed @kbd{+}, the number was rounded down.
2419
2420 @smallexample
2421 @group
2422 1: 0.142857142857
2423 2: 0.142857142857142857142857142857
2424 3: 1.14285714286
2425 .
2426 @end group
2427 @end smallexample
2428
2429 @noindent
2430 In fact, since we added a digit on the left, we had to lose one
2431 digit on the right from even the 12-digit value of @expr{1/7}.
2432
2433 How did we get more than 12 digits when we computed @samp{2^3^4}? The
2434 answer is that Calc makes a distinction between @dfn{integers} and
2435 @dfn{floating-point} numbers, or @dfn{floats}. An integer is a number
2436 that does not contain a decimal point. There is no such thing as an
2437 ``infinitely repeating fraction integer,'' so Calc doesn't have to limit
2438 itself. If you asked for @samp{2^10000} (don't try this!), you would
2439 have to wait a long time but you would eventually get an exact answer.
2440 If you ask for @samp{2.^10000}, you will quickly get an answer which is
2441 correct only to 12 places. The decimal point tells Calc that it should
2442 use floating-point arithmetic to get the answer, not exact integer
2443 arithmetic.
2444
2445 You can use the @kbd{F} (@code{calc-floor}) command to convert a
2446 floating-point value to an integer, and @kbd{c f} (@code{calc-float})
2447 to convert an integer to floating-point form.
2448
2449 Let's try entering that last calculation:
2450
2451 @smallexample
2452 @group
2453 1: 2. 2: 2. 1: 1.99506311689e3010
2454 . 1: 10000 .
2455 .
2456
2457 2.0 @key{RET} 10000 @key{RET} ^
2458 @end group
2459 @end smallexample
2460
2461 @noindent
2462 @cindex Scientific notation, entry of
2463 Notice the letter @samp{e} in there. It represents ``times ten to the
2464 power of,'' and is used by Calc automatically whenever writing the
2465 number out fully would introduce more extra zeros than you probably
2466 want to see. You can enter numbers in this notation, too.
2467
2468 @smallexample
2469 @group
2470 1: 2. 2: 2. 1: 1.99506311678e3010
2471 . 1: 10000. .
2472 .
2473
2474 2.0 @key{RET} 1e4 @key{RET} ^
2475 @end group
2476 @end smallexample
2477
2478 @cindex Round-off errors
2479 @noindent
2480 Hey, the answer is different! Look closely at the middle columns
2481 of the two examples. In the first, the stack contained the
2482 exact integer @expr{10000}, but in the second it contained
2483 a floating-point value with a decimal point. When you raise a
2484 number to an integer power, Calc uses repeated squaring and
2485 multiplication to get the answer. When you use a floating-point
2486 power, Calc uses logarithms and exponentials. As you can see,
2487 a slight error crept in during one of these methods. Which
2488 one should we trust? Let's raise the precision a bit and find
2489 out:
2490
2491 @smallexample
2492 @group
2493 . 1: 2. 2: 2. 1: 1.995063116880828e3010
2494 . 1: 10000. .
2495 .
2496
2497 p 16 @key{RET} 2. @key{RET} 1e4 ^ p 12 @key{RET}
2498 @end group
2499 @end smallexample
2500
2501 @noindent
2502 @cindex Guard digits
2503 Presumably, it doesn't matter whether we do this higher-precision
2504 calculation using an integer or floating-point power, since we
2505 have added enough ``guard digits'' to trust the first 12 digits
2506 no matter what. And the verdict is@dots{} Integer powers were more
2507 accurate; in fact, the result was only off by one unit in the
2508 last place.
2509
2510 @cindex Guard digits
2511 Calc does many of its internal calculations to a slightly higher
2512 precision, but it doesn't always bump the precision up enough.
2513 In each case, Calc added about two digits of precision during
2514 its calculation and then rounded back down to 12 digits
2515 afterward. In one case, it was enough; in the other, it
2516 wasn't. If you really need @var{x} digits of precision, it
2517 never hurts to do the calculation with a few extra guard digits.
2518
2519 What if we want guard digits but don't want to look at them?
2520 We can set the @dfn{float format}. Calc supports four major
2521 formats for floating-point numbers, called @dfn{normal},
2522 @dfn{fixed-point}, @dfn{scientific notation}, and @dfn{engineering
2523 notation}. You get them by pressing @w{@kbd{d n}}, @kbd{d f},
2524 @kbd{d s}, and @kbd{d e}, respectively. In each case, you can
2525 supply a numeric prefix argument which says how many digits
2526 should be displayed. As an example, let's put a few numbers
2527 onto the stack and try some different display modes. First,
2528 use @kbd{M-0 @key{DEL}} to clear the stack, then enter the four
2529 numbers shown here:
2530
2531 @smallexample
2532 @group
2533 4: 12345 4: 12345 4: 12345 4: 12345 4: 12345
2534 3: 12345. 3: 12300. 3: 1.2345e4 3: 1.23e4 3: 12345.000
2535 2: 123.45 2: 123. 2: 1.2345e2 2: 1.23e2 2: 123.450
2536 1: 12.345 1: 12.3 1: 1.2345e1 1: 1.23e1 1: 12.345
2537 . . . . .
2538
2539 d n M-3 d n d s M-3 d s M-3 d f
2540 @end group
2541 @end smallexample
2542
2543 @noindent
2544 Notice that when we typed @kbd{M-3 d n}, the numbers were rounded down
2545 to three significant digits, but then when we typed @kbd{d s} all
2546 five significant figures reappeared. The float format does not
2547 affect how numbers are stored, it only affects how they are
2548 displayed. Only the current precision governs the actual rounding
2549 of numbers in the Calculator's memory.
2550
2551 Engineering notation, not shown here, is like scientific notation
2552 except the exponent (the power-of-ten part) is always adjusted to be
2553 a multiple of three (as in ``kilo,'' ``micro,'' etc.). As a result
2554 there will be one, two, or three digits before the decimal point.
2555
2556 Whenever you change a display-related mode, Calc redraws everything
2557 in the stack. This may be slow if there are many things on the stack,
2558 so Calc allows you to type shift-@kbd{H} before any mode command to
2559 prevent it from updating the stack. Anything Calc displays after the
2560 mode-changing command will appear in the new format.
2561
2562 @smallexample
2563 @group
2564 4: 12345 4: 12345 4: 12345 4: 12345 4: 12345
2565 3: 12345.000 3: 12345.000 3: 12345.000 3: 1.2345e4 3: 12345.
2566 2: 123.450 2: 123.450 2: 1.2345e1 2: 1.2345e1 2: 123.45
2567 1: 12.345 1: 1.2345e1 1: 1.2345e2 1: 1.2345e2 1: 12.345
2568 . . . . .
2569
2570 H d s @key{DEL} U @key{TAB} d @key{SPC} d n
2571 @end group
2572 @end smallexample
2573
2574 @noindent
2575 Here the @kbd{H d s} command changes to scientific notation but without
2576 updating the screen. Deleting the top stack entry and undoing it back
2577 causes it to show up in the new format; swapping the top two stack
2578 entries reformats both entries. The @kbd{d @key{SPC}} command refreshes the
2579 whole stack. The @kbd{d n} command changes back to the normal float
2580 format; since it doesn't have an @kbd{H} prefix, it also updates all
2581 the stack entries to be in @kbd{d n} format.
2582
2583 Notice that the integer @expr{12345} was not affected by any
2584 of the float formats. Integers are integers, and are always
2585 displayed exactly.
2586
2587 @cindex Large numbers, readability
2588 Large integers have their own problems. Let's look back at
2589 the result of @kbd{2^3^4}.
2590
2591 @example
2592 2417851639229258349412352
2593 @end example
2594
2595 @noindent
2596 Quick---how many digits does this have? Try typing @kbd{d g}:
2597
2598 @example
2599 2,417,851,639,229,258,349,412,352
2600 @end example
2601
2602 @noindent
2603 Now how many digits does this have? It's much easier to tell!
2604 We can actually group digits into clumps of any size. Some
2605 people prefer @kbd{M-5 d g}:
2606
2607 @example
2608 24178,51639,22925,83494,12352
2609 @end example
2610
2611 Let's see what happens to floating-point numbers when they are grouped.
2612 First, type @kbd{p 25 @key{RET}} to make sure we have enough precision
2613 to get ourselves into trouble. Now, type @kbd{1e13 /}:
2614
2615 @example
2616 24,17851,63922.9258349412352
2617 @end example
2618
2619 @noindent
2620 The integer part is grouped but the fractional part isn't. Now try
2621 @kbd{M-- M-5 d g} (that's meta-minus-sign, meta-five):
2622
2623 @example
2624 24,17851,63922.92583,49412,352
2625 @end example
2626
2627 If you find it hard to tell the decimal point from the commas, try
2628 changing the grouping character to a space with @kbd{d , @key{SPC}}:
2629
2630 @example
2631 24 17851 63922.92583 49412 352
2632 @end example
2633
2634 Type @kbd{d , ,} to restore the normal grouping character, then
2635 @kbd{d g} again to turn grouping off. Also, press @kbd{p 12} to
2636 restore the default precision.
2637
2638 Press @kbd{U} enough times to get the original big integer back.
2639 (Notice that @kbd{U} does not undo each mode-setting command; if
2640 you want to undo a mode-setting command, you have to do it yourself.)
2641 Now, type @kbd{d r 16 @key{RET}}:
2642
2643 @example
2644 16#200000000000000000000
2645 @end example
2646
2647 @noindent
2648 The number is now displayed in @dfn{hexadecimal}, or ``base-16'' form.
2649 Suddenly it looks pretty simple; this should be no surprise, since we
2650 got this number by computing a power of two, and 16 is a power of 2.
2651 In fact, we can use @w{@kbd{d r 2 @key{RET}}} to see it in actual binary
2652 form:
2653
2654 @example
2655 2#1000000000000000000000000000000000000000000000000000000 @dots{}
2656 @end example
2657
2658 @noindent
2659 We don't have enough space here to show all the zeros! They won't
2660 fit on a typical screen, either, so you will have to use horizontal
2661 scrolling to see them all. Press @kbd{<} and @kbd{>} to scroll the
2662 stack window left and right by half its width. Another way to view
2663 something large is to press @kbd{`} (back-quote) to edit the top of
2664 stack in a separate window. (Press @kbd{C-c C-c} when you are done.)
2665
2666 You can enter non-decimal numbers using the @kbd{#} symbol, too.
2667 Let's see what the hexadecimal number @samp{5FE} looks like in
2668 binary. Type @kbd{16#5FE} (the letters can be typed in upper or
2669 lower case; they will always appear in upper case). It will also
2670 help to turn grouping on with @kbd{d g}:
2671
2672 @example
2673 2#101,1111,1110
2674 @end example
2675
2676 Notice that @kbd{d g} groups by fours by default if the display radix
2677 is binary or hexadecimal, but by threes if it is decimal, octal, or any
2678 other radix.
2679
2680 Now let's see that number in decimal; type @kbd{d r 10}:
2681
2682 @example
2683 1,534
2684 @end example
2685
2686 Numbers are not @emph{stored} with any particular radix attached. They're
2687 just numbers; they can be entered in any radix, and are always displayed
2688 in whatever radix you've chosen with @kbd{d r}. The current radix applies
2689 to integers, fractions, and floats.
2690
2691 @cindex Roundoff errors, in non-decimal numbers
2692 (@bullet{}) @strong{Exercise 1.} Your friend Joe tried to enter one-third
2693 as @samp{3#0.1} in @kbd{d r 3} mode with a precision of 12. He got
2694 @samp{3#0.0222222...} (with 25 2's) in the display. When he multiplied
2695 that by three, he got @samp{3#0.222222...} instead of the expected
2696 @samp{3#1}. Next, Joe entered @samp{3#0.2} and, to his great relief,
2697 saw @samp{3#0.2} on the screen. But when he typed @kbd{2 /}, he got
2698 @samp{3#0.10000001} (some zeros omitted). What's going on here?
2699 @xref{Modes Answer 1, 1}. (@bullet{})
2700
2701 @cindex Scientific notation, in non-decimal numbers
2702 (@bullet{}) @strong{Exercise 2.} Scientific notation works in non-decimal
2703 modes in the natural way (the exponent is a power of the radix instead of
2704 a power of ten, although the exponent itself is always written in decimal).
2705 Thus @samp{8#1.23e3 = 8#1230.0}. Suppose we have the hexadecimal number
2706 @samp{f.e8f} times 16 to the 15th power: We write @samp{16#f.e8fe15}.
2707 What is wrong with this picture? What could we write instead that would
2708 work better? @xref{Modes Answer 2, 2}. (@bullet{})
2709
2710 The @kbd{m} prefix key has another set of modes, relating to the way
2711 Calc interprets your inputs and does computations. Whereas @kbd{d}-prefix
2712 modes generally affect the way things look, @kbd{m}-prefix modes affect
2713 the way they are actually computed.
2714
2715 The most popular @kbd{m}-prefix mode is the @dfn{angular mode}. Notice
2716 the @samp{Deg} indicator in the mode line. This means that if you use
2717 a command that interprets a number as an angle, it will assume the
2718 angle is measured in degrees. For example,
2719
2720 @smallexample
2721 @group
2722 1: 45 1: 0.707106781187 1: 0.500000000001 1: 0.5
2723 . . . .
2724
2725 45 S 2 ^ c 1
2726 @end group
2727 @end smallexample
2728
2729 @noindent
2730 The shift-@kbd{S} command computes the sine of an angle. The sine
2731 of 45 degrees is
2732 @texline @math{\sqrt{2}/2};
2733 @infoline @expr{sqrt(2)/2};
2734 squaring this yields @expr{2/4 = 0.5}. However, there has been a slight
2735 roundoff error because the representation of
2736 @texline @math{\sqrt{2}/2}
2737 @infoline @expr{sqrt(2)/2}
2738 wasn't exact. The @kbd{c 1} command is a handy way to clean up numbers
2739 in this case; it temporarily reduces the precision by one digit while it
2740 re-rounds the number on the top of the stack.
2741
2742 @cindex Roundoff errors, examples
2743 (@bullet{}) @strong{Exercise 3.} Your friend Joe computed the sine
2744 of 45 degrees as shown above, then, hoping to avoid an inexact
2745 result, he increased the precision to 16 digits before squaring.
2746 What happened? @xref{Modes Answer 3, 3}. (@bullet{})
2747
2748 To do this calculation in radians, we would type @kbd{m r} first.
2749 (The indicator changes to @samp{Rad}.) 45 degrees corresponds to
2750 @cpiover{4} radians. To get @cpi{}, press the @kbd{P} key. (Once
2751 again, this is a shifted capital @kbd{P}. Remember, unshifted
2752 @kbd{p} sets the precision.)
2753
2754 @smallexample
2755 @group
2756 1: 3.14159265359 1: 0.785398163398 1: 0.707106781187
2757 . . .
2758
2759 P 4 / m r S
2760 @end group
2761 @end smallexample
2762
2763 Likewise, inverse trigonometric functions generate results in
2764 either radians or degrees, depending on the current angular mode.
2765
2766 @smallexample
2767 @group
2768 1: 0.707106781187 1: 0.785398163398 1: 45.
2769 . . .
2770
2771 .5 Q m r I S m d U I S
2772 @end group
2773 @end smallexample
2774
2775 @noindent
2776 Here we compute the Inverse Sine of
2777 @texline @math{\sqrt{0.5}},
2778 @infoline @expr{sqrt(0.5)},
2779 first in radians, then in degrees.
2780
2781 Use @kbd{c d} and @kbd{c r} to convert a number from radians to degrees
2782 and vice-versa.
2783
2784 @smallexample
2785 @group
2786 1: 45 1: 0.785398163397 1: 45.
2787 . . .
2788
2789 45 c r c d
2790 @end group
2791 @end smallexample
2792
2793 Another interesting mode is @dfn{Fraction mode}. Normally,
2794 dividing two integers produces a floating-point result if the
2795 quotient can't be expressed as an exact integer. Fraction mode
2796 causes integer division to produce a fraction, i.e., a rational
2797 number, instead.
2798
2799 @smallexample
2800 @group
2801 2: 12 1: 1.33333333333 1: 4:3
2802 1: 9 . .
2803 .
2804
2805 12 @key{RET} 9 / m f U / m f
2806 @end group
2807 @end smallexample
2808
2809 @noindent
2810 In the first case, we get an approximate floating-point result.
2811 In the second case, we get an exact fractional result (four-thirds).
2812
2813 You can enter a fraction at any time using @kbd{:} notation.
2814 (Calc uses @kbd{:} instead of @kbd{/} as the fraction separator
2815 because @kbd{/} is already used to divide the top two stack
2816 elements.) Calculations involving fractions will always
2817 produce exact fractional results; Fraction mode only says
2818 what to do when dividing two integers.
2819
2820 @cindex Fractions vs. floats
2821 @cindex Floats vs. fractions
2822 (@bullet{}) @strong{Exercise 4.} If fractional arithmetic is exact,
2823 why would you ever use floating-point numbers instead?
2824 @xref{Modes Answer 4, 4}. (@bullet{})
2825
2826 Typing @kbd{m f} doesn't change any existing values in the stack.
2827 In the above example, we had to Undo the division and do it over
2828 again when we changed to Fraction mode. But if you use the
2829 evaluates-to operator you can get commands like @kbd{m f} to
2830 recompute for you.
2831
2832 @smallexample
2833 @group
2834 1: 12 / 9 => 1.33333333333 1: 12 / 9 => 1.333 1: 12 / 9 => 4:3
2835 . . .
2836
2837 ' 12/9 => @key{RET} p 4 @key{RET} m f
2838 @end group
2839 @end smallexample
2840
2841 @noindent
2842 In this example, the righthand side of the @samp{=>} operator
2843 on the stack is recomputed when we change the precision, then
2844 again when we change to Fraction mode. All @samp{=>} expressions
2845 on the stack are recomputed every time you change any mode that
2846 might affect their values.
2847
2848 @node Arithmetic Tutorial, Vector/Matrix Tutorial, Basic Tutorial, Tutorial
2849 @section Arithmetic Tutorial
2850
2851 @noindent
2852 In this section, we explore the arithmetic and scientific functions
2853 available in the Calculator.
2854
2855 The standard arithmetic commands are @kbd{+}, @kbd{-}, @kbd{*}, @kbd{/},
2856 and @kbd{^}. Each normally takes two numbers from the top of the stack
2857 and pushes back a result. The @kbd{n} and @kbd{&} keys perform
2858 change-sign and reciprocal operations, respectively.
2859
2860 @smallexample
2861 @group
2862 1: 5 1: 0.2 1: 5. 1: -5. 1: 5.
2863 . . . . .
2864
2865 5 & & n n
2866 @end group
2867 @end smallexample
2868
2869 @cindex Binary operators
2870 You can apply a ``binary operator'' like @kbd{+} across any number of
2871 stack entries by giving it a numeric prefix. You can also apply it
2872 pairwise to several stack elements along with the top one if you use
2873 a negative prefix.
2874
2875 @smallexample
2876 @group
2877 3: 2 1: 9 3: 2 4: 2 3: 12
2878 2: 3 . 2: 3 3: 3 2: 13
2879 1: 4 1: 4 2: 4 1: 14
2880 . . 1: 10 .
2881 .
2882
2883 2 @key{RET} 3 @key{RET} 4 M-3 + U 10 M-- M-3 +
2884 @end group
2885 @end smallexample
2886
2887 @cindex Unary operators
2888 You can apply a ``unary operator'' like @kbd{&} to the top @var{n}
2889 stack entries with a numeric prefix, too.
2890
2891 @smallexample
2892 @group
2893 3: 2 3: 0.5 3: 0.5
2894 2: 3 2: 0.333333333333 2: 3.
2895 1: 4 1: 0.25 1: 4.
2896 . . .
2897
2898 2 @key{RET} 3 @key{RET} 4 M-3 & M-2 &
2899 @end group
2900 @end smallexample
2901
2902 Notice that the results here are left in floating-point form.
2903 We can convert them back to integers by pressing @kbd{F}, the
2904 ``floor'' function. This function rounds down to the next lower
2905 integer. There is also @kbd{R}, which rounds to the nearest
2906 integer.
2907
2908 @smallexample
2909 @group
2910 7: 2. 7: 2 7: 2
2911 6: 2.4 6: 2 6: 2
2912 5: 2.5 5: 2 5: 3
2913 4: 2.6 4: 2 4: 3
2914 3: -2. 3: -2 3: -2
2915 2: -2.4 2: -3 2: -2
2916 1: -2.6 1: -3 1: -3
2917 . . .
2918
2919 M-7 F U M-7 R
2920 @end group
2921 @end smallexample
2922
2923 Since dividing-and-flooring (i.e., ``integer quotient'') is such a
2924 common operation, Calc provides a special command for that purpose, the
2925 backslash @kbd{\}. Another common arithmetic operator is @kbd{%}, which
2926 computes the remainder that would arise from a @kbd{\} operation, i.e.,
2927 the ``modulo'' of two numbers. For example,
2928
2929 @smallexample
2930 @group
2931 2: 1234 1: 12 2: 1234 1: 34
2932 1: 100 . 1: 100 .
2933 . .
2934
2935 1234 @key{RET} 100 \ U %
2936 @end group
2937 @end smallexample
2938
2939 These commands actually work for any real numbers, not just integers.
2940
2941 @smallexample
2942 @group
2943 2: 3.1415 1: 3 2: 3.1415 1: 0.1415
2944 1: 1 . 1: 1 .
2945 . .
2946
2947 3.1415 @key{RET} 1 \ U %
2948 @end group
2949 @end smallexample
2950
2951 (@bullet{}) @strong{Exercise 1.} The @kbd{\} command would appear to be a
2952 frill, since you could always do the same thing with @kbd{/ F}. Think
2953 of a situation where this is not true---@kbd{/ F} would be inadequate.
2954 Now think of a way you could get around the problem if Calc didn't
2955 provide a @kbd{\} command. @xref{Arithmetic Answer 1, 1}. (@bullet{})
2956
2957 We've already seen the @kbd{Q} (square root) and @kbd{S} (sine)
2958 commands. Other commands along those lines are @kbd{C} (cosine),
2959 @kbd{T} (tangent), @kbd{E} (@expr{e^x}) and @kbd{L} (natural
2960 logarithm). These can be modified by the @kbd{I} (inverse) and
2961 @kbd{H} (hyperbolic) prefix keys.
2962
2963 Let's compute the sine and cosine of an angle, and verify the
2964 identity
2965 @texline @math{\sin^2x + \cos^2x = 1}.
2966 @infoline @expr{sin(x)^2 + cos(x)^2 = 1}.
2967 We'll arbitrarily pick @mathit{-64} degrees as a good value for @expr{x}.
2968 With the angular mode set to degrees (type @w{@kbd{m d}}), do:
2969
2970 @smallexample
2971 @group
2972 2: -64 2: -64 2: -0.89879 2: -0.89879 1: 1.
2973 1: -64 1: -0.89879 1: -64 1: 0.43837 .
2974 . . . .
2975
2976 64 n @key{RET} @key{RET} S @key{TAB} C f h
2977 @end group
2978 @end smallexample
2979
2980 @noindent
2981 (For brevity, we're showing only five digits of the results here.
2982 You can of course do these calculations to any precision you like.)
2983
2984 Remember, @kbd{f h} is the @code{calc-hypot}, or square-root of sum
2985 of squares, command.
2986
2987 Another identity is
2988 @texline @math{\displaystyle\tan x = {\sin x \over \cos x}}.
2989 @infoline @expr{tan(x) = sin(x) / cos(x)}.
2990 @smallexample
2991 @group
2992
2993 2: -0.89879 1: -2.0503 1: -64.
2994 1: 0.43837 . .
2995 .
2996
2997 U / I T
2998 @end group
2999 @end smallexample
3000
3001 A physical interpretation of this calculation is that if you move
3002 @expr{0.89879} units downward and @expr{0.43837} units to the right,
3003 your direction of motion is @mathit{-64} degrees from horizontal. Suppose
3004 we move in the opposite direction, up and to the left:
3005
3006 @smallexample
3007 @group
3008 2: -0.89879 2: 0.89879 1: -2.0503 1: -64.
3009 1: 0.43837 1: -0.43837 . .
3010 . .
3011
3012 U U M-2 n / I T
3013 @end group
3014 @end smallexample
3015
3016 @noindent
3017 How can the angle be the same? The answer is that the @kbd{/} operation
3018 loses information about the signs of its inputs. Because the quotient
3019 is negative, we know exactly one of the inputs was negative, but we
3020 can't tell which one. There is an @kbd{f T} [@code{arctan2}] function which
3021 computes the inverse tangent of the quotient of a pair of numbers.
3022 Since you feed it the two original numbers, it has enough information
3023 to give you a full 360-degree answer.
3024
3025 @smallexample
3026 @group
3027 2: 0.89879 1: 116. 3: 116. 2: 116. 1: 180.
3028 1: -0.43837 . 2: -0.89879 1: -64. .
3029 . 1: 0.43837 .
3030 .
3031
3032 U U f T M-@key{RET} M-2 n f T -
3033 @end group
3034 @end smallexample
3035
3036 @noindent
3037 The resulting angles differ by 180 degrees; in other words, they
3038 point in opposite directions, just as we would expect.
3039
3040 The @key{META}-@key{RET} we used in the third step is the
3041 ``last-arguments'' command. It is sort of like Undo, except that it
3042 restores the arguments of the last command to the stack without removing
3043 the command's result. It is useful in situations like this one,
3044 where we need to do several operations on the same inputs. We could
3045 have accomplished the same thing by using @kbd{M-2 @key{RET}} to duplicate
3046 the top two stack elements right after the @kbd{U U}, then a pair of
3047 @kbd{M-@key{TAB}} commands to cycle the 116 up around the duplicates.
3048
3049 A similar identity is supposed to hold for hyperbolic sines and cosines,
3050 except that it is the @emph{difference}
3051 @texline @math{\cosh^2x - \sinh^2x}
3052 @infoline @expr{cosh(x)^2 - sinh(x)^2}
3053 that always equals one. Let's try to verify this identity.
3054
3055 @smallexample
3056 @group
3057 2: -64 2: -64 2: -64 2: 9.7192e54 2: 9.7192e54
3058 1: -64 1: -3.1175e27 1: 9.7192e54 1: -64 1: 9.7192e54
3059 . . . . .
3060
3061 64 n @key{RET} @key{RET} H C 2 ^ @key{TAB} H S 2 ^
3062 @end group
3063 @end smallexample
3064
3065 @noindent
3066 @cindex Roundoff errors, examples
3067 Something's obviously wrong, because when we subtract these numbers
3068 the answer will clearly be zero! But if you think about it, if these
3069 numbers @emph{did} differ by one, it would be in the 55th decimal
3070 place. The difference we seek has been lost entirely to roundoff
3071 error.
3072
3073 We could verify this hypothesis by doing the actual calculation with,
3074 say, 60 decimal places of precision. This will be slow, but not
3075 enormously so. Try it if you wish; sure enough, the answer is
3076 0.99999, reasonably close to 1.
3077
3078 Of course, a more reasonable way to verify the identity is to use
3079 a more reasonable value for @expr{x}!
3080
3081 @cindex Common logarithm
3082 Some Calculator commands use the Hyperbolic prefix for other purposes.
3083 The logarithm and exponential functions, for example, work to the base
3084 @expr{e} normally but use base-10 instead if you use the Hyperbolic
3085 prefix.
3086
3087 @smallexample
3088 @group
3089 1: 1000 1: 6.9077 1: 1000 1: 3
3090 . . . .
3091
3092 1000 L U H L
3093 @end group
3094 @end smallexample
3095
3096 @noindent
3097 First, we mistakenly compute a natural logarithm. Then we undo
3098 and compute a common logarithm instead.
3099
3100 The @kbd{B} key computes a general base-@var{b} logarithm for any
3101 value of @var{b}.
3102
3103 @smallexample
3104 @group
3105 2: 1000 1: 3 1: 1000. 2: 1000. 1: 6.9077
3106 1: 10 . . 1: 2.71828 .
3107 . .
3108
3109 1000 @key{RET} 10 B H E H P B
3110 @end group
3111 @end smallexample
3112
3113 @noindent
3114 Here we first use @kbd{B} to compute the base-10 logarithm, then use
3115 the ``hyperbolic'' exponential as a cheap hack to recover the number
3116 1000, then use @kbd{B} again to compute the natural logarithm. Note
3117 that @kbd{P} with the hyperbolic prefix pushes the constant @expr{e}
3118 onto the stack.
3119
3120 You may have noticed that both times we took the base-10 logarithm
3121 of 1000, we got an exact integer result. Calc always tries to give
3122 an exact rational result for calculations involving rational numbers
3123 where possible. But when we used @kbd{H E}, the result was a
3124 floating-point number for no apparent reason. In fact, if we had
3125 computed @kbd{10 @key{RET} 3 ^} we @emph{would} have gotten an
3126 exact integer 1000. But the @kbd{H E} command is rigged to generate
3127 a floating-point result all of the time so that @kbd{1000 H E} will
3128 not waste time computing a thousand-digit integer when all you
3129 probably wanted was @samp{1e1000}.
3130
3131 (@bullet{}) @strong{Exercise 2.} Find a pair of integer inputs to
3132 the @kbd{B} command for which Calc could find an exact rational
3133 result but doesn't. @xref{Arithmetic Answer 2, 2}. (@bullet{})
3134
3135 The Calculator also has a set of functions relating to combinatorics
3136 and statistics. You may be familiar with the @dfn{factorial} function,
3137 which computes the product of all the integers up to a given number.
3138
3139 @smallexample
3140 @group
3141 1: 100 1: 93326215443... 1: 100. 1: 9.3326e157
3142 . . . .
3143
3144 100 ! U c f !
3145 @end group
3146 @end smallexample
3147
3148 @noindent
3149 Recall, the @kbd{c f} command converts the integer or fraction at the
3150 top of the stack to floating-point format. If you take the factorial
3151 of a floating-point number, you get a floating-point result
3152 accurate to the current precision. But if you give @kbd{!} an
3153 exact integer, you get an exact integer result (158 digits long
3154 in this case).
3155
3156 If you take the factorial of a non-integer, Calc uses a generalized
3157 factorial function defined in terms of Euler's Gamma function
3158 @texline @math{\Gamma(n)}
3159 @infoline @expr{gamma(n)}
3160 (which is itself available as the @kbd{f g} command).
3161
3162 @smallexample
3163 @group
3164 3: 4. 3: 24. 1: 5.5 1: 52.342777847
3165 2: 4.5 2: 52.3427777847 . .
3166 1: 5. 1: 120.
3167 . .
3168
3169 M-3 ! M-0 @key{DEL} 5.5 f g
3170 @end group
3171 @end smallexample
3172
3173 @noindent
3174 Here we verify the identity
3175 @texline @math{n! = \Gamma(n+1)}.
3176 @infoline @expr{@var{n}!@: = gamma(@var{n}+1)}.
3177
3178 The binomial coefficient @var{n}-choose-@var{m}
3179 @texline or @math{\displaystyle {n \choose m}}
3180 is defined by
3181 @texline @math{\displaystyle {n! \over m! \, (n-m)!}}
3182 @infoline @expr{n!@: / m!@: (n-m)!}
3183 for all reals @expr{n} and @expr{m}. The intermediate results in this
3184 formula can become quite large even if the final result is small; the
3185 @kbd{k c} command computes a binomial coefficient in a way that avoids
3186 large intermediate values.
3187
3188 The @kbd{k} prefix key defines several common functions out of
3189 combinatorics and number theory. Here we compute the binomial
3190 coefficient 30-choose-20, then determine its prime factorization.
3191
3192 @smallexample
3193 @group
3194 2: 30 1: 30045015 1: [3, 3, 5, 7, 11, 13, 23, 29]
3195 1: 20 . .
3196 .
3197
3198 30 @key{RET} 20 k c k f
3199 @end group
3200 @end smallexample
3201
3202 @noindent
3203 You can verify these prime factors by using @kbd{v u} to ``unpack''
3204 this vector into 8 separate stack entries, then @kbd{M-8 *} to
3205 multiply them back together. The result is the original number,
3206 30045015.
3207
3208 @cindex Hash tables
3209 Suppose a program you are writing needs a hash table with at least
3210 10000 entries. It's best to use a prime number as the actual size
3211 of a hash table. Calc can compute the next prime number after 10000:
3212
3213 @smallexample
3214 @group
3215 1: 10000 1: 10007 1: 9973
3216 . . .
3217
3218 10000 k n I k n
3219 @end group
3220 @end smallexample
3221
3222 @noindent
3223 Just for kicks we've also computed the next prime @emph{less} than
3224 10000.
3225
3226 @c [fix-ref Financial Functions]
3227 @xref{Financial Functions}, for a description of the Calculator
3228 commands that deal with business and financial calculations (functions
3229 like @code{pv}, @code{rate}, and @code{sln}).
3230
3231 @c [fix-ref Binary Number Functions]
3232 @xref{Binary Functions}, to read about the commands for operating
3233 on binary numbers (like @code{and}, @code{xor}, and @code{lsh}).
3234
3235 @node Vector/Matrix Tutorial, Types Tutorial, Arithmetic Tutorial, Tutorial
3236 @section Vector/Matrix Tutorial
3237
3238 @noindent
3239 A @dfn{vector} is a list of numbers or other Calc data objects.
3240 Calc provides a large set of commands that operate on vectors. Some
3241 are familiar operations from vector analysis. Others simply treat
3242 a vector as a list of objects.
3243
3244 @menu
3245 * Vector Analysis Tutorial::
3246 * Matrix Tutorial::
3247 * List Tutorial::
3248 @end menu
3249
3250 @node Vector Analysis Tutorial, Matrix Tutorial, Vector/Matrix Tutorial, Vector/Matrix Tutorial
3251 @subsection Vector Analysis
3252
3253 @noindent
3254 If you add two vectors, the result is a vector of the sums of the
3255 elements, taken pairwise.
3256
3257 @smallexample
3258 @group
3259 1: [1, 2, 3] 2: [1, 2, 3] 1: [8, 8, 3]
3260 . 1: [7, 6, 0] .
3261 .
3262
3263 [1,2,3] s 1 [7 6 0] s 2 +
3264 @end group
3265 @end smallexample
3266
3267 @noindent
3268 Note that we can separate the vector elements with either commas or
3269 spaces. This is true whether we are using incomplete vectors or
3270 algebraic entry. The @kbd{s 1} and @kbd{s 2} commands save these
3271 vectors so we can easily reuse them later.
3272
3273 If you multiply two vectors, the result is the sum of the products
3274 of the elements taken pairwise. This is called the @dfn{dot product}
3275 of the vectors.
3276
3277 @smallexample
3278 @group
3279 2: [1, 2, 3] 1: 19
3280 1: [7, 6, 0] .
3281 .
3282
3283 r 1 r 2 *
3284 @end group
3285 @end smallexample
3286
3287 @cindex Dot product
3288 The dot product of two vectors is equal to the product of their
3289 lengths times the cosine of the angle between them. (Here the vector
3290 is interpreted as a line from the origin @expr{(0,0,0)} to the
3291 specified point in three-dimensional space.) The @kbd{A}
3292 (absolute value) command can be used to compute the length of a
3293 vector.
3294
3295 @smallexample
3296 @group
3297 3: 19 3: 19 1: 0.550782 1: 56.579
3298 2: [1, 2, 3] 2: 3.741657 . .
3299 1: [7, 6, 0] 1: 9.219544
3300 . .
3301
3302 M-@key{RET} M-2 A * / I C
3303 @end group
3304 @end smallexample
3305
3306 @noindent
3307 First we recall the arguments to the dot product command, then
3308 we compute the absolute values of the top two stack entries to
3309 obtain the lengths of the vectors, then we divide the dot product
3310 by the product of the lengths to get the cosine of the angle.
3311 The inverse cosine finds that the angle between the vectors
3312 is about 56 degrees.
3313
3314 @cindex Cross product
3315 @cindex Perpendicular vectors
3316 The @dfn{cross product} of two vectors is a vector whose length
3317 is the product of the lengths of the inputs times the sine of the
3318 angle between them, and whose direction is perpendicular to both
3319 input vectors. Unlike the dot product, the cross product is
3320 defined only for three-dimensional vectors. Let's double-check
3321 our computation of the angle using the cross product.
3322
3323 @smallexample
3324 @group
3325 2: [1, 2, 3] 3: [-18, 21, -8] 1: [-0.52, 0.61, -0.23] 1: 56.579
3326 1: [7, 6, 0] 2: [1, 2, 3] . .
3327 . 1: [7, 6, 0]
3328 .
3329
3330 r 1 r 2 V C s 3 M-@key{RET} M-2 A * / A I S
3331 @end group
3332 @end smallexample
3333
3334 @noindent
3335 First we recall the original vectors and compute their cross product,
3336 which we also store for later reference. Now we divide the vector
3337 by the product of the lengths of the original vectors. The length of
3338 this vector should be the sine of the angle; sure enough, it is!
3339
3340 @c [fix-ref General Mode Commands]
3341 Vector-related commands generally begin with the @kbd{v} prefix key.
3342 Some are uppercase letters and some are lowercase. To make it easier
3343 to type these commands, the shift-@kbd{V} prefix key acts the same as
3344 the @kbd{v} key. (@xref{General Mode Commands}, for a way to make all
3345 prefix keys have this property.)
3346
3347 If we take the dot product of two perpendicular vectors we expect
3348 to get zero, since the cosine of 90 degrees is zero. Let's check
3349 that the cross product is indeed perpendicular to both inputs:
3350
3351 @smallexample
3352 @group
3353 2: [1, 2, 3] 1: 0 2: [7, 6, 0] 1: 0
3354 1: [-18, 21, -8] . 1: [-18, 21, -8] .
3355 . .
3356
3357 r 1 r 3 * @key{DEL} r 2 r 3 *
3358 @end group
3359 @end smallexample
3360
3361 @cindex Normalizing a vector
3362 @cindex Unit vectors
3363 (@bullet{}) @strong{Exercise 1.} Given a vector on the top of the
3364 stack, what keystrokes would you use to @dfn{normalize} the
3365 vector, i.e., to reduce its length to one without changing its
3366 direction? @xref{Vector Answer 1, 1}. (@bullet{})
3367
3368 (@bullet{}) @strong{Exercise 2.} Suppose a certain particle can be
3369 at any of several positions along a ruler. You have a list of
3370 those positions in the form of a vector, and another list of the
3371 probabilities for the particle to be at the corresponding positions.
3372 Find the average position of the particle.
3373 @xref{Vector Answer 2, 2}. (@bullet{})
3374
3375 @node Matrix Tutorial, List Tutorial, Vector Analysis Tutorial, Vector/Matrix Tutorial
3376 @subsection Matrices
3377
3378 @noindent
3379 A @dfn{matrix} is just a vector of vectors, all the same length.
3380 This means you can enter a matrix using nested brackets. You can
3381 also use the semicolon character to enter a matrix. We'll show
3382 both methods here:
3383
3384 @smallexample
3385 @group
3386 1: [ [ 1, 2, 3 ] 1: [ [ 1, 2, 3 ]
3387 [ 4, 5, 6 ] ] [ 4, 5, 6 ] ]
3388 . .
3389
3390 [[1 2 3] [4 5 6]] ' [1 2 3; 4 5 6] @key{RET}
3391 @end group
3392 @end smallexample
3393
3394 @noindent
3395 We'll be using this matrix again, so type @kbd{s 4} to save it now.
3396
3397 Note that semicolons work with incomplete vectors, but they work
3398 better in algebraic entry. That's why we use the apostrophe in
3399 the second example.
3400
3401 When two matrices are multiplied, the lefthand matrix must have
3402 the same number of columns as the righthand matrix has rows.
3403 Row @expr{i}, column @expr{j} of the result is effectively the
3404 dot product of row @expr{i} of the left matrix by column @expr{j}
3405 of the right matrix.
3406
3407 If we try to duplicate this matrix and multiply it by itself,
3408 the dimensions are wrong and the multiplication cannot take place:
3409
3410 @smallexample
3411 @group
3412 1: [ [ 1, 2, 3 ] * [ [ 1, 2, 3 ]
3413 [ 4, 5, 6 ] ] [ 4, 5, 6 ] ]
3414 .
3415
3416 @key{RET} *
3417 @end group
3418 @end smallexample
3419
3420 @noindent
3421 Though rather hard to read, this is a formula which shows the product
3422 of two matrices. The @samp{*} function, having invalid arguments, has
3423 been left in symbolic form.
3424
3425 We can multiply the matrices if we @dfn{transpose} one of them first.
3426
3427 @smallexample
3428 @group
3429 2: [ [ 1, 2, 3 ] 1: [ [ 14, 32 ] 1: [ [ 17, 22, 27 ]
3430 [ 4, 5, 6 ] ] [ 32, 77 ] ] [ 22, 29, 36 ]
3431 1: [ [ 1, 4 ] . [ 27, 36, 45 ] ]
3432 [ 2, 5 ] .
3433 [ 3, 6 ] ]
3434 .
3435
3436 U v t * U @key{TAB} *
3437 @end group
3438 @end smallexample
3439
3440 Matrix multiplication is not commutative; indeed, switching the
3441 order of the operands can even change the dimensions of the result
3442 matrix, as happened here!
3443
3444 If you multiply a plain vector by a matrix, it is treated as a
3445 single row or column depending on which side of the matrix it is
3446 on. The result is a plain vector which should also be interpreted
3447 as a row or column as appropriate.
3448
3449 @smallexample
3450 @group
3451 2: [ [ 1, 2, 3 ] 1: [14, 32]
3452 [ 4, 5, 6 ] ] .
3453 1: [1, 2, 3]
3454 .
3455
3456 r 4 r 1 *
3457 @end group
3458 @end smallexample
3459
3460 Multiplying in the other order wouldn't work because the number of
3461 rows in the matrix is different from the number of elements in the
3462 vector.
3463
3464 (@bullet{}) @strong{Exercise 1.} Use @samp{*} to sum along the rows
3465 of the above
3466 @texline @math{2\times3}
3467 @infoline 2x3
3468 matrix to get @expr{[6, 15]}. Now use @samp{*} to sum along the columns
3469 to get @expr{[5, 7, 9]}.
3470 @xref{Matrix Answer 1, 1}. (@bullet{})
3471
3472 @cindex Identity matrix
3473 An @dfn{identity matrix} is a square matrix with ones along the
3474 diagonal and zeros elsewhere. It has the property that multiplication
3475 by an identity matrix, on the left or on the right, always produces
3476 the original matrix.
3477
3478 @smallexample
3479 @group
3480 1: [ [ 1, 2, 3 ] 2: [ [ 1, 2, 3 ] 1: [ [ 1, 2, 3 ]
3481 [ 4, 5, 6 ] ] [ 4, 5, 6 ] ] [ 4, 5, 6 ] ]
3482 . 1: [ [ 1, 0, 0 ] .
3483 [ 0, 1, 0 ]
3484 [ 0, 0, 1 ] ]
3485 .
3486
3487 r 4 v i 3 @key{RET} *
3488 @end group
3489 @end smallexample
3490
3491 If a matrix is square, it is often possible to find its @dfn{inverse},
3492 that is, a matrix which, when multiplied by the original matrix, yields
3493 an identity matrix. The @kbd{&} (reciprocal) key also computes the
3494 inverse of a matrix.
3495
3496 @smallexample
3497 @group
3498 1: [ [ 1, 2, 3 ] 1: [ [ -2.4, 1.2, -0.2 ]
3499 [ 4, 5, 6 ] [ 2.8, -1.4, 0.4 ]
3500 [ 7, 6, 0 ] ] [ -0.73333, 0.53333, -0.2 ] ]
3501 . .
3502
3503 r 4 r 2 | s 5 &
3504 @end group
3505 @end smallexample
3506
3507 @noindent
3508 The vertical bar @kbd{|} @dfn{concatenates} numbers, vectors, and
3509 matrices together. Here we have used it to add a new row onto
3510 our matrix to make it square.
3511
3512 We can multiply these two matrices in either order to get an identity.
3513
3514 @smallexample
3515 @group
3516 1: [ [ 1., 0., 0. ] 1: [ [ 1., 0., 0. ]
3517 [ 0., 1., 0. ] [ 0., 1., 0. ]
3518 [ 0., 0., 1. ] ] [ 0., 0., 1. ] ]
3519 . .
3520
3521 M-@key{RET} * U @key{TAB} *
3522 @end group
3523 @end smallexample
3524
3525 @cindex Systems of linear equations
3526 @cindex Linear equations, systems of
3527 Matrix inverses are related to systems of linear equations in algebra.
3528 Suppose we had the following set of equations:
3529
3530 @ifinfo
3531 @group
3532 @example
3533 a + 2b + 3c = 6
3534 4a + 5b + 6c = 2
3535 7a + 6b = 3
3536 @end example
3537 @end group
3538 @end ifinfo
3539 @tex
3540 \turnoffactive
3541 \beforedisplayh
3542 $$ \openup1\jot \tabskip=0pt plus1fil
3543 \halign to\displaywidth{\tabskip=0pt
3544 $\hfil#$&$\hfil{}#{}$&
3545 $\hfil#$&$\hfil{}#{}$&
3546 $\hfil#$&${}#\hfil$\tabskip=0pt plus1fil\cr
3547 a&+&2b&+&3c&=6 \cr
3548 4a&+&5b&+&6c&=2 \cr
3549 7a&+&6b& & &=3 \cr}
3550 $$
3551 \afterdisplayh
3552 @end tex
3553
3554 @noindent
3555 This can be cast into the matrix equation,
3556
3557 @ifinfo
3558 @group
3559 @example
3560 [ [ 1, 2, 3 ] [ [ a ] [ [ 6 ]
3561 [ 4, 5, 6 ] * [ b ] = [ 2 ]
3562 [ 7, 6, 0 ] ] [ c ] ] [ 3 ] ]
3563 @end example
3564 @end group
3565 @end ifinfo
3566 @tex
3567 \turnoffactive
3568 \beforedisplay
3569 $$ \pmatrix{ 1 & 2 & 3 \cr 4 & 5 & 6 \cr 7 & 6 & 0 }
3570 \times
3571 \pmatrix{ a \cr b \cr c } = \pmatrix{ 6 \cr 2 \cr 3 }
3572 $$
3573 \afterdisplay
3574 @end tex
3575
3576 We can solve this system of equations by multiplying both sides by the
3577 inverse of the matrix. Calc can do this all in one step:
3578
3579 @smallexample
3580 @group
3581 2: [6, 2, 3] 1: [-12.6, 15.2, -3.93333]
3582 1: [ [ 1, 2, 3 ] .
3583 [ 4, 5, 6 ]
3584 [ 7, 6, 0 ] ]
3585 .
3586
3587 [6,2,3] r 5 /
3588 @end group
3589 @end smallexample
3590
3591 @noindent
3592 The result is the @expr{[a, b, c]} vector that solves the equations.
3593 (Dividing by a square matrix is equivalent to multiplying by its
3594 inverse.)
3595
3596 Let's verify this solution:
3597
3598 @smallexample
3599 @group
3600 2: [ [ 1, 2, 3 ] 1: [6., 2., 3.]
3601 [ 4, 5, 6 ] .
3602 [ 7, 6, 0 ] ]
3603 1: [-12.6, 15.2, -3.93333]
3604 .
3605
3606 r 5 @key{TAB} *
3607 @end group
3608 @end smallexample
3609
3610 @noindent
3611 Note that we had to be careful about the order in which we multiplied
3612 the matrix and vector. If we multiplied in the other order, Calc would
3613 assume the vector was a row vector in order to make the dimensions
3614 come out right, and the answer would be incorrect. If you
3615 don't feel safe letting Calc take either interpretation of your
3616 vectors, use explicit
3617 @texline @math{N\times1}
3618 @infoline Nx1
3619 or
3620 @texline @math{1\times N}
3621 @infoline 1xN
3622 matrices instead. In this case, you would enter the original column
3623 vector as @samp{[[6], [2], [3]]} or @samp{[6; 2; 3]}.
3624
3625 (@bullet{}) @strong{Exercise 2.} Algebraic entry allows you to make
3626 vectors and matrices that include variables. Solve the following
3627 system of equations to get expressions for @expr{x} and @expr{y}
3628 in terms of @expr{a} and @expr{b}.
3629
3630 @ifinfo
3631 @group
3632 @example
3633 x + a y = 6
3634 x + b y = 10
3635 @end example
3636 @end group
3637 @end ifinfo
3638 @tex
3639 \turnoffactive
3640 \beforedisplay
3641 $$ \eqalign{ x &+ a y = 6 \cr
3642 x &+ b y = 10}
3643 $$
3644 \afterdisplay
3645 @end tex
3646
3647 @noindent
3648 @xref{Matrix Answer 2, 2}. (@bullet{})
3649
3650 @cindex Least-squares for over-determined systems
3651 @cindex Over-determined systems of equations
3652 (@bullet{}) @strong{Exercise 3.} A system of equations is ``over-determined''
3653 if it has more equations than variables. It is often the case that
3654 there are no values for the variables that will satisfy all the
3655 equations at once, but it is still useful to find a set of values
3656 which ``nearly'' satisfy all the equations. In terms of matrix equations,
3657 you can't solve @expr{A X = B} directly because the matrix @expr{A}
3658 is not square for an over-determined system. Matrix inversion works
3659 only for square matrices. One common trick is to multiply both sides
3660 on the left by the transpose of @expr{A}:
3661 @ifinfo
3662 @samp{trn(A)*A*X = trn(A)*B}.
3663 @end ifinfo
3664 @tex
3665 \turnoffactive
3666 $A^T A \, X = A^T B$, where $A^T$ is the transpose \samp{trn(A)}.
3667 @end tex
3668 Now
3669 @texline @math{A^T A}
3670 @infoline @expr{trn(A)*A}
3671 is a square matrix so a solution is possible. It turns out that the
3672 @expr{X} vector you compute in this way will be a ``least-squares''
3673 solution, which can be regarded as the ``closest'' solution to the set
3674 of equations. Use Calc to solve the following over-determined
3675 system:
3676
3677 @ifinfo
3678 @group
3679 @example
3680 a + 2b + 3c = 6
3681 4a + 5b + 6c = 2
3682 7a + 6b = 3
3683 2a + 4b + 6c = 11
3684 @end example
3685 @end group
3686 @end ifinfo
3687 @tex
3688 \turnoffactive
3689 \beforedisplayh
3690 $$ \openup1\jot \tabskip=0pt plus1fil
3691 \halign to\displaywidth{\tabskip=0pt
3692 $\hfil#$&$\hfil{}#{}$&
3693 $\hfil#$&$\hfil{}#{}$&
3694 $\hfil#$&${}#\hfil$\tabskip=0pt plus1fil\cr
3695 a&+&2b&+&3c&=6 \cr
3696 4a&+&5b&+&6c&=2 \cr
3697 7a&+&6b& & &=3 \cr
3698 2a&+&4b&+&6c&=11 \cr}
3699 $$
3700 \afterdisplayh
3701 @end tex
3702
3703 @noindent
3704 @xref{Matrix Answer 3, 3}. (@bullet{})
3705
3706 @node List Tutorial, , Matrix Tutorial, Vector/Matrix Tutorial
3707 @subsection Vectors as Lists
3708
3709 @noindent
3710 @cindex Lists
3711 Although Calc has a number of features for manipulating vectors and
3712 matrices as mathematical objects, you can also treat vectors as
3713 simple lists of values. For example, we saw that the @kbd{k f}
3714 command returns a vector which is a list of the prime factors of a
3715 number.
3716
3717 You can pack and unpack stack entries into vectors:
3718
3719 @smallexample
3720 @group
3721 3: 10 1: [10, 20, 30] 3: 10
3722 2: 20 . 2: 20
3723 1: 30 1: 30
3724 . .
3725
3726 M-3 v p v u
3727 @end group
3728 @end smallexample
3729
3730 You can also build vectors out of consecutive integers, or out
3731 of many copies of a given value:
3732
3733 @smallexample
3734 @group
3735 1: [1, 2, 3, 4] 2: [1, 2, 3, 4] 2: [1, 2, 3, 4]
3736 . 1: 17 1: [17, 17, 17, 17]
3737 . .
3738
3739 v x 4 @key{RET} 17 v b 4 @key{RET}
3740 @end group
3741 @end smallexample
3742
3743 You can apply an operator to every element of a vector using the
3744 @dfn{map} command.
3745
3746 @smallexample
3747 @group
3748 1: [17, 34, 51, 68] 1: [289, 1156, 2601, 4624] 1: [17, 34, 51, 68]
3749 . . .
3750
3751 V M * 2 V M ^ V M Q
3752 @end group
3753 @end smallexample
3754
3755 @noindent
3756 In the first step, we multiply the vector of integers by the vector
3757 of 17's elementwise. In the second step, we raise each element to
3758 the power two. (The general rule is that both operands must be
3759 vectors of the same length, or else one must be a vector and the
3760 other a plain number.) In the final step, we take the square root
3761 of each element.
3762
3763 (@bullet{}) @strong{Exercise 1.} Compute a vector of powers of two
3764 from
3765 @texline @math{2^{-4}}
3766 @infoline @expr{2^-4}
3767 to @expr{2^4}. @xref{List Answer 1, 1}. (@bullet{})
3768
3769 You can also @dfn{reduce} a binary operator across a vector.
3770 For example, reducing @samp{*} computes the product of all the
3771 elements in the vector:
3772
3773 @smallexample
3774 @group
3775 1: 123123 1: [3, 7, 11, 13, 41] 1: 123123
3776 . . .
3777
3778 123123 k f V R *
3779 @end group
3780 @end smallexample
3781
3782 @noindent
3783 In this example, we decompose 123123 into its prime factors, then
3784 multiply those factors together again to yield the original number.
3785
3786 We could compute a dot product ``by hand'' using mapping and
3787 reduction:
3788
3789 @smallexample
3790 @group
3791 2: [1, 2, 3] 1: [7, 12, 0] 1: 19
3792 1: [7, 6, 0] . .
3793 .
3794
3795 r 1 r 2 V M * V R +
3796 @end group
3797 @end smallexample
3798
3799 @noindent
3800 Recalling two vectors from the previous section, we compute the
3801 sum of pairwise products of the elements to get the same answer
3802 for the dot product as before.
3803
3804 A slight variant of vector reduction is the @dfn{accumulate} operation,
3805 @kbd{V U}. This produces a vector of the intermediate results from
3806 a corresponding reduction. Here we compute a table of factorials:
3807
3808 @smallexample
3809 @group
3810 1: [1, 2, 3, 4, 5, 6] 1: [1, 2, 6, 24, 120, 720]
3811 . .
3812
3813 v x 6 @key{RET} V U *
3814 @end group
3815 @end smallexample
3816
3817 Calc allows vectors to grow as large as you like, although it gets
3818 rather slow if vectors have more than about a hundred elements.
3819 Actually, most of the time is spent formatting these large vectors
3820 for display, not calculating on them. Try the following experiment
3821 (if your computer is very fast you may need to substitute a larger
3822 vector size).
3823
3824 @smallexample
3825 @group
3826 1: [1, 2, 3, 4, ... 1: [2, 3, 4, 5, ...
3827 . .
3828
3829 v x 500 @key{RET} 1 V M +
3830 @end group
3831 @end smallexample
3832
3833 Now press @kbd{v .} (the letter @kbd{v}, then a period) and try the
3834 experiment again. In @kbd{v .} mode, long vectors are displayed
3835 ``abbreviated'' like this:
3836
3837 @smallexample
3838 @group
3839 1: [1, 2, 3, ..., 500] 1: [2, 3, 4, ..., 501]
3840 . .
3841
3842 v x 500 @key{RET} 1 V M +
3843 @end group
3844 @end smallexample
3845
3846 @noindent
3847 (where now the @samp{...} is actually part of the Calc display).
3848 You will find both operations are now much faster. But notice that
3849 even in @w{@kbd{v .}} mode, the full vectors are still shown in the Trail.
3850 Type @w{@kbd{t .}} to cause the trail to abbreviate as well, and try the
3851 experiment one more time. Operations on long vectors are now quite
3852 fast! (But of course if you use @kbd{t .} you will lose the ability
3853 to get old vectors back using the @kbd{t y} command.)
3854
3855 An easy way to view a full vector when @kbd{v .} mode is active is
3856 to press @kbd{`} (back-quote) to edit the vector; editing always works
3857 with the full, unabbreviated value.
3858
3859 @cindex Least-squares for fitting a straight line
3860 @cindex Fitting data to a line
3861 @cindex Line, fitting data to
3862 @cindex Data, extracting from buffers
3863 @cindex Columns of data, extracting
3864 As a larger example, let's try to fit a straight line to some data,
3865 using the method of least squares. (Calc has a built-in command for
3866 least-squares curve fitting, but we'll do it by hand here just to
3867 practice working with vectors.) Suppose we have the following list
3868 of values in a file we have loaded into Emacs:
3869
3870 @smallexample
3871 x y
3872 --- ---
3873 1.34 0.234
3874 1.41 0.298
3875 1.49 0.402
3876 1.56 0.412
3877 1.64 0.466
3878 1.73 0.473
3879 1.82 0.601
3880 1.91 0.519
3881 2.01 0.603
3882 2.11 0.637
3883 2.22 0.645
3884 2.33 0.705
3885 2.45 0.917
3886 2.58 1.009
3887 2.71 0.971
3888 2.85 1.062
3889 3.00 1.148
3890 3.15 1.157
3891 3.32 1.354
3892 @end smallexample
3893
3894 @noindent
3895 If you are reading this tutorial in printed form, you will find it
3896 easiest to press @kbd{M-# i} to enter the on-line Info version of
3897 the manual and find this table there. (Press @kbd{g}, then type
3898 @kbd{List Tutorial}, to jump straight to this section.)
3899
3900 Position the cursor at the upper-left corner of this table, just
3901 to the left of the @expr{1.34}. Press @kbd{C-@@} to set the mark.
3902 (On your system this may be @kbd{C-2}, @kbd{C-@key{SPC}}, or @kbd{NUL}.)
3903 Now position the cursor to the lower-right, just after the @expr{1.354}.
3904 You have now defined this region as an Emacs ``rectangle.'' Still
3905 in the Info buffer, type @kbd{M-# r}. This command
3906 (@code{calc-grab-rectangle}) will pop you back into the Calculator, with
3907 the contents of the rectangle you specified in the form of a matrix.
3908
3909 @smallexample
3910 @group
3911 1: [ [ 1.34, 0.234 ]
3912 [ 1.41, 0.298 ]
3913 @dots{}
3914 @end group
3915 @end smallexample
3916
3917 @noindent
3918 (You may wish to use @kbd{v .} mode to abbreviate the display of this
3919 large matrix.)
3920
3921 We want to treat this as a pair of lists. The first step is to
3922 transpose this matrix into a pair of rows. Remember, a matrix is
3923 just a vector of vectors. So we can unpack the matrix into a pair
3924 of row vectors on the stack.
3925
3926 @smallexample
3927 @group
3928 1: [ [ 1.34, 1.41, 1.49, ... ] 2: [1.34, 1.41, 1.49, ... ]
3929 [ 0.234, 0.298, 0.402, ... ] ] 1: [0.234, 0.298, 0.402, ... ]
3930 . .
3931
3932 v t v u
3933 @end group
3934 @end smallexample
3935
3936 @noindent
3937 Let's store these in quick variables 1 and 2, respectively.
3938
3939 @smallexample
3940 @group
3941 1: [1.34, 1.41, 1.49, ... ] .
3942 .
3943
3944 t 2 t 1
3945 @end group
3946 @end smallexample
3947
3948 @noindent
3949 (Recall that @kbd{t 2} is a variant of @kbd{s 2} that removes the
3950 stored value from the stack.)
3951
3952 In a least squares fit, the slope @expr{m} is given by the formula
3953
3954 @ifinfo
3955 @example
3956 m = (N sum(x y) - sum(x) sum(y)) / (N sum(x^2) - sum(x)^2)
3957 @end example
3958 @end ifinfo
3959 @tex
3960 \turnoffactive
3961 \beforedisplay
3962 $$ m = {N \sum x y - \sum x \sum y \over
3963 N \sum x^2 - \left( \sum x \right)^2} $$
3964 \afterdisplay
3965 @end tex
3966
3967 @noindent
3968 where
3969 @texline @math{\sum x}
3970 @infoline @expr{sum(x)}
3971 represents the sum of all the values of @expr{x}. While there is an
3972 actual @code{sum} function in Calc, it's easier to sum a vector using a
3973 simple reduction. First, let's compute the four different sums that
3974 this formula uses.
3975
3976 @smallexample
3977 @group
3978 1: 41.63 1: 98.0003
3979 . .
3980
3981 r 1 V R + t 3 r 1 2 V M ^ V R + t 4
3982
3983 @end group
3984 @end smallexample
3985 @noindent
3986 @smallexample
3987 @group
3988 1: 13.613 1: 33.36554
3989 . .
3990
3991 r 2 V R + t 5 r 1 r 2 V M * V R + t 6
3992 @end group
3993 @end smallexample
3994
3995 @ifinfo
3996 @noindent
3997 These are @samp{sum(x)}, @samp{sum(x^2)}, @samp{sum(y)}, and @samp{sum(x y)},
3998 respectively. (We could have used @kbd{*} to compute @samp{sum(x^2)} and
3999 @samp{sum(x y)}.)
4000 @end ifinfo
4001 @tex
4002 \turnoffactive
4003 These are $\sum x$, $\sum x^2$, $\sum y$, and $\sum x y$,
4004 respectively. (We could have used \kbd{*} to compute $\sum x^2$ and
4005 $\sum x y$.)
4006 @end tex
4007
4008 Finally, we also need @expr{N}, the number of data points. This is just
4009 the length of either of our lists.
4010
4011 @smallexample
4012 @group
4013 1: 19
4014 .
4015
4016 r 1 v l t 7
4017 @end group
4018 @end smallexample
4019
4020 @noindent
4021 (That's @kbd{v} followed by a lower-case @kbd{l}.)
4022
4023 Now we grind through the formula:
4024
4025 @smallexample
4026 @group
4027 1: 633.94526 2: 633.94526 1: 67.23607
4028 . 1: 566.70919 .
4029 .
4030
4031 r 7 r 6 * r 3 r 5 * -
4032
4033 @end group
4034 @end smallexample
4035 @noindent
4036 @smallexample
4037 @group
4038 2: 67.23607 3: 67.23607 2: 67.23607 1: 0.52141679
4039 1: 1862.0057 2: 1862.0057 1: 128.9488 .
4040 . 1: 1733.0569 .
4041 .
4042
4043 r 7 r 4 * r 3 2 ^ - / t 8
4044 @end group
4045 @end smallexample
4046
4047 That gives us the slope @expr{m}. The y-intercept @expr{b} can now
4048 be found with the simple formula,
4049
4050 @ifinfo
4051 @example
4052 b = (sum(y) - m sum(x)) / N
4053 @end example
4054 @end ifinfo
4055 @tex
4056 \turnoffactive
4057 \beforedisplay
4058 $$ b = {\sum y - m \sum x \over N} $$
4059 \afterdisplay
4060 \vskip10pt
4061 @end tex
4062
4063 @smallexample
4064 @group
4065 1: 13.613 2: 13.613 1: -8.09358 1: -0.425978
4066 . 1: 21.70658 . .
4067 .
4068
4069 r 5 r 8 r 3 * - r 7 / t 9
4070 @end group
4071 @end smallexample
4072
4073 Let's ``plot'' this straight line approximation,
4074 @texline @math{y \approx m x + b},
4075 @infoline @expr{m x + b},
4076 and compare it with the original data.
4077
4078 @smallexample
4079 @group
4080 1: [0.699, 0.735, ... ] 1: [0.273, 0.309, ... ]
4081 . .
4082
4083 r 1 r 8 * r 9 + s 0
4084 @end group
4085 @end smallexample
4086
4087 @noindent
4088 Notice that multiplying a vector by a constant, and adding a constant
4089 to a vector, can be done without mapping commands since these are
4090 common operations from vector algebra. As far as Calc is concerned,
4091 we've just been doing geometry in 19-dimensional space!
4092
4093 We can subtract this vector from our original @expr{y} vector to get
4094 a feel for the error of our fit. Let's find the maximum error:
4095
4096 @smallexample
4097 @group
4098 1: [0.0387, 0.0112, ... ] 1: [0.0387, 0.0112, ... ] 1: 0.0897
4099 . . .
4100
4101 r 2 - V M A V R X
4102 @end group
4103 @end smallexample
4104
4105 @noindent
4106 First we compute a vector of differences, then we take the absolute
4107 values of these differences, then we reduce the @code{max} function
4108 across the vector. (The @code{max} function is on the two-key sequence
4109 @kbd{f x}; because it is so common to use @code{max} in a vector
4110 operation, the letters @kbd{X} and @kbd{N} are also accepted for
4111 @code{max} and @code{min} in this context. In general, you answer
4112 the @kbd{V M} or @kbd{V R} prompt with the actual key sequence that
4113 invokes the function you want. You could have typed @kbd{V R f x} or
4114 even @kbd{V R x max @key{RET}} if you had preferred.)
4115
4116 If your system has the GNUPLOT program, you can see graphs of your
4117 data and your straight line to see how well they match. (If you have
4118 GNUPLOT 3.0, the following instructions will work regardless of the
4119 kind of display you have. Some GNUPLOT 2.0, non-X-windows systems
4120 may require additional steps to view the graphs.)
4121
4122 Let's start by plotting the original data. Recall the ``@var{x}'' and ``@var{y}''
4123 vectors onto the stack and press @kbd{g f}. This ``fast'' graphing
4124 command does everything you need to do for simple, straightforward
4125 plotting of data.
4126
4127 @smallexample
4128 @group
4129 2: [1.34, 1.41, 1.49, ... ]
4130 1: [0.234, 0.298, 0.402, ... ]
4131 .
4132
4133 r 1 r 2 g f
4134 @end group
4135 @end smallexample
4136
4137 If all goes well, you will shortly get a new window containing a graph
4138 of the data. (If not, contact your GNUPLOT or Calc installer to find
4139 out what went wrong.) In the X window system, this will be a separate
4140 graphics window. For other kinds of displays, the default is to
4141 display the graph in Emacs itself using rough character graphics.
4142 Press @kbd{q} when you are done viewing the character graphics.
4143
4144 Next, let's add the line we got from our least-squares fit.
4145 @ifinfo
4146 (If you are reading this tutorial on-line while running Calc, typing
4147 @kbd{g a} may cause the tutorial to disappear from its window and be
4148 replaced by a buffer named @samp{*Gnuplot Commands*}. The tutorial
4149 will reappear when you terminate GNUPLOT by typing @kbd{g q}.)
4150 @end ifinfo
4151
4152 @smallexample
4153 @group
4154 2: [1.34, 1.41, 1.49, ... ]
4155 1: [0.273, 0.309, 0.351, ... ]
4156 .
4157
4158 @key{DEL} r 0 g a g p
4159 @end group
4160 @end smallexample
4161
4162 It's not very useful to get symbols to mark the data points on this
4163 second curve; you can type @kbd{g S g p} to remove them. Type @kbd{g q}
4164 when you are done to remove the X graphics window and terminate GNUPLOT.
4165
4166 (@bullet{}) @strong{Exercise 2.} An earlier exercise showed how to do
4167 least squares fitting to a general system of equations. Our 19 data
4168 points are really 19 equations of the form @expr{y_i = m x_i + b} for
4169 different pairs of @expr{(x_i,y_i)}. Use the matrix-transpose method
4170 to solve for @expr{m} and @expr{b}, duplicating the above result.
4171 @xref{List Answer 2, 2}. (@bullet{})
4172
4173 @cindex Geometric mean
4174 (@bullet{}) @strong{Exercise 3.} If the input data do not form a
4175 rectangle, you can use @w{@kbd{M-# g}} (@code{calc-grab-region})
4176 to grab the data the way Emacs normally works with regions---it reads
4177 left-to-right, top-to-bottom, treating line breaks the same as spaces.
4178 Use this command to find the geometric mean of the following numbers.
4179 (The geometric mean is the @var{n}th root of the product of @var{n} numbers.)
4180
4181 @example
4182 2.3 6 22 15.1 7
4183 15 14 7.5
4184 2.5
4185 @end example
4186
4187 @noindent
4188 The @kbd{M-# g} command accepts numbers separated by spaces or commas,
4189 with or without surrounding vector brackets.
4190 @xref{List Answer 3, 3}. (@bullet{})
4191
4192 @ifinfo
4193 As another example, a theorem about binomial coefficients tells
4194 us that the alternating sum of binomial coefficients
4195 @var{n}-choose-0 minus @var{n}-choose-1 plus @var{n}-choose-2, and so
4196 on up to @var{n}-choose-@var{n},
4197 always comes out to zero. Let's verify this
4198 for @expr{n=6}.
4199 @end ifinfo
4200 @tex
4201 As another example, a theorem about binomial coefficients tells
4202 us that the alternating sum of binomial coefficients
4203 ${n \choose 0} - {n \choose 1} + {n \choose 2} - \cdots \pm {n \choose n}$
4204 always comes out to zero. Let's verify this
4205 for \cite{n=6}.
4206 @end tex
4207
4208 @smallexample
4209 @group
4210 1: [1, 2, 3, 4, 5, 6, 7] 1: [0, 1, 2, 3, 4, 5, 6]
4211 . .
4212
4213 v x 7 @key{RET} 1 -
4214
4215 @end group
4216 @end smallexample
4217 @noindent
4218 @smallexample
4219 @group
4220 1: [1, -6, 15, -20, 15, -6, 1] 1: 0
4221 . .
4222
4223 V M ' (-1)^$ choose(6,$) @key{RET} V R +
4224 @end group
4225 @end smallexample
4226
4227 The @kbd{V M '} command prompts you to enter any algebraic expression
4228 to define the function to map over the vector. The symbol @samp{$}
4229 inside this expression represents the argument to the function.
4230 The Calculator applies this formula to each element of the vector,
4231 substituting each element's value for the @samp{$} sign(s) in turn.
4232
4233 To define a two-argument function, use @samp{$$} for the first
4234 argument and @samp{$} for the second: @kbd{V M ' $$-$ @key{RET}} is
4235 equivalent to @kbd{V M -}. This is analogous to regular algebraic
4236 entry, where @samp{$$} would refer to the next-to-top stack entry
4237 and @samp{$} would refer to the top stack entry, and @kbd{' $$-$ @key{RET}}
4238 would act exactly like @kbd{-}.
4239
4240 Notice that the @kbd{V M '} command has recorded two things in the
4241 trail: The result, as usual, and also a funny-looking thing marked
4242 @samp{oper} that represents the operator function you typed in.
4243 The function is enclosed in @samp{< >} brackets, and the argument is
4244 denoted by a @samp{#} sign. If there were several arguments, they
4245 would be shown as @samp{#1}, @samp{#2}, and so on. (For example,
4246 @kbd{V M ' $$-$} will put the function @samp{<#1 - #2>} on the
4247 trail.) This object is a ``nameless function''; you can use nameless
4248 @w{@samp{< >}} notation to answer the @kbd{V M '} prompt if you like.
4249 Nameless function notation has the interesting, occasionally useful
4250 property that a nameless function is not actually evaluated until
4251 it is used. For example, @kbd{V M ' $+random(2.0)} evaluates
4252 @samp{random(2.0)} once and adds that random number to all elements
4253 of the vector, but @kbd{V M ' <#+random(2.0)>} evaluates the
4254 @samp{random(2.0)} separately for each vector element.
4255
4256 Another group of operators that are often useful with @kbd{V M} are
4257 the relational operators: @kbd{a =}, for example, compares two numbers
4258 and gives the result 1 if they are equal, or 0 if not. Similarly,
4259 @w{@kbd{a <}} checks for one number being less than another.
4260
4261 Other useful vector operations include @kbd{v v}, to reverse a
4262 vector end-for-end; @kbd{V S}, to sort the elements of a vector
4263 into increasing order; and @kbd{v r} and @w{@kbd{v c}}, to extract
4264 one row or column of a matrix, or (in both cases) to extract one
4265 element of a plain vector. With a negative argument, @kbd{v r}
4266 and @kbd{v c} instead delete one row, column, or vector element.
4267
4268 @cindex Divisor functions
4269 (@bullet{}) @strong{Exercise 4.} The @expr{k}th @dfn{divisor function}
4270 @tex
4271 $\sigma_k(n)$
4272 @end tex
4273 is the sum of the @expr{k}th powers of all the divisors of an
4274 integer @expr{n}. Figure out a method for computing the divisor
4275 function for reasonably small values of @expr{n}. As a test,
4276 the 0th and 1st divisor functions of 30 are 8 and 72, respectively.
4277 @xref{List Answer 4, 4}. (@bullet{})
4278
4279 @cindex Square-free numbers
4280 @cindex Duplicate values in a list
4281 (@bullet{}) @strong{Exercise 5.} The @kbd{k f} command produces a
4282 list of prime factors for a number. Sometimes it is important to
4283 know that a number is @dfn{square-free}, i.e., that no prime occurs
4284 more than once in its list of prime factors. Find a sequence of
4285 keystrokes to tell if a number is square-free; your method should
4286 leave 1 on the stack if it is, or 0 if it isn't.
4287 @xref{List Answer 5, 5}. (@bullet{})
4288
4289 @cindex Triangular lists
4290 (@bullet{}) @strong{Exercise 6.} Build a list of lists that looks
4291 like the following diagram. (You may wish to use the @kbd{v /}
4292 command to enable multi-line display of vectors.)
4293
4294 @smallexample
4295 @group
4296 1: [ [1],
4297 [1, 2],
4298 [1, 2, 3],
4299 [1, 2, 3, 4],
4300 [1, 2, 3, 4, 5],
4301 [1, 2, 3, 4, 5, 6] ]
4302 @end group
4303 @end smallexample
4304
4305 @noindent
4306 @xref{List Answer 6, 6}. (@bullet{})
4307
4308 (@bullet{}) @strong{Exercise 7.} Build the following list of lists.
4309
4310 @smallexample
4311 @group
4312 1: [ [0],
4313 [1, 2],
4314 [3, 4, 5],
4315 [6, 7, 8, 9],
4316 [10, 11, 12, 13, 14],
4317 [15, 16, 17, 18, 19, 20] ]
4318 @end group
4319 @end smallexample
4320
4321 @noindent
4322 @xref{List Answer 7, 7}. (@bullet{})
4323
4324 @cindex Maximizing a function over a list of values
4325 @c [fix-ref Numerical Solutions]
4326 (@bullet{}) @strong{Exercise 8.} Compute a list of values of Bessel's
4327 @texline @math{J_1(x)}
4328 @infoline @expr{J1}
4329 function @samp{besJ(1,x)} for @expr{x} from 0 to 5 in steps of 0.25.
4330 Find the value of @expr{x} (from among the above set of values) for
4331 which @samp{besJ(1,x)} is a maximum. Use an ``automatic'' method,
4332 i.e., just reading along the list by hand to find the largest value
4333 is not allowed! (There is an @kbd{a X} command which does this kind
4334 of thing automatically; @pxref{Numerical Solutions}.)
4335 @xref{List Answer 8, 8}. (@bullet{})
4336
4337 @cindex Digits, vectors of
4338 (@bullet{}) @strong{Exercise 9.} You are given an integer in the range
4339 @texline @math{0 \le N < 10^m}
4340 @infoline @expr{0 <= N < 10^m}
4341 for @expr{m=12} (i.e., an integer of less than
4342 twelve digits). Convert this integer into a vector of @expr{m}
4343 digits, each in the range from 0 to 9. In vector-of-digits notation,
4344 add one to this integer to produce a vector of @expr{m+1} digits
4345 (since there could be a carry out of the most significant digit).
4346 Convert this vector back into a regular integer. A good integer
4347 to try is 25129925999. @xref{List Answer 9, 9}. (@bullet{})
4348
4349 (@bullet{}) @strong{Exercise 10.} Your friend Joe tried to use
4350 @kbd{V R a =} to test if all numbers in a list were equal. What
4351 happened? How would you do this test? @xref{List Answer 10, 10}. (@bullet{})
4352
4353 (@bullet{}) @strong{Exercise 11.} The area of a circle of radius one
4354 is @cpi{}. The area of the
4355 @texline @math{2\times2}
4356 @infoline 2x2
4357 square that encloses that circle is 4. So if we throw @var{n} darts at
4358 random points in the square, about @cpiover{4} of them will land inside
4359 the circle. This gives us an entertaining way to estimate the value of
4360 @cpi{}. The @w{@kbd{k r}}
4361 command picks a random number between zero and the value on the stack.
4362 We could get a random floating-point number between @mathit{-1} and 1 by typing
4363 @w{@kbd{2.0 k r 1 -}}. Build a vector of 100 random @expr{(x,y)} points in
4364 this square, then use vector mapping and reduction to count how many
4365 points lie inside the unit circle. Hint: Use the @kbd{v b} command.
4366 @xref{List Answer 11, 11}. (@bullet{})
4367
4368 @cindex Matchstick problem
4369 (@bullet{}) @strong{Exercise 12.} The @dfn{matchstick problem} provides
4370 another way to calculate @cpi{}. Say you have an infinite field
4371 of vertical lines with a spacing of one inch. Toss a one-inch matchstick
4372 onto the field. The probability that the matchstick will land crossing
4373 a line turns out to be
4374 @texline @math{2/\pi}.
4375 @infoline @expr{2/pi}.
4376 Toss 100 matchsticks to estimate @cpi{}. (If you want still more fun,
4377 the probability that the GCD (@w{@kbd{k g}}) of two large integers is
4378 one turns out to be
4379 @texline @math{6/\pi^2}.
4380 @infoline @expr{6/pi^2}.
4381 That provides yet another way to estimate @cpi{}.)
4382 @xref{List Answer 12, 12}. (@bullet{})
4383
4384 (@bullet{}) @strong{Exercise 13.} An algebraic entry of a string in
4385 double-quote marks, @samp{"hello"}, creates a vector of the numerical
4386 (ASCII) codes of the characters (here, @expr{[104, 101, 108, 108, 111]}).
4387 Sometimes it is convenient to compute a @dfn{hash code} of a string,
4388 which is just an integer that represents the value of that string.
4389 Two equal strings have the same hash code; two different strings
4390 @dfn{probably} have different hash codes. (For example, Calc has
4391 over 400 function names, but Emacs can quickly find the definition for
4392 any given name because it has sorted the functions into ``buckets'' by
4393 their hash codes. Sometimes a few names will hash into the same bucket,
4394 but it is easier to search among a few names than among all the names.)
4395 One popular hash function is computed as follows: First set @expr{h = 0}.
4396 Then, for each character from the string in turn, set @expr{h = 3h + c_i}
4397 where @expr{c_i} is the character's ASCII code. If we have 511 buckets,
4398 we then take the hash code modulo 511 to get the bucket number. Develop a
4399 simple command or commands for converting string vectors into hash codes.
4400 The hash code for @samp{"Testing, 1, 2, 3"} is 1960915098, which modulo
4401 511 is 121. @xref{List Answer 13, 13}. (@bullet{})
4402
4403 (@bullet{}) @strong{Exercise 14.} The @kbd{H V R} and @kbd{H V U}
4404 commands do nested function evaluations. @kbd{H V U} takes a starting
4405 value and a number of steps @var{n} from the stack; it then applies the
4406 function you give to the starting value 0, 1, 2, up to @var{n} times
4407 and returns a vector of the results. Use this command to create a
4408 ``random walk'' of 50 steps. Start with the two-dimensional point
4409 @expr{(0,0)}; then take one step a random distance between @mathit{-1} and 1
4410 in both @expr{x} and @expr{y}; then take another step, and so on. Use the
4411 @kbd{g f} command to display this random walk. Now modify your random
4412 walk to walk a unit distance, but in a random direction, at each step.
4413 (Hint: The @code{sincos} function returns a vector of the cosine and
4414 sine of an angle.) @xref{List Answer 14, 14}. (@bullet{})
4415
4416 @node Types Tutorial, Algebra Tutorial, Vector/Matrix Tutorial, Tutorial
4417 @section Types Tutorial
4418
4419 @noindent
4420 Calc understands a variety of data types as well as simple numbers.
4421 In this section, we'll experiment with each of these types in turn.
4422
4423 The numbers we've been using so far have mainly been either @dfn{integers}
4424 or @dfn{floats}. We saw that floats are usually a good approximation to
4425 the mathematical concept of real numbers, but they are only approximations
4426 and are susceptible to roundoff error. Calc also supports @dfn{fractions},
4427 which can exactly represent any rational number.
4428
4429 @smallexample
4430 @group
4431 1: 3628800 2: 3628800 1: 518400:7 1: 518414:7 1: 7:518414
4432 . 1: 49 . . .
4433 .
4434
4435 10 ! 49 @key{RET} : 2 + &
4436 @end group
4437 @end smallexample
4438
4439 @noindent
4440 The @kbd{:} command divides two integers to get a fraction; @kbd{/}
4441 would normally divide integers to get a floating-point result.
4442 Notice we had to type @key{RET} between the @kbd{49} and the @kbd{:}
4443 since the @kbd{:} would otherwise be interpreted as part of a
4444 fraction beginning with 49.
4445
4446 You can convert between floating-point and fractional format using
4447 @kbd{c f} and @kbd{c F}:
4448
4449 @smallexample
4450 @group
4451 1: 1.35027217629e-5 1: 7:518414
4452 . .
4453
4454 c f c F
4455 @end group
4456 @end smallexample
4457
4458 The @kbd{c F} command replaces a floating-point number with the
4459 ``simplest'' fraction whose floating-point representation is the
4460 same, to within the current precision.
4461
4462 @smallexample
4463 @group
4464 1: 3.14159265359 1: 1146408:364913 1: 3.1416 1: 355:113
4465 . . . .
4466
4467 P c F @key{DEL} p 5 @key{RET} P c F
4468 @end group
4469 @end smallexample
4470
4471 (@bullet{}) @strong{Exercise 1.} A calculation has produced the
4472 result 1.26508260337. You suspect it is the square root of the
4473 product of @cpi{} and some rational number. Is it? (Be sure
4474 to allow for roundoff error!) @xref{Types Answer 1, 1}. (@bullet{})
4475
4476 @dfn{Complex numbers} can be stored in both rectangular and polar form.
4477
4478 @smallexample
4479 @group
4480 1: -9 1: (0, 3) 1: (3; 90.) 1: (6; 90.) 1: (2.4495; 45.)
4481 . . . . .
4482
4483 9 n Q c p 2 * Q
4484 @end group
4485 @end smallexample
4486
4487 @noindent
4488 The square root of @mathit{-9} is by default rendered in rectangular form
4489 (@w{@expr{0 + 3i}}), but we can convert it to polar form (3 with a
4490 phase angle of 90 degrees). All the usual arithmetic and scientific
4491 operations are defined on both types of complex numbers.
4492
4493 Another generalized kind of number is @dfn{infinity}. Infinity
4494 isn't really a number, but it can sometimes be treated like one.
4495 Calc uses the symbol @code{inf} to represent positive infinity,
4496 i.e., a value greater than any real number. Naturally, you can
4497 also write @samp{-inf} for minus infinity, a value less than any
4498 real number. The word @code{inf} can only be input using
4499 algebraic entry.
4500
4501 @smallexample
4502 @group
4503 2: inf 2: -inf 2: -inf 2: -inf 1: nan
4504 1: -17 1: -inf 1: -inf 1: inf .
4505 . . . .
4506
4507 ' inf @key{RET} 17 n * @key{RET} 72 + A +
4508 @end group
4509 @end smallexample
4510
4511 @noindent
4512 Since infinity is infinitely large, multiplying it by any finite
4513 number (like @mathit{-17}) has no effect, except that since @mathit{-17}
4514 is negative, it changes a plus infinity to a minus infinity.
4515 (``A huge positive number, multiplied by @mathit{-17}, yields a huge
4516 negative number.'') Adding any finite number to infinity also
4517 leaves it unchanged. Taking an absolute value gives us plus
4518 infinity again. Finally, we add this plus infinity to the minus
4519 infinity we had earlier. If you work it out, you might expect
4520 the answer to be @mathit{-72} for this. But the 72 has been completely
4521 lost next to the infinities; by the time we compute @w{@samp{inf - inf}}
4522 the finite difference between them, if any, is undetectable.
4523 So we say the result is @dfn{indeterminate}, which Calc writes
4524 with the symbol @code{nan} (for Not A Number).
4525
4526 Dividing by zero is normally treated as an error, but you can get
4527 Calc to write an answer in terms of infinity by pressing @kbd{m i}
4528 to turn on Infinite mode.
4529
4530 @smallexample
4531 @group
4532 3: nan 2: nan 2: nan 2: nan 1: nan
4533 2: 1 1: 1 / 0 1: uinf 1: uinf .
4534 1: 0 . . .
4535 .
4536
4537 1 @key{RET} 0 / m i U / 17 n * +
4538 @end group
4539 @end smallexample
4540
4541 @noindent
4542 Dividing by zero normally is left unevaluated, but after @kbd{m i}
4543 it instead gives an infinite result. The answer is actually
4544 @code{uinf}, ``undirected infinity.'' If you look at a graph of
4545 @expr{1 / x} around @w{@expr{x = 0}}, you'll see that it goes toward
4546 plus infinity as you approach zero from above, but toward minus
4547 infinity as you approach from below. Since we said only @expr{1 / 0},
4548 Calc knows that the answer is infinite but not in which direction.
4549 That's what @code{uinf} means. Notice that multiplying @code{uinf}
4550 by a negative number still leaves plain @code{uinf}; there's no
4551 point in saying @samp{-uinf} because the sign of @code{uinf} is
4552 unknown anyway. Finally, we add @code{uinf} to our @code{nan},
4553 yielding @code{nan} again. It's easy to see that, because
4554 @code{nan} means ``totally unknown'' while @code{uinf} means
4555 ``unknown sign but known to be infinite,'' the more mysterious
4556 @code{nan} wins out when it is combined with @code{uinf}, or, for
4557 that matter, with anything else.
4558
4559 (@bullet{}) @strong{Exercise 2.} Predict what Calc will answer
4560 for each of these formulas: @samp{inf / inf}, @samp{exp(inf)},
4561 @samp{exp(-inf)}, @samp{sqrt(-inf)}, @samp{sqrt(uinf)},
4562 @samp{abs(uinf)}, @samp{ln(0)}.
4563 @xref{Types Answer 2, 2}. (@bullet{})
4564
4565 (@bullet{}) @strong{Exercise 3.} We saw that @samp{inf - inf = nan},
4566 which stands for an unknown value. Can @code{nan} stand for
4567 a complex number? Can it stand for infinity?
4568 @xref{Types Answer 3, 3}. (@bullet{})
4569
4570 @dfn{HMS forms} represent a value in terms of hours, minutes, and
4571 seconds.
4572
4573 @smallexample
4574 @group
4575 1: 2@@ 30' 0" 1: 3@@ 30' 0" 2: 3@@ 30' 0" 1: 2.
4576 . . 1: 1@@ 45' 0." .
4577 .
4578
4579 2@@ 30' @key{RET} 1 + @key{RET} 2 / /
4580 @end group
4581 @end smallexample
4582
4583 HMS forms can also be used to hold angles in degrees, minutes, and
4584 seconds.
4585
4586 @smallexample
4587 @group
4588 1: 0.5 1: 26.56505 1: 26@@ 33' 54.18" 1: 0.44721
4589 . . . .
4590
4591 0.5 I T c h S
4592 @end group
4593 @end smallexample
4594
4595 @noindent
4596 First we convert the inverse tangent of 0.5 to degrees-minutes-seconds
4597 form, then we take the sine of that angle. Note that the trigonometric
4598 functions will accept HMS forms directly as input.
4599
4600 @cindex Beatles
4601 (@bullet{}) @strong{Exercise 4.} The Beatles' @emph{Abbey Road} is
4602 47 minutes and 26 seconds long, and contains 17 songs. What is the
4603 average length of a song on @emph{Abbey Road}? If the Extended Disco
4604 Version of @emph{Abbey Road} added 20 seconds to the length of each
4605 song, how long would the album be? @xref{Types Answer 4, 4}. (@bullet{})
4606
4607 A @dfn{date form} represents a date, or a date and time. Dates must
4608 be entered using algebraic entry. Date forms are surrounded by
4609 @samp{< >} symbols; most standard formats for dates are recognized.
4610
4611 @smallexample
4612 @group
4613 2: <Sun Jan 13, 1991> 1: 2.25
4614 1: <6:00pm Thu Jan 10, 1991> .
4615 .
4616
4617 ' <13 Jan 1991>, <1/10/91, 6pm> @key{RET} -
4618 @end group
4619 @end smallexample
4620
4621 @noindent
4622 In this example, we enter two dates, then subtract to find the
4623 number of days between them. It is also possible to add an
4624 HMS form or a number (of days) to a date form to get another
4625 date form.
4626
4627 @smallexample
4628 @group
4629 1: <4:45:59pm Mon Jan 14, 1991> 1: <2:50:59am Thu Jan 17, 1991>
4630 . .
4631
4632 t N 2 + 10@@ 5' +
4633 @end group
4634 @end smallexample
4635
4636 @c [fix-ref Date Arithmetic]
4637 @noindent
4638 The @kbd{t N} (``now'') command pushes the current date and time on the
4639 stack; then we add two days, ten hours and five minutes to the date and
4640 time. Other date-and-time related commands include @kbd{t J}, which
4641 does Julian day conversions, @kbd{t W}, which finds the beginning of
4642 the week in which a date form lies, and @kbd{t I}, which increments a
4643 date by one or several months. @xref{Date Arithmetic}, for more.
4644
4645 (@bullet{}) @strong{Exercise 5.} How many days until the next
4646 Friday the 13th? @xref{Types Answer 5, 5}. (@bullet{})
4647
4648 (@bullet{}) @strong{Exercise 6.} How many leap years will there be
4649 between now and the year 10001 A.D.? @xref{Types Answer 6, 6}. (@bullet{})
4650
4651 @cindex Slope and angle of a line
4652 @cindex Angle and slope of a line
4653 An @dfn{error form} represents a mean value with an attached standard
4654 deviation, or error estimate. Suppose our measurements indicate that
4655 a certain telephone pole is about 30 meters away, with an estimated
4656 error of 1 meter, and 8 meters tall, with an estimated error of 0.2
4657 meters. What is the slope of a line from here to the top of the
4658 pole, and what is the equivalent angle in degrees?
4659
4660 @smallexample
4661 @group
4662 1: 8 +/- 0.2 2: 8 +/- 0.2 1: 0.266 +/- 0.011 1: 14.93 +/- 0.594
4663 . 1: 30 +/- 1 . .
4664 .
4665
4666 8 p .2 @key{RET} 30 p 1 / I T
4667 @end group
4668 @end smallexample
4669
4670 @noindent
4671 This means that the angle is about 15 degrees, and, assuming our
4672 original error estimates were valid standard deviations, there is about
4673 a 60% chance that the result is correct within 0.59 degrees.
4674
4675 @cindex Torus, volume of
4676 (@bullet{}) @strong{Exercise 7.} The volume of a torus (a donut shape) is
4677 @texline @math{2 \pi^2 R r^2}
4678 @infoline @w{@expr{2 pi^2 R r^2}}
4679 where @expr{R} is the radius of the circle that
4680 defines the center of the tube and @expr{r} is the radius of the tube
4681 itself. Suppose @expr{R} is 20 cm and @expr{r} is 4 cm, each known to
4682 within 5 percent. What is the volume and the relative uncertainty of
4683 the volume? @xref{Types Answer 7, 7}. (@bullet{})
4684
4685 An @dfn{interval form} represents a range of values. While an
4686 error form is best for making statistical estimates, intervals give
4687 you exact bounds on an answer. Suppose we additionally know that
4688 our telephone pole is definitely between 28 and 31 meters away,
4689 and that it is between 7.7 and 8.1 meters tall.
4690
4691 @smallexample
4692 @group
4693 1: [7.7 .. 8.1] 2: [7.7 .. 8.1] 1: [0.24 .. 0.28] 1: [13.9 .. 16.1]
4694 . 1: [28 .. 31] . .
4695 .
4696
4697 [ 7.7 .. 8.1 ] [ 28 .. 31 ] / I T
4698 @end group
4699 @end smallexample
4700
4701 @noindent
4702 If our bounds were correct, then the angle to the top of the pole
4703 is sure to lie in the range shown.
4704
4705 The square brackets around these intervals indicate that the endpoints
4706 themselves are allowable values. In other words, the distance to the
4707 telephone pole is between 28 and 31, @emph{inclusive}. You can also
4708 make an interval that is exclusive of its endpoints by writing
4709 parentheses instead of square brackets. You can even make an interval
4710 which is inclusive (``closed'') on one end and exclusive (``open'') on
4711 the other.
4712
4713 @smallexample
4714 @group
4715 1: [1 .. 10) 1: (0.1 .. 1] 2: (0.1 .. 1] 1: (0.2 .. 3)
4716 . . 1: [2 .. 3) .
4717 .
4718
4719 [ 1 .. 10 ) & [ 2 .. 3 ) *
4720 @end group
4721 @end smallexample
4722
4723 @noindent
4724 The Calculator automatically keeps track of which end values should
4725 be open and which should be closed. You can also make infinite or
4726 semi-infinite intervals by using @samp{-inf} or @samp{inf} for one
4727 or both endpoints.
4728
4729 (@bullet{}) @strong{Exercise 8.} What answer would you expect from
4730 @samp{@w{1 /} @w{(0 .. 10)}}? What about @samp{@w{1 /} @w{(-10 .. 0)}}? What
4731 about @samp{@w{1 /} @w{[0 .. 10]}} (where the interval actually includes
4732 zero)? What about @samp{@w{1 /} @w{(-10 .. 10)}}?
4733 @xref{Types Answer 8, 8}. (@bullet{})
4734
4735 (@bullet{}) @strong{Exercise 9.} Two easy ways of squaring a number
4736 are @kbd{@key{RET} *} and @w{@kbd{2 ^}}. Normally these produce the same
4737 answer. Would you expect this still to hold true for interval forms?
4738 If not, which of these will result in a larger interval?
4739 @xref{Types Answer 9, 9}. (@bullet{})
4740
4741 A @dfn{modulo form} is used for performing arithmetic modulo @var{m}.
4742 For example, arithmetic involving time is generally done modulo 12
4743 or 24 hours.
4744
4745 @smallexample
4746 @group
4747 1: 17 mod 24 1: 3 mod 24 1: 21 mod 24 1: 9 mod 24
4748 . . . .
4749
4750 17 M 24 @key{RET} 10 + n 5 /
4751 @end group
4752 @end smallexample
4753
4754 @noindent
4755 In this last step, Calc has divided by 5 modulo 24; i.e., it has found a
4756 new number which, when multiplied by 5 modulo 24, produces the original
4757 number, 21. If @var{m} is prime and the divisor is not a multiple of
4758 @var{m}, it is always possible to find such a number. For non-prime
4759 @var{m} like 24, it is only sometimes possible.
4760
4761 @smallexample
4762 @group
4763 1: 10 mod 24 1: 16 mod 24 1: 1000000... 1: 16
4764 . . . .
4765
4766 10 M 24 @key{RET} 100 ^ 10 @key{RET} 100 ^ 24 %
4767 @end group
4768 @end smallexample
4769
4770 @noindent
4771 These two calculations get the same answer, but the first one is
4772 much more efficient because it avoids the huge intermediate value
4773 that arises in the second one.
4774
4775 @cindex Fermat, primality test of
4776 (@bullet{}) @strong{Exercise 10.} A theorem of Pierre de Fermat
4777 says that
4778 @texline @w{@math{x^{n-1} \bmod n = 1}}
4779 @infoline @expr{x^(n-1) mod n = 1}
4780 if @expr{n} is a prime number and @expr{x} is an integer less than
4781 @expr{n}. If @expr{n} is @emph{not} a prime number, this will
4782 @emph{not} be true for most values of @expr{x}. Thus we can test
4783 informally if a number is prime by trying this formula for several
4784 values of @expr{x}. Use this test to tell whether the following numbers
4785 are prime: 811749613, 15485863. @xref{Types Answer 10, 10}. (@bullet{})
4786
4787 It is possible to use HMS forms as parts of error forms, intervals,
4788 modulo forms, or as the phase part of a polar complex number.
4789 For example, the @code{calc-time} command pushes the current time
4790 of day on the stack as an HMS/modulo form.
4791
4792 @smallexample
4793 @group
4794 1: 17@@ 34' 45" mod 24@@ 0' 0" 1: 6@@ 22' 15" mod 24@@ 0' 0"
4795 . .
4796
4797 x time @key{RET} n
4798 @end group
4799 @end smallexample
4800
4801 @noindent
4802 This calculation tells me it is six hours and 22 minutes until midnight.
4803
4804 (@bullet{}) @strong{Exercise 11.} A rule of thumb is that one year
4805 is about
4806 @texline @math{\pi \times 10^7}
4807 @infoline @w{@expr{pi * 10^7}}
4808 seconds. What time will it be that many seconds from right now?
4809 @xref{Types Answer 11, 11}. (@bullet{})
4810
4811 (@bullet{}) @strong{Exercise 12.} You are preparing to order packaging
4812 for the CD release of the Extended Disco Version of @emph{Abbey Road}.
4813 You are told that the songs will actually be anywhere from 20 to 60
4814 seconds longer than the originals. One CD can hold about 75 minutes
4815 of music. Should you order single or double packages?
4816 @xref{Types Answer 12, 12}. (@bullet{})
4817
4818 Another kind of data the Calculator can manipulate is numbers with
4819 @dfn{units}. This isn't strictly a new data type; it's simply an
4820 application of algebraic expressions, where we use variables with
4821 suggestive names like @samp{cm} and @samp{in} to represent units
4822 like centimeters and inches.
4823
4824 @smallexample
4825 @group
4826 1: 2 in 1: 5.08 cm 1: 0.027778 fath 1: 0.0508 m
4827 . . . .
4828
4829 ' 2in @key{RET} u c cm @key{RET} u c fath @key{RET} u b
4830 @end group
4831 @end smallexample
4832
4833 @noindent
4834 We enter the quantity ``2 inches'' (actually an algebraic expression
4835 which means two times the variable @samp{in}), then we convert it
4836 first to centimeters, then to fathoms, then finally to ``base'' units,
4837 which in this case means meters.
4838
4839 @smallexample
4840 @group
4841 1: 9 acre 1: 3 sqrt(acre) 1: 190.84 m 1: 190.84 m + 30 cm
4842 . . . .
4843
4844 ' 9 acre @key{RET} Q u s ' $+30 cm @key{RET}
4845
4846 @end group
4847 @end smallexample
4848 @noindent
4849 @smallexample
4850 @group
4851 1: 191.14 m 1: 36536.3046 m^2 1: 365363046 cm^2
4852 . . .
4853
4854 u s 2 ^ u c cgs
4855 @end group
4856 @end smallexample
4857
4858 @noindent
4859 Since units expressions are really just formulas, taking the square
4860 root of @samp{acre} is undefined. After all, @code{acre} might be an
4861 algebraic variable that you will someday assign a value. We use the
4862 ``units-simplify'' command to simplify the expression with variables
4863 being interpreted as unit names.
4864
4865 In the final step, we have converted not to a particular unit, but to a
4866 units system. The ``cgs'' system uses centimeters instead of meters
4867 as its standard unit of length.
4868
4869 There is a wide variety of units defined in the Calculator.
4870
4871 @smallexample
4872 @group
4873 1: 55 mph 1: 88.5139 kph 1: 88.5139 km / hr 1: 8.201407e-8 c
4874 . . . .
4875
4876 ' 55 mph @key{RET} u c kph @key{RET} u c km/hr @key{RET} u c c @key{RET}
4877 @end group
4878 @end smallexample
4879
4880 @noindent
4881 We express a speed first in miles per hour, then in kilometers per
4882 hour, then again using a slightly more explicit notation, then
4883 finally in terms of fractions of the speed of light.
4884
4885 Temperature conversions are a bit more tricky. There are two ways to
4886 interpret ``20 degrees Fahrenheit''---it could mean an actual
4887 temperature, or it could mean a change in temperature. For normal
4888 units there is no difference, but temperature units have an offset
4889 as well as a scale factor and so there must be two explicit commands
4890 for them.
4891
4892 @smallexample
4893 @group
4894 1: 20 degF 1: 11.1111 degC 1: -20:3 degC 1: -6.666 degC
4895 . . . .
4896
4897 ' 20 degF @key{RET} u c degC @key{RET} U u t degC @key{RET} c f
4898 @end group
4899 @end smallexample
4900
4901 @noindent
4902 First we convert a change of 20 degrees Fahrenheit into an equivalent
4903 change in degrees Celsius (or Centigrade). Then, we convert the
4904 absolute temperature 20 degrees Fahrenheit into Celsius. Since
4905 this comes out as an exact fraction, we then convert to floating-point
4906 for easier comparison with the other result.
4907
4908 For simple unit conversions, you can put a plain number on the stack.
4909 Then @kbd{u c} and @kbd{u t} will prompt for both old and new units.
4910 When you use this method, you're responsible for remembering which
4911 numbers are in which units:
4912
4913 @smallexample
4914 @group
4915 1: 55 1: 88.5139 1: 8.201407e-8
4916 . . .
4917
4918 55 u c mph @key{RET} kph @key{RET} u c km/hr @key{RET} c @key{RET}
4919 @end group
4920 @end smallexample
4921
4922 To see a complete list of built-in units, type @kbd{u v}. Press
4923 @w{@kbd{M-# c}} again to re-enter the Calculator when you're done looking
4924 at the units table.
4925
4926 (@bullet{}) @strong{Exercise 13.} How many seconds are there really
4927 in a year? @xref{Types Answer 13, 13}. (@bullet{})
4928
4929 @cindex Speed of light
4930 (@bullet{}) @strong{Exercise 14.} Supercomputer designs are limited by
4931 the speed of light (and of electricity, which is nearly as fast).
4932 Suppose a computer has a 4.1 ns (nanosecond) clock cycle, and its
4933 cabinet is one meter across. Is speed of light going to be a
4934 significant factor in its design? @xref{Types Answer 14, 14}. (@bullet{})
4935
4936 (@bullet{}) @strong{Exercise 15.} Sam the Slug normally travels about
4937 five yards in an hour. He has obtained a supply of Power Pills; each
4938 Power Pill he eats doubles his speed. How many Power Pills can he
4939 swallow and still travel legally on most US highways?
4940 @xref{Types Answer 15, 15}. (@bullet{})
4941
4942 @node Algebra Tutorial, Programming Tutorial, Types Tutorial, Tutorial
4943 @section Algebra and Calculus Tutorial
4944
4945 @noindent
4946 This section shows how to use Calc's algebra facilities to solve
4947 equations, do simple calculus problems, and manipulate algebraic
4948 formulas.
4949
4950 @menu
4951 * Basic Algebra Tutorial::
4952 * Rewrites Tutorial::
4953 @end menu
4954
4955 @node Basic Algebra Tutorial, Rewrites Tutorial, Algebra Tutorial, Algebra Tutorial
4956 @subsection Basic Algebra
4957
4958 @noindent
4959 If you enter a formula in Algebraic mode that refers to variables,
4960 the formula itself is pushed onto the stack. You can manipulate
4961 formulas as regular data objects.
4962
4963 @smallexample
4964 @group
4965 1: 2 x^2 - 6 1: 6 - 2 x^2 1: (6 - 2 x^2) (3 x^2 + y)
4966 . . .
4967
4968 ' 2x^2-6 @key{RET} n ' 3x^2+y @key{RET} *
4969 @end group
4970 @end smallexample
4971
4972 (@bullet{}) @strong{Exercise 1.} Do @kbd{' x @key{RET} Q 2 ^} and
4973 @kbd{' x @key{RET} 2 ^ Q} both wind up with the same result (@samp{x})?
4974 Why or why not? @xref{Algebra Answer 1, 1}. (@bullet{})
4975
4976 There are also commands for doing common algebraic operations on
4977 formulas. Continuing with the formula from the last example,
4978
4979 @smallexample
4980 @group
4981 1: 18 x^2 + 6 y - 6 x^4 - 2 x^2 y 1: (18 - 2 y) x^2 - 6 x^4 + 6 y
4982 . .
4983
4984 a x a c x @key{RET}
4985 @end group
4986 @end smallexample
4987
4988 @noindent
4989 First we ``expand'' using the distributive law, then we ``collect''
4990 terms involving like powers of @expr{x}.
4991
4992 Let's find the value of this expression when @expr{x} is 2 and @expr{y}
4993 is one-half.
4994
4995 @smallexample
4996 @group
4997 1: 17 x^2 - 6 x^4 + 3 1: -25
4998 . .
4999
5000 1:2 s l y @key{RET} 2 s l x @key{RET}
5001 @end group
5002 @end smallexample
5003
5004 @noindent
5005 The @kbd{s l} command means ``let''; it takes a number from the top of
5006 the stack and temporarily assigns it as the value of the variable
5007 you specify. It then evaluates (as if by the @kbd{=} key) the
5008 next expression on the stack. After this command, the variable goes
5009 back to its original value, if any.
5010
5011 (An earlier exercise in this tutorial involved storing a value in the
5012 variable @code{x}; if this value is still there, you will have to
5013 unstore it with @kbd{s u x @key{RET}} before the above example will work
5014 properly.)
5015
5016 @cindex Maximum of a function using Calculus
5017 Let's find the maximum value of our original expression when @expr{y}
5018 is one-half and @expr{x} ranges over all possible values. We can
5019 do this by taking the derivative with respect to @expr{x} and examining
5020 values of @expr{x} for which the derivative is zero. If the second
5021 derivative of the function at that value of @expr{x} is negative,
5022 the function has a local maximum there.
5023
5024 @smallexample
5025 @group
5026 1: 17 x^2 - 6 x^4 + 3 1: 34 x - 24 x^3
5027 . .
5028
5029 U @key{DEL} s 1 a d x @key{RET} s 2
5030 @end group
5031 @end smallexample
5032
5033 @noindent
5034 Well, the derivative is clearly zero when @expr{x} is zero. To find
5035 the other root(s), let's divide through by @expr{x} and then solve:
5036
5037 @smallexample
5038 @group
5039 1: (34 x - 24 x^3) / x 1: 34 x / x - 24 x^3 / x 1: 34 - 24 x^2
5040 . . .
5041
5042 ' x @key{RET} / a x a s
5043
5044 @end group
5045 @end smallexample
5046 @noindent
5047 @smallexample
5048 @group
5049 1: 34 - 24 x^2 = 0 1: x = 1.19023
5050 . .
5051
5052 0 a = s 3 a S x @key{RET}
5053 @end group
5054 @end smallexample
5055
5056 @noindent
5057 Notice the use of @kbd{a s} to ``simplify'' the formula. When the
5058 default algebraic simplifications don't do enough, you can use
5059 @kbd{a s} to tell Calc to spend more time on the job.
5060
5061 Now we compute the second derivative and plug in our values of @expr{x}:
5062
5063 @smallexample
5064 @group
5065 1: 1.19023 2: 1.19023 2: 1.19023
5066 . 1: 34 x - 24 x^3 1: 34 - 72 x^2
5067 . .
5068
5069 a . r 2 a d x @key{RET} s 4
5070 @end group
5071 @end smallexample
5072
5073 @noindent
5074 (The @kbd{a .} command extracts just the righthand side of an equation.
5075 Another method would have been to use @kbd{v u} to unpack the equation
5076 @w{@samp{x = 1.19}} to @samp{x} and @samp{1.19}, then use @kbd{M-- M-2 @key{DEL}}
5077 to delete the @samp{x}.)
5078
5079 @smallexample
5080 @group
5081 2: 34 - 72 x^2 1: -68. 2: 34 - 72 x^2 1: 34
5082 1: 1.19023 . 1: 0 .
5083 . .
5084
5085 @key{TAB} s l x @key{RET} U @key{DEL} 0 s l x @key{RET}
5086 @end group
5087 @end smallexample
5088
5089 @noindent
5090 The first of these second derivatives is negative, so we know the function
5091 has a maximum value at @expr{x = 1.19023}. (The function also has a
5092 local @emph{minimum} at @expr{x = 0}.)
5093
5094 When we solved for @expr{x}, we got only one value even though
5095 @expr{34 - 24 x^2 = 0} is a quadratic equation that ought to have
5096 two solutions. The reason is that @w{@kbd{a S}} normally returns a
5097 single ``principal'' solution. If it needs to come up with an
5098 arbitrary sign (as occurs in the quadratic formula) it picks @expr{+}.
5099 If it needs an arbitrary integer, it picks zero. We can get a full
5100 solution by pressing @kbd{H} (the Hyperbolic flag) before @kbd{a S}.
5101
5102 @smallexample
5103 @group
5104 1: 34 - 24 x^2 = 0 1: x = 1.19023 s1 1: x = -1.19023
5105 . . .
5106
5107 r 3 H a S x @key{RET} s 5 1 n s l s1 @key{RET}
5108 @end group
5109 @end smallexample
5110
5111 @noindent
5112 Calc has invented the variable @samp{s1} to represent an unknown sign;
5113 it is supposed to be either @mathit{+1} or @mathit{-1}. Here we have used
5114 the ``let'' command to evaluate the expression when the sign is negative.
5115 If we plugged this into our second derivative we would get the same,
5116 negative, answer, so @expr{x = -1.19023} is also a maximum.
5117
5118 To find the actual maximum value, we must plug our two values of @expr{x}
5119 into the original formula.
5120
5121 @smallexample
5122 @group
5123 2: 17 x^2 - 6 x^4 + 3 1: 24.08333 s1^2 - 12.04166 s1^4 + 3
5124 1: x = 1.19023 s1 .
5125 .
5126
5127 r 1 r 5 s l @key{RET}
5128 @end group
5129 @end smallexample
5130
5131 @noindent
5132 (Here we see another way to use @kbd{s l}; if its input is an equation
5133 with a variable on the lefthand side, then @kbd{s l} treats the equation
5134 like an assignment to that variable if you don't give a variable name.)
5135
5136 It's clear that this will have the same value for either sign of
5137 @code{s1}, but let's work it out anyway, just for the exercise:
5138
5139 @smallexample
5140 @group
5141 2: [-1, 1] 1: [15.04166, 15.04166]
5142 1: 24.08333 s1^2 ... .
5143 .
5144
5145 [ 1 n , 1 ] @key{TAB} V M $ @key{RET}
5146 @end group
5147 @end smallexample
5148
5149 @noindent
5150 Here we have used a vector mapping operation to evaluate the function
5151 at several values of @samp{s1} at once. @kbd{V M $} is like @kbd{V M '}
5152 except that it takes the formula from the top of the stack. The
5153 formula is interpreted as a function to apply across the vector at the
5154 next-to-top stack level. Since a formula on the stack can't contain
5155 @samp{$} signs, Calc assumes the variables in the formula stand for
5156 different arguments. It prompts you for an @dfn{argument list}, giving
5157 the list of all variables in the formula in alphabetical order as the
5158 default list. In this case the default is @samp{(s1)}, which is just
5159 what we want so we simply press @key{RET} at the prompt.
5160
5161 If there had been several different values, we could have used
5162 @w{@kbd{V R X}} to find the global maximum.
5163
5164 Calc has a built-in @kbd{a P} command that solves an equation using
5165 @w{@kbd{H a S}} and returns a vector of all the solutions. It simply
5166 automates the job we just did by hand. Applied to our original
5167 cubic polynomial, it would produce the vector of solutions
5168 @expr{[1.19023, -1.19023, 0]}. (There is also an @kbd{a X} command
5169 which finds a local maximum of a function. It uses a numerical search
5170 method rather than examining the derivatives, and thus requires you
5171 to provide some kind of initial guess to show it where to look.)
5172
5173 (@bullet{}) @strong{Exercise 2.} Given a vector of the roots of a
5174 polynomial (such as the output of an @kbd{a P} command), what
5175 sequence of commands would you use to reconstruct the original
5176 polynomial? (The answer will be unique to within a constant
5177 multiple; choose the solution where the leading coefficient is one.)
5178 @xref{Algebra Answer 2, 2}. (@bullet{})
5179
5180 The @kbd{m s} command enables Symbolic mode, in which formulas
5181 like @samp{sqrt(5)} that can't be evaluated exactly are left in
5182 symbolic form rather than giving a floating-point approximate answer.
5183 Fraction mode (@kbd{m f}) is also useful when doing algebra.
5184
5185 @smallexample
5186 @group
5187 2: 34 x - 24 x^3 2: 34 x - 24 x^3
5188 1: 34 x - 24 x^3 1: [sqrt(51) / 6, sqrt(51) / -6, 0]
5189 . .
5190
5191 r 2 @key{RET} m s m f a P x @key{RET}
5192 @end group
5193 @end smallexample
5194
5195 One more mode that makes reading formulas easier is Big mode.
5196
5197 @smallexample
5198 @group
5199 3
5200 2: 34 x - 24 x
5201
5202 ____ ____
5203 V 51 V 51
5204 1: [-----, -----, 0]
5205 6 -6
5206
5207 .
5208
5209 d B
5210 @end group
5211 @end smallexample
5212
5213 Here things like powers, square roots, and quotients and fractions
5214 are displayed in a two-dimensional pictorial form. Calc has other
5215 language modes as well, such as C mode, FORTRAN mode, @TeX{} mode
5216 and La@TeX{} mode.
5217
5218 @smallexample
5219 @group
5220 2: 34*x - 24*pow(x, 3) 2: 34*x - 24*x**3
5221 1: @{sqrt(51) / 6, sqrt(51) / -6, 0@} 1: /sqrt(51) / 6, sqrt(51) / -6, 0/
5222 . .
5223
5224 d C d F
5225
5226 @end group
5227 @end smallexample
5228 @noindent
5229 @smallexample
5230 @group
5231 3: 34 x - 24 x^3
5232 2: [@{\sqrt@{51@} \over 6@}, @{\sqrt@{51@} \over -6@}, 0]
5233 1: @{2 \over 3@} \sqrt@{5@}
5234 .
5235
5236 d T ' 2 \sqrt@{5@} \over 3 @key{RET}
5237 @end group
5238 @end smallexample
5239
5240 @noindent
5241 As you can see, language modes affect both entry and display of
5242 formulas. They affect such things as the names used for built-in
5243 functions, the set of arithmetic operators and their precedences,
5244 and notations for vectors and matrices.
5245
5246 Notice that @samp{sqrt(51)} may cause problems with older
5247 implementations of C and FORTRAN, which would require something more
5248 like @samp{sqrt(51.0)}. It is always wise to check over the formulas
5249 produced by the various language modes to make sure they are fully
5250 correct.
5251
5252 Type @kbd{m s}, @kbd{m f}, and @kbd{d N} to reset these modes. (You
5253 may prefer to remain in Big mode, but all the examples in the tutorial
5254 are shown in normal mode.)
5255
5256 @cindex Area under a curve
5257 What is the area under the portion of this curve from @expr{x = 1} to @expr{2}?
5258 This is simply the integral of the function:
5259
5260 @smallexample
5261 @group
5262 1: 17 x^2 - 6 x^4 + 3 1: 5.6666 x^3 - 1.2 x^5 + 3 x
5263 . .
5264
5265 r 1 a i x
5266 @end group
5267 @end smallexample
5268
5269 @noindent
5270 We want to evaluate this at our two values for @expr{x} and subtract.
5271 One way to do it is again with vector mapping and reduction:
5272
5273 @smallexample
5274 @group
5275 2: [2, 1] 1: [12.93333, 7.46666] 1: 5.46666
5276 1: 5.6666 x^3 ... . .
5277
5278 [ 2 , 1 ] @key{TAB} V M $ @key{RET} V R -
5279 @end group
5280 @end smallexample
5281
5282 (@bullet{}) @strong{Exercise 3.} Find the integral from 1 to @expr{y}
5283 of
5284 @texline @math{x \sin \pi x}
5285 @infoline @w{@expr{x sin(pi x)}}
5286 (where the sine is calculated in radians). Find the values of the
5287 integral for integers @expr{y} from 1 to 5. @xref{Algebra Answer 3,
5288 3}. (@bullet{})
5289
5290 Calc's integrator can do many simple integrals symbolically, but many
5291 others are beyond its capabilities. Suppose we wish to find the area
5292 under the curve
5293 @texline @math{\sin x \ln x}
5294 @infoline @expr{sin(x) ln(x)}
5295 over the same range of @expr{x}. If you entered this formula and typed
5296 @kbd{a i x @key{RET}} (don't bother to try this), Calc would work for a
5297 long time but would be unable to find a solution. In fact, there is no
5298 closed-form solution to this integral. Now what do we do?
5299
5300 @cindex Integration, numerical
5301 @cindex Numerical integration
5302 One approach would be to do the integral numerically. It is not hard
5303 to do this by hand using vector mapping and reduction. It is rather
5304 slow, though, since the sine and logarithm functions take a long time.
5305 We can save some time by reducing the working precision.
5306
5307 @smallexample
5308 @group
5309 3: 10 1: [1, 1.1, 1.2, ... , 1.8, 1.9]
5310 2: 1 .
5311 1: 0.1
5312 .
5313
5314 10 @key{RET} 1 @key{RET} .1 @key{RET} C-u v x
5315 @end group
5316 @end smallexample
5317
5318 @noindent
5319 (Note that we have used the extended version of @kbd{v x}; we could
5320 also have used plain @kbd{v x} as follows: @kbd{v x 10 @key{RET} 9 + .1 *}.)
5321
5322 @smallexample
5323 @group
5324 2: [1, 1.1, ... ] 1: [0., 0.084941, 0.16993, ... ]
5325 1: sin(x) ln(x) .
5326 .
5327
5328 ' sin(x) ln(x) @key{RET} s 1 m r p 5 @key{RET} V M $ @key{RET}
5329
5330 @end group
5331 @end smallexample
5332 @noindent
5333 @smallexample
5334 @group
5335 1: 3.4195 0.34195
5336 . .
5337
5338 V R + 0.1 *
5339 @end group
5340 @end smallexample
5341
5342 @noindent
5343 (If you got wildly different results, did you remember to switch
5344 to Radians mode?)
5345
5346 Here we have divided the curve into ten segments of equal width;
5347 approximating these segments as rectangular boxes (i.e., assuming
5348 the curve is nearly flat at that resolution), we compute the areas
5349 of the boxes (height times width), then sum the areas. (It is
5350 faster to sum first, then multiply by the width, since the width
5351 is the same for every box.)
5352
5353 The true value of this integral turns out to be about 0.374, so
5354 we're not doing too well. Let's try another approach.
5355
5356 @smallexample
5357 @group
5358 1: sin(x) ln(x) 1: 0.84147 x - 0.84147 + 0.11957 (x - 1)^2 - ...
5359 . .
5360
5361 r 1 a t x=1 @key{RET} 4 @key{RET}
5362 @end group
5363 @end smallexample
5364
5365 @noindent
5366 Here we have computed the Taylor series expansion of the function
5367 about the point @expr{x=1}. We can now integrate this polynomial
5368 approximation, since polynomials are easy to integrate.
5369
5370 @smallexample
5371 @group
5372 1: 0.42074 x^2 + ... 1: [-0.0446, -0.42073] 1: 0.3761
5373 . . .
5374
5375 a i x @key{RET} [ 2 , 1 ] @key{TAB} V M $ @key{RET} V R -
5376 @end group
5377 @end smallexample
5378
5379 @noindent
5380 Better! By increasing the precision and/or asking for more terms
5381 in the Taylor series, we can get a result as accurate as we like.
5382 (Taylor series converge better away from singularities in the
5383 function such as the one at @code{ln(0)}, so it would also help to
5384 expand the series about the points @expr{x=2} or @expr{x=1.5} instead
5385 of @expr{x=1}.)
5386
5387 @cindex Simpson's rule
5388 @cindex Integration by Simpson's rule
5389 (@bullet{}) @strong{Exercise 4.} Our first method approximated the
5390 curve by stairsteps of width 0.1; the total area was then the sum
5391 of the areas of the rectangles under these stairsteps. Our second
5392 method approximated the function by a polynomial, which turned out
5393 to be a better approximation than stairsteps. A third method is
5394 @dfn{Simpson's rule}, which is like the stairstep method except
5395 that the steps are not required to be flat. Simpson's rule boils
5396 down to the formula,
5397
5398 @ifinfo
5399 @example
5400 (h/3) * (f(a) + 4 f(a+h) + 2 f(a+2h) + 4 f(a+3h) + ...
5401 + 2 f(a+(n-2)*h) + 4 f(a+(n-1)*h) + f(a+n*h))
5402 @end example
5403 @end ifinfo
5404 @tex
5405 \turnoffactive
5406 \beforedisplay
5407 $$ \displaylines{
5408 \qquad {h \over 3} (f(a) + 4 f(a+h) + 2 f(a+2h) + 4 f(a+3h) + \cdots
5409 \hfill \cr \hfill {} + 2 f(a+(n-2)h) + 4 f(a+(n-1)h) + f(a+n h)) \qquad
5410 } $$
5411 \afterdisplay
5412 @end tex
5413
5414 @noindent
5415 where @expr{n} (which must be even) is the number of slices and @expr{h}
5416 is the width of each slice. These are 10 and 0.1 in our example.
5417 For reference, here is the corresponding formula for the stairstep
5418 method:
5419
5420 @ifinfo
5421 @example
5422 h * (f(a) + f(a+h) + f(a+2h) + f(a+3h) + ...
5423 + f(a+(n-2)*h) + f(a+(n-1)*h))
5424 @end example
5425 @end ifinfo
5426 @tex
5427 \turnoffactive
5428 \beforedisplay
5429 $$ h (f(a) + f(a+h) + f(a+2h) + f(a+3h) + \cdots
5430 + f(a+(n-2)h) + f(a+(n-1)h)) $$
5431 \afterdisplay
5432 @end tex
5433
5434 Compute the integral from 1 to 2 of
5435 @texline @math{\sin x \ln x}
5436 @infoline @expr{sin(x) ln(x)}
5437 using Simpson's rule with 10 slices.
5438 @xref{Algebra Answer 4, 4}. (@bullet{})
5439
5440 Calc has a built-in @kbd{a I} command for doing numerical integration.
5441 It uses @dfn{Romberg's method}, which is a more sophisticated cousin
5442 of Simpson's rule. In particular, it knows how to keep refining the
5443 result until the current precision is satisfied.
5444
5445 @c [fix-ref Selecting Sub-Formulas]
5446 Aside from the commands we've seen so far, Calc also provides a
5447 large set of commands for operating on parts of formulas. You
5448 indicate the desired sub-formula by placing the cursor on any part
5449 of the formula before giving a @dfn{selection} command. Selections won't
5450 be covered in the tutorial; @pxref{Selecting Subformulas}, for
5451 details and examples.
5452
5453 @c hard exercise: simplify (2^(n r) - 2^(r*(n - 1))) / (2^r - 1) 2^(n - 1)
5454 @c to 2^((n-1)*(r-1)).
5455
5456 @node Rewrites Tutorial, , Basic Algebra Tutorial, Algebra Tutorial
5457 @subsection Rewrite Rules
5458
5459 @noindent
5460 No matter how many built-in commands Calc provided for doing algebra,
5461 there would always be something you wanted to do that Calc didn't have
5462 in its repertoire. So Calc also provides a @dfn{rewrite rule} system
5463 that you can use to define your own algebraic manipulations.
5464
5465 Suppose we want to simplify this trigonometric formula:
5466
5467 @smallexample
5468 @group
5469 1: 1 / cos(x) - sin(x) tan(x)
5470 .
5471
5472 ' 1/cos(x) - sin(x) tan(x) @key{RET} s 1
5473 @end group
5474 @end smallexample
5475
5476 @noindent
5477 If we were simplifying this by hand, we'd probably replace the
5478 @samp{tan} with a @samp{sin/cos} first, then combine over a common
5479 denominator. There is no Calc command to do the former; the @kbd{a n}
5480 algebra command will do the latter but we'll do both with rewrite
5481 rules just for practice.
5482
5483 Rewrite rules are written with the @samp{:=} symbol.
5484
5485 @smallexample
5486 @group
5487 1: 1 / cos(x) - sin(x)^2 / cos(x)
5488 .
5489
5490 a r tan(a) := sin(a)/cos(a) @key{RET}
5491 @end group
5492 @end smallexample
5493
5494 @noindent
5495 (The ``assignment operator'' @samp{:=} has several uses in Calc. All
5496 by itself the formula @samp{tan(a) := sin(a)/cos(a)} doesn't do anything,
5497 but when it is given to the @kbd{a r} command, that command interprets
5498 it as a rewrite rule.)
5499
5500 The lefthand side, @samp{tan(a)}, is called the @dfn{pattern} of the
5501 rewrite rule. Calc searches the formula on the stack for parts that
5502 match the pattern. Variables in a rewrite pattern are called
5503 @dfn{meta-variables}, and when matching the pattern each meta-variable
5504 can match any sub-formula. Here, the meta-variable @samp{a} matched
5505 the actual variable @samp{x}.
5506
5507 When the pattern part of a rewrite rule matches a part of the formula,
5508 that part is replaced by the righthand side with all the meta-variables
5509 substituted with the things they matched. So the result is
5510 @samp{sin(x) / cos(x)}. Calc's normal algebraic simplifications then
5511 mix this in with the rest of the original formula.
5512
5513 To merge over a common denominator, we can use another simple rule:
5514
5515 @smallexample
5516 @group
5517 1: (1 - sin(x)^2) / cos(x)
5518 .
5519
5520 a r a/x + b/x := (a+b)/x @key{RET}
5521 @end group
5522 @end smallexample
5523
5524 This rule points out several interesting features of rewrite patterns.
5525 First, if a meta-variable appears several times in a pattern, it must
5526 match the same thing everywhere. This rule detects common denominators
5527 because the same meta-variable @samp{x} is used in both of the
5528 denominators.
5529
5530 Second, meta-variable names are independent from variables in the
5531 target formula. Notice that the meta-variable @samp{x} here matches
5532 the subformula @samp{cos(x)}; Calc never confuses the two meanings of
5533 @samp{x}.
5534
5535 And third, rewrite patterns know a little bit about the algebraic
5536 properties of formulas. The pattern called for a sum of two quotients;
5537 Calc was able to match a difference of two quotients by matching
5538 @samp{a = 1}, @samp{b = -sin(x)^2}, and @samp{x = cos(x)}.
5539
5540 @c [fix-ref Algebraic Properties of Rewrite Rules]
5541 We could just as easily have written @samp{a/x - b/x := (a-b)/x} for
5542 the rule. It would have worked just the same in all cases. (If we
5543 really wanted the rule to apply only to @samp{+} or only to @samp{-},
5544 we could have used the @code{plain} symbol. @xref{Algebraic Properties
5545 of Rewrite Rules}, for some examples of this.)
5546
5547 One more rewrite will complete the job. We want to use the identity
5548 @samp{sin(x)^2 + cos(x)^2 = 1}, but of course we must first rearrange
5549 the identity in a way that matches our formula. The obvious rule
5550 would be @samp{@w{1 - sin(x)^2} := cos(x)^2}, but a little thought shows
5551 that the rule @samp{sin(x)^2 := 1 - cos(x)^2} will also work. The
5552 latter rule has a more general pattern so it will work in many other
5553 situations, too.
5554
5555 @smallexample
5556 @group
5557 1: (1 + cos(x)^2 - 1) / cos(x) 1: cos(x)
5558 . .
5559
5560 a r sin(x)^2 := 1 - cos(x)^2 @key{RET} a s
5561 @end group
5562 @end smallexample
5563
5564 You may ask, what's the point of using the most general rule if you
5565 have to type it in every time anyway? The answer is that Calc allows
5566 you to store a rewrite rule in a variable, then give the variable
5567 name in the @kbd{a r} command. In fact, this is the preferred way to
5568 use rewrites. For one, if you need a rule once you'll most likely
5569 need it again later. Also, if the rule doesn't work quite right you
5570 can simply Undo, edit the variable, and run the rule again without
5571 having to retype it.
5572
5573 @smallexample
5574 @group
5575 ' tan(x) := sin(x)/cos(x) @key{RET} s t tsc @key{RET}
5576 ' a/x + b/x := (a+b)/x @key{RET} s t merge @key{RET}
5577 ' sin(x)^2 := 1 - cos(x)^2 @key{RET} s t sinsqr @key{RET}
5578
5579 1: 1 / cos(x) - sin(x) tan(x) 1: cos(x)
5580 . .
5581
5582 r 1 a r tsc @key{RET} a r merge @key{RET} a r sinsqr @key{RET} a s
5583 @end group
5584 @end smallexample
5585
5586 To edit a variable, type @kbd{s e} and the variable name, use regular
5587 Emacs editing commands as necessary, then type @kbd{C-c C-c} to store
5588 the edited value back into the variable.
5589 You can also use @w{@kbd{s e}} to create a new variable if you wish.
5590
5591 Notice that the first time you use each rule, Calc puts up a ``compiling''
5592 message briefly. The pattern matcher converts rules into a special
5593 optimized pattern-matching language rather than using them directly.
5594 This allows @kbd{a r} to apply even rather complicated rules very
5595 efficiently. If the rule is stored in a variable, Calc compiles it
5596 only once and stores the compiled form along with the variable. That's
5597 another good reason to store your rules in variables rather than
5598 entering them on the fly.
5599
5600 (@bullet{}) @strong{Exercise 1.} Type @kbd{m s} to get Symbolic
5601 mode, then enter the formula @samp{@w{(2 + sqrt(2))} / @w{(1 + sqrt(2))}}.
5602 Using a rewrite rule, simplify this formula by multiplying both
5603 sides by the conjugate @w{@samp{1 - sqrt(2)}}. The result will have
5604 to be expanded by the distributive law; do this with another
5605 rewrite. @xref{Rewrites Answer 1, 1}. (@bullet{})
5606
5607 The @kbd{a r} command can also accept a vector of rewrite rules, or
5608 a variable containing a vector of rules.
5609
5610 @smallexample
5611 @group
5612 1: [tsc, merge, sinsqr] 1: [tan(x) := sin(x) / cos(x), ... ]
5613 . .
5614
5615 ' [tsc,merge,sinsqr] @key{RET} =
5616
5617 @end group
5618 @end smallexample
5619 @noindent
5620 @smallexample
5621 @group
5622 1: 1 / cos(x) - sin(x) tan(x) 1: cos(x)
5623 . .
5624
5625 s t trig @key{RET} r 1 a r trig @key{RET} a s
5626 @end group
5627 @end smallexample
5628
5629 @c [fix-ref Nested Formulas with Rewrite Rules]
5630 Calc tries all the rules you give against all parts of the formula,
5631 repeating until no further change is possible. (The exact order in
5632 which things are tried is rather complex, but for simple rules like
5633 the ones we've used here the order doesn't really matter.
5634 @xref{Nested Formulas with Rewrite Rules}.)
5635
5636 Calc actually repeats only up to 100 times, just in case your rule set
5637 has gotten into an infinite loop. You can give a numeric prefix argument
5638 to @kbd{a r} to specify any limit. In particular, @kbd{M-1 a r} does
5639 only one rewrite at a time.
5640
5641 @smallexample
5642 @group
5643 1: 1 / cos(x) - sin(x)^2 / cos(x) 1: (1 - sin(x)^2) / cos(x)
5644 . .
5645
5646 r 1 M-1 a r trig @key{RET} M-1 a r trig @key{RET}
5647 @end group
5648 @end smallexample
5649
5650 You can type @kbd{M-0 a r} if you want no limit at all on the number
5651 of rewrites that occur.
5652
5653 Rewrite rules can also be @dfn{conditional}. Simply follow the rule
5654 with a @samp{::} symbol and the desired condition. For example,
5655
5656 @smallexample
5657 @group
5658 1: exp(2 pi i) + exp(3 pi i) + exp(4 pi i)
5659 .
5660
5661 ' exp(2 pi i) + exp(3 pi i) + exp(4 pi i) @key{RET}
5662
5663 @end group
5664 @end smallexample
5665 @noindent
5666 @smallexample
5667 @group
5668 1: 1 + exp(3 pi i) + 1
5669 .
5670
5671 a r exp(k pi i) := 1 :: k % 2 = 0 @key{RET}
5672 @end group
5673 @end smallexample
5674
5675 @noindent
5676 (Recall, @samp{k % 2} is the remainder from dividing @samp{k} by 2,
5677 which will be zero only when @samp{k} is an even integer.)
5678
5679 An interesting point is that the variables @samp{pi} and @samp{i}
5680 were matched literally rather than acting as meta-variables.
5681 This is because they are special-constant variables. The special
5682 constants @samp{e}, @samp{phi}, and so on also match literally.
5683 A common error with rewrite
5684 rules is to write, say, @samp{f(a,b,c,d,e) := g(a+b+c+d+e)}, expecting
5685 to match any @samp{f} with five arguments but in fact matching
5686 only when the fifth argument is literally @samp{e}!
5687
5688 @cindex Fibonacci numbers
5689 @ignore
5690 @starindex
5691 @end ignore
5692 @tindex fib
5693 Rewrite rules provide an interesting way to define your own functions.
5694 Suppose we want to define @samp{fib(n)} to produce the @var{n}th
5695 Fibonacci number. The first two Fibonacci numbers are each 1;
5696 later numbers are formed by summing the two preceding numbers in
5697 the sequence. This is easy to express in a set of three rules:
5698
5699 @smallexample
5700 @group
5701 ' [fib(1) := 1, fib(2) := 1, fib(n) := fib(n-1) + fib(n-2)] @key{RET} s t fib
5702
5703 1: fib(7) 1: 13
5704 . .
5705
5706 ' fib(7) @key{RET} a r fib @key{RET}
5707 @end group
5708 @end smallexample
5709
5710 One thing that is guaranteed about the order that rewrites are tried
5711 is that, for any given subformula, earlier rules in the rule set will
5712 be tried for that subformula before later ones. So even though the
5713 first and third rules both match @samp{fib(1)}, we know the first will
5714 be used preferentially.
5715
5716 This rule set has one dangerous bug: Suppose we apply it to the
5717 formula @samp{fib(x)}? (Don't actually try this.) The third rule
5718 will match @samp{fib(x)} and replace it with @w{@samp{fib(x-1) + fib(x-2)}}.
5719 Each of these will then be replaced to get @samp{fib(x-2) + 2 fib(x-3) +
5720 fib(x-4)}, and so on, expanding forever. What we really want is to apply
5721 the third rule only when @samp{n} is an integer greater than two. Type
5722 @w{@kbd{s e fib @key{RET}}}, then edit the third rule to:
5723
5724 @smallexample
5725 fib(n) := fib(n-1) + fib(n-2) :: integer(n) :: n > 2
5726 @end smallexample
5727
5728 @noindent
5729 Now:
5730
5731 @smallexample
5732 @group
5733 1: fib(6) + fib(x) + fib(0) 1: 8 + fib(x) + fib(0)
5734 . .
5735
5736 ' fib(6)+fib(x)+fib(0) @key{RET} a r fib @key{RET}
5737 @end group
5738 @end smallexample
5739
5740 @noindent
5741 We've created a new function, @code{fib}, and a new command,
5742 @w{@kbd{a r fib @key{RET}}}, which means ``evaluate all @code{fib} calls in
5743 this formula.'' To make things easier still, we can tell Calc to
5744 apply these rules automatically by storing them in the special
5745 variable @code{EvalRules}.
5746
5747 @smallexample
5748 @group
5749 1: [fib(1) := ...] . 1: [8, 13]
5750 . .
5751
5752 s r fib @key{RET} s t EvalRules @key{RET} ' [fib(6), fib(7)] @key{RET}
5753 @end group
5754 @end smallexample
5755
5756 It turns out that this rule set has the problem that it does far
5757 more work than it needs to when @samp{n} is large. Consider the
5758 first few steps of the computation of @samp{fib(6)}:
5759
5760 @smallexample
5761 @group
5762 fib(6) =
5763 fib(5) + fib(4) =
5764 fib(4) + fib(3) + fib(3) + fib(2) =
5765 fib(3) + fib(2) + fib(2) + fib(1) + fib(2) + fib(1) + 1 = ...
5766 @end group
5767 @end smallexample
5768
5769 @noindent
5770 Note that @samp{fib(3)} appears three times here. Unless Calc's
5771 algebraic simplifier notices the multiple @samp{fib(3)}s and combines
5772 them (and, as it happens, it doesn't), this rule set does lots of
5773 needless recomputation. To cure the problem, type @code{s e EvalRules}
5774 to edit the rules (or just @kbd{s E}, a shorthand command for editing
5775 @code{EvalRules}) and add another condition:
5776
5777 @smallexample
5778 fib(n) := fib(n-1) + fib(n-2) :: integer(n) :: n > 2 :: remember
5779 @end smallexample
5780
5781 @noindent
5782 If a @samp{:: remember} condition appears anywhere in a rule, then if
5783 that rule succeeds Calc will add another rule that describes that match
5784 to the front of the rule set. (Remembering works in any rule set, but
5785 for technical reasons it is most effective in @code{EvalRules}.) For
5786 example, if the rule rewrites @samp{fib(7)} to something that evaluates
5787 to 13, then the rule @samp{fib(7) := 13} will be added to the rule set.
5788
5789 Type @kbd{' fib(8) @key{RET}} to compute the eighth Fibonacci number, then
5790 type @kbd{s E} again to see what has happened to the rule set.
5791
5792 With the @code{remember} feature, our rule set can now compute
5793 @samp{fib(@var{n})} in just @var{n} steps. In the process it builds
5794 up a table of all Fibonacci numbers up to @var{n}. After we have
5795 computed the result for a particular @var{n}, we can get it back
5796 (and the results for all smaller @var{n}) later in just one step.
5797
5798 All Calc operations will run somewhat slower whenever @code{EvalRules}
5799 contains any rules. You should type @kbd{s u EvalRules @key{RET}} now to
5800 un-store the variable.
5801
5802 (@bullet{}) @strong{Exercise 2.} Sometimes it is possible to reformulate
5803 a problem to reduce the amount of recursion necessary to solve it.
5804 Create a rule that, in about @var{n} simple steps and without recourse
5805 to the @code{remember} option, replaces @samp{fib(@var{n}, 1, 1)} with
5806 @samp{fib(1, @var{x}, @var{y})} where @var{x} and @var{y} are the
5807 @var{n}th and @var{n+1}st Fibonacci numbers, respectively. This rule is
5808 rather clunky to use, so add a couple more rules to make the ``user
5809 interface'' the same as for our first version: enter @samp{fib(@var{n})},
5810 get back a plain number. @xref{Rewrites Answer 2, 2}. (@bullet{})
5811
5812 There are many more things that rewrites can do. For example, there
5813 are @samp{&&&} and @samp{|||} pattern operators that create ``and''
5814 and ``or'' combinations of rules. As one really simple example, we
5815 could combine our first two Fibonacci rules thusly:
5816
5817 @example
5818 [fib(1 ||| 2) := 1, fib(n) := ... ]
5819 @end example
5820
5821 @noindent
5822 That means ``@code{fib} of something matching either 1 or 2 rewrites
5823 to 1.''
5824
5825 You can also make meta-variables optional by enclosing them in @code{opt}.
5826 For example, the pattern @samp{a + b x} matches @samp{2 + 3 x} but not
5827 @samp{2 + x} or @samp{3 x} or @samp{x}. The pattern @samp{opt(a) + opt(b) x}
5828 matches all of these forms, filling in a default of zero for @samp{a}
5829 and one for @samp{b}.
5830
5831 (@bullet{}) @strong{Exercise 3.} Your friend Joe had @samp{2 + 3 x}
5832 on the stack and tried to use the rule
5833 @samp{opt(a) + opt(b) x := f(a, b, x)}. What happened?
5834 @xref{Rewrites Answer 3, 3}. (@bullet{})
5835
5836 (@bullet{}) @strong{Exercise 4.} Starting with a positive integer @expr{a},
5837 divide @expr{a} by two if it is even, otherwise compute @expr{3 a + 1}.
5838 Now repeat this step over and over. A famous unproved conjecture
5839 is that for any starting @expr{a}, the sequence always eventually
5840 reaches 1. Given the formula @samp{seq(@var{a}, 0)}, write a set of
5841 rules that convert this into @samp{seq(1, @var{n})} where @var{n}
5842 is the number of steps it took the sequence to reach the value 1.
5843 Now enhance the rules to accept @samp{seq(@var{a})} as a starting
5844 configuration, and to stop with just the number @var{n} by itself.
5845 Now make the result be a vector of values in the sequence, from @var{a}
5846 to 1. (The formula @samp{@var{x}|@var{y}} appends the vectors @var{x}
5847 and @var{y}.) For example, rewriting @samp{seq(6)} should yield the
5848 vector @expr{[6, 3, 10, 5, 16, 8, 4, 2, 1]}.
5849 @xref{Rewrites Answer 4, 4}. (@bullet{})
5850
5851 (@bullet{}) @strong{Exercise 5.} Define, using rewrite rules, a function
5852 @samp{nterms(@var{x})} that returns the number of terms in the sum
5853 @var{x}, or 1 if @var{x} is not a sum. (A @dfn{sum} for our purposes
5854 is one or more non-sum terms separated by @samp{+} or @samp{-} signs,
5855 so that @expr{2 - 3 (x + y) + x y} is a sum of three terms.)
5856 @xref{Rewrites Answer 5, 5}. (@bullet{})
5857
5858 (@bullet{}) @strong{Exercise 6.} A Taylor series for a function is an
5859 infinite series that exactly equals the value of that function at
5860 values of @expr{x} near zero.
5861
5862 @ifinfo
5863 @example
5864 cos(x) = 1 - x^2 / 2! + x^4 / 4! - x^6 / 6! + ...
5865 @end example
5866 @end ifinfo
5867 @tex
5868 \turnoffactive
5869 \beforedisplay
5870 $$ \cos x = 1 - {x^2 \over 2!} + {x^4 \over 4!} - {x^6 \over 6!} + \cdots $$
5871 \afterdisplay
5872 @end tex
5873
5874 The @kbd{a t} command produces a @dfn{truncated Taylor series} which
5875 is obtained by dropping all the terms higher than, say, @expr{x^2}.
5876 Calc represents the truncated Taylor series as a polynomial in @expr{x}.
5877 Mathematicians often write a truncated series using a ``big-O'' notation
5878 that records what was the lowest term that was truncated.
5879
5880 @ifinfo
5881 @example
5882 cos(x) = 1 - x^2 / 2! + O(x^3)
5883 @end example
5884 @end ifinfo
5885 @tex
5886 \turnoffactive
5887 \beforedisplay
5888 $$ \cos x = 1 - {x^2 \over 2!} + O(x^3) $$
5889 \afterdisplay
5890 @end tex
5891
5892 @noindent
5893 The meaning of @expr{O(x^3)} is ``a quantity which is negligibly small
5894 if @expr{x^3} is considered negligibly small as @expr{x} goes to zero.''
5895
5896 The exercise is to create rewrite rules that simplify sums and products of
5897 power series represented as @samp{@var{polynomial} + O(@var{var}^@var{n})}.
5898 For example, given @samp{1 - x^2 / 2 + O(x^3)} and @samp{x - x^3 / 6 + O(x^4)}
5899 on the stack, we want to be able to type @kbd{*} and get the result
5900 @samp{x - 2:3 x^3 + O(x^4)}. Don't worry if the terms of the sum are
5901 rearranged or if @kbd{a s} needs to be typed after rewriting. (This one
5902 is rather tricky; the solution at the end of this chapter uses 6 rewrite
5903 rules. Hint: The @samp{constant(x)} condition tests whether @samp{x} is
5904 a number.) @xref{Rewrites Answer 6, 6}. (@bullet{})
5905
5906 Just for kicks, try adding the rule @code{2+3 := 6} to @code{EvalRules}.
5907 What happens? (Be sure to remove this rule afterward, or you might get
5908 a nasty surprise when you use Calc to balance your checkbook!)
5909
5910 @xref{Rewrite Rules}, for the whole story on rewrite rules.
5911
5912 @node Programming Tutorial, Answers to Exercises, Algebra Tutorial, Tutorial
5913 @section Programming Tutorial
5914
5915 @noindent
5916 The Calculator is written entirely in Emacs Lisp, a highly extensible
5917 language. If you know Lisp, you can program the Calculator to do
5918 anything you like. Rewrite rules also work as a powerful programming
5919 system. But Lisp and rewrite rules take a while to master, and often
5920 all you want to do is define a new function or repeat a command a few
5921 times. Calc has features that allow you to do these things easily.
5922
5923 One very limited form of programming is defining your own functions.
5924 Calc's @kbd{Z F} command allows you to define a function name and
5925 key sequence to correspond to any formula. Programming commands use
5926 the shift-@kbd{Z} prefix; the user commands they create use the lower
5927 case @kbd{z} prefix.
5928
5929 @smallexample
5930 @group
5931 1: 1 + x + x^2 / 2 + x^3 / 6 1: 1 + x + x^2 / 2 + x^3 / 6
5932 . .
5933
5934 ' 1 + x + x^2/2! + x^3/3! @key{RET} Z F e myexp @key{RET} @key{RET} @key{RET} y
5935 @end group
5936 @end smallexample
5937
5938 This polynomial is a Taylor series approximation to @samp{exp(x)}.
5939 The @kbd{Z F} command asks a number of questions. The above answers
5940 say that the key sequence for our function should be @kbd{z e}; the
5941 @kbd{M-x} equivalent should be @code{calc-myexp}; the name of the
5942 function in algebraic formulas should also be @code{myexp}; the
5943 default argument list @samp{(x)} is acceptable; and finally @kbd{y}
5944 answers the question ``leave it in symbolic form for non-constant
5945 arguments?''
5946
5947 @smallexample
5948 @group
5949 1: 1.3495 2: 1.3495 3: 1.3495
5950 . 1: 1.34986 2: 1.34986
5951 . 1: myexp(a + 1)
5952 .
5953
5954 .3 z e .3 E ' a+1 @key{RET} z e
5955 @end group
5956 @end smallexample
5957
5958 @noindent
5959 First we call our new @code{exp} approximation with 0.3 as an
5960 argument, and compare it with the true @code{exp} function. Then
5961 we note that, as requested, if we try to give @kbd{z e} an
5962 argument that isn't a plain number, it leaves the @code{myexp}
5963 function call in symbolic form. If we had answered @kbd{n} to the
5964 final question, @samp{myexp(a + 1)} would have evaluated by plugging
5965 in @samp{a + 1} for @samp{x} in the defining formula.
5966
5967 @cindex Sine integral Si(x)
5968 @ignore
5969 @starindex
5970 @end ignore
5971 @tindex Si
5972 (@bullet{}) @strong{Exercise 1.} The ``sine integral'' function
5973 @texline @math{{\rm Si}(x)}
5974 @infoline @expr{Si(x)}
5975 is defined as the integral of @samp{sin(t)/t} for
5976 @expr{t = 0} to @expr{x} in radians. (It was invented because this
5977 integral has no solution in terms of basic functions; if you give it
5978 to Calc's @kbd{a i} command, it will ponder it for a long time and then
5979 give up.) We can use the numerical integration command, however,
5980 which in algebraic notation is written like @samp{ninteg(f(t), t, 0, x)}
5981 with any integrand @samp{f(t)}. Define a @kbd{z s} command and
5982 @code{Si} function that implement this. You will need to edit the
5983 default argument list a bit. As a test, @samp{Si(1)} should return
5984 0.946083. (If you don't get this answer, you might want to check that
5985 Calc is in Radians mode. Also, @code{ninteg} will run a lot faster if
5986 you reduce the precision to, say, six digits beforehand.)
5987 @xref{Programming Answer 1, 1}. (@bullet{})
5988
5989 The simplest way to do real ``programming'' of Emacs is to define a
5990 @dfn{keyboard macro}. A keyboard macro is simply a sequence of
5991 keystrokes which Emacs has stored away and can play back on demand.
5992 For example, if you find yourself typing @kbd{H a S x @key{RET}} often,
5993 you may wish to program a keyboard macro to type this for you.
5994
5995 @smallexample
5996 @group
5997 1: y = sqrt(x) 1: x = y^2
5998 . .
5999
6000 ' y=sqrt(x) @key{RET} C-x ( H a S x @key{RET} C-x )
6001
6002 1: y = cos(x) 1: x = s1 arccos(y) + 2 pi n1
6003 . .
6004
6005 ' y=cos(x) @key{RET} X
6006 @end group
6007 @end smallexample
6008
6009 @noindent
6010 When you type @kbd{C-x (}, Emacs begins recording. But it is also
6011 still ready to execute your keystrokes, so you're really ``training''
6012 Emacs by walking it through the procedure once. When you type
6013 @w{@kbd{C-x )}}, the macro is recorded. You can now type @kbd{X} to
6014 re-execute the same keystrokes.
6015
6016 You can give a name to your macro by typing @kbd{Z K}.
6017
6018 @smallexample
6019 @group
6020 1: . 1: y = x^4 1: x = s2 sqrt(s1 sqrt(y))
6021 . .
6022
6023 Z K x @key{RET} ' y=x^4 @key{RET} z x
6024 @end group
6025 @end smallexample
6026
6027 @noindent
6028 Notice that we use shift-@kbd{Z} to define the command, and lower-case
6029 @kbd{z} to call it up.
6030
6031 Keyboard macros can call other macros.
6032
6033 @smallexample
6034 @group
6035 1: abs(x) 1: x = s1 y 1: 2 / x 1: x = 2 / y
6036 . . . .
6037
6038 ' abs(x) @key{RET} C-x ( ' y @key{RET} a = z x C-x ) ' 2/x @key{RET} X
6039 @end group
6040 @end smallexample
6041
6042 (@bullet{}) @strong{Exercise 2.} Define a keyboard macro to negate
6043 the item in level 3 of the stack, without disturbing the rest of
6044 the stack. @xref{Programming Answer 2, 2}. (@bullet{})
6045
6046 (@bullet{}) @strong{Exercise 3.} Define keyboard macros to compute
6047 the following functions:
6048
6049 @enumerate
6050 @item
6051 Compute
6052 @texline @math{\displaystyle{\sin x \over x}},
6053 @infoline @expr{sin(x) / x},
6054 where @expr{x} is the number on the top of the stack.
6055
6056 @item
6057 Compute the base-@expr{b} logarithm, just like the @kbd{B} key except
6058 the arguments are taken in the opposite order.
6059
6060 @item
6061 Produce a vector of integers from 1 to the integer on the top of
6062 the stack.
6063 @end enumerate
6064 @noindent
6065 @xref{Programming Answer 3, 3}. (@bullet{})
6066
6067 (@bullet{}) @strong{Exercise 4.} Define a keyboard macro to compute
6068 the average (mean) value of a list of numbers.
6069 @xref{Programming Answer 4, 4}. (@bullet{})
6070
6071 In many programs, some of the steps must execute several times.
6072 Calc has @dfn{looping} commands that allow this. Loops are useful
6073 inside keyboard macros, but actually work at any time.
6074
6075 @smallexample
6076 @group
6077 1: x^6 2: x^6 1: 360 x^2
6078 . 1: 4 .
6079 .
6080
6081 ' x^6 @key{RET} 4 Z < a d x @key{RET} Z >
6082 @end group
6083 @end smallexample
6084
6085 @noindent
6086 Here we have computed the fourth derivative of @expr{x^6} by
6087 enclosing a derivative command in a ``repeat loop'' structure.
6088 This structure pops a repeat count from the stack, then
6089 executes the body of the loop that many times.
6090
6091 If you make a mistake while entering the body of the loop,
6092 type @w{@kbd{Z C-g}} to cancel the loop command.
6093
6094 @cindex Fibonacci numbers
6095 Here's another example:
6096
6097 @smallexample
6098 @group
6099 3: 1 2: 10946
6100 2: 1 1: 17711
6101 1: 20 .
6102 .
6103
6104 1 @key{RET} @key{RET} 20 Z < @key{TAB} C-j + Z >
6105 @end group
6106 @end smallexample
6107
6108 @noindent
6109 The numbers in levels 2 and 1 should be the 21st and 22nd Fibonacci
6110 numbers, respectively. (To see what's going on, try a few repetitions
6111 of the loop body by hand; @kbd{C-j}, also on the Line-Feed or @key{LFD}
6112 key if you have one, makes a copy of the number in level 2.)
6113
6114 @cindex Golden ratio
6115 @cindex Phi, golden ratio
6116 A fascinating property of the Fibonacci numbers is that the @expr{n}th
6117 Fibonacci number can be found directly by computing
6118 @texline @math{\phi^n / \sqrt{5}}
6119 @infoline @expr{phi^n / sqrt(5)}
6120 and then rounding to the nearest integer, where
6121 @texline @math{\phi} (``phi''),
6122 @infoline @expr{phi},
6123 the ``golden ratio,'' is
6124 @texline @math{(1 + \sqrt{5}) / 2}.
6125 @infoline @expr{(1 + sqrt(5)) / 2}.
6126 (For convenience, this constant is available from the @code{phi}
6127 variable, or the @kbd{I H P} command.)
6128
6129 @smallexample
6130 @group
6131 1: 1.61803 1: 24476.0000409 1: 10945.9999817 1: 10946
6132 . . . .
6133
6134 I H P 21 ^ 5 Q / R
6135 @end group
6136 @end smallexample
6137
6138 @cindex Continued fractions
6139 (@bullet{}) @strong{Exercise 5.} The @dfn{continued fraction}
6140 representation of
6141 @texline @math{\phi}
6142 @infoline @expr{phi}
6143 is
6144 @texline @math{1 + 1/(1 + 1/(1 + 1/( \ldots )))}.
6145 @infoline @expr{1 + 1/(1 + 1/(1 + 1/( ...@: )))}.
6146 We can compute an approximate value by carrying this however far
6147 and then replacing the innermost
6148 @texline @math{1/( \ldots )}
6149 @infoline @expr{1/( ...@: )}
6150 by 1. Approximate
6151 @texline @math{\phi}
6152 @infoline @expr{phi}
6153 using a twenty-term continued fraction.
6154 @xref{Programming Answer 5, 5}. (@bullet{})
6155
6156 (@bullet{}) @strong{Exercise 6.} Linear recurrences like the one for
6157 Fibonacci numbers can be expressed in terms of matrices. Given a
6158 vector @w{@expr{[a, b]}} determine a matrix which, when multiplied by this
6159 vector, produces the vector @expr{[b, c]}, where @expr{a}, @expr{b} and
6160 @expr{c} are three successive Fibonacci numbers. Now write a program
6161 that, given an integer @expr{n}, computes the @expr{n}th Fibonacci number
6162 using matrix arithmetic. @xref{Programming Answer 6, 6}. (@bullet{})
6163
6164 @cindex Harmonic numbers
6165 A more sophisticated kind of loop is the @dfn{for} loop. Suppose
6166 we wish to compute the 20th ``harmonic'' number, which is equal to
6167 the sum of the reciprocals of the integers from 1 to 20.
6168
6169 @smallexample
6170 @group
6171 3: 0 1: 3.597739
6172 2: 1 .
6173 1: 20
6174 .
6175
6176 0 @key{RET} 1 @key{RET} 20 Z ( & + 1 Z )
6177 @end group
6178 @end smallexample
6179
6180 @noindent
6181 The ``for'' loop pops two numbers, the lower and upper limits, then
6182 repeats the body of the loop as an internal counter increases from
6183 the lower limit to the upper one. Just before executing the loop
6184 body, it pushes the current loop counter. When the loop body
6185 finishes, it pops the ``step,'' i.e., the amount by which to
6186 increment the loop counter. As you can see, our loop always
6187 uses a step of one.
6188
6189 This harmonic number function uses the stack to hold the running
6190 total as well as for the various loop housekeeping functions. If
6191 you find this disorienting, you can sum in a variable instead:
6192
6193 @smallexample
6194 @group
6195 1: 0 2: 1 . 1: 3.597739
6196 . 1: 20 .
6197 .
6198
6199 0 t 7 1 @key{RET} 20 Z ( & s + 7 1 Z ) r 7
6200 @end group
6201 @end smallexample
6202
6203 @noindent
6204 The @kbd{s +} command adds the top-of-stack into the value in a
6205 variable (and removes that value from the stack).
6206
6207 It's worth noting that many jobs that call for a ``for'' loop can
6208 also be done more easily by Calc's high-level operations. Two
6209 other ways to compute harmonic numbers are to use vector mapping
6210 and reduction (@kbd{v x 20}, then @w{@kbd{V M &}}, then @kbd{V R +}),
6211 or to use the summation command @kbd{a +}. Both of these are
6212 probably easier than using loops. However, there are some
6213 situations where loops really are the way to go:
6214
6215 (@bullet{}) @strong{Exercise 7.} Use a ``for'' loop to find the first
6216 harmonic number which is greater than 4.0.
6217 @xref{Programming Answer 7, 7}. (@bullet{})
6218
6219 Of course, if we're going to be using variables in our programs,
6220 we have to worry about the programs clobbering values that the
6221 caller was keeping in those same variables. This is easy to
6222 fix, though:
6223
6224 @smallexample
6225 @group
6226 . 1: 0.6667 1: 0.6667 3: 0.6667
6227 . . 2: 3.597739
6228 1: 0.6667
6229 .
6230
6231 Z ` p 4 @key{RET} 2 @key{RET} 3 / s 7 s s a @key{RET} Z ' r 7 s r a @key{RET}
6232 @end group
6233 @end smallexample
6234
6235 @noindent
6236 When we type @kbd{Z `} (that's a back-quote character), Calc saves
6237 its mode settings and the contents of the ten ``quick variables''
6238 for later reference. When we type @kbd{Z '} (that's an apostrophe
6239 now), Calc restores those saved values. Thus the @kbd{p 4} and
6240 @kbd{s 7} commands have no effect outside this sequence. Wrapping
6241 this around the body of a keyboard macro ensures that it doesn't
6242 interfere with what the user of the macro was doing. Notice that
6243 the contents of the stack, and the values of named variables,
6244 survive past the @kbd{Z '} command.
6245
6246 @cindex Bernoulli numbers, approximate
6247 The @dfn{Bernoulli numbers} are a sequence with the interesting
6248 property that all of the odd Bernoulli numbers are zero, and the
6249 even ones, while difficult to compute, can be roughly approximated
6250 by the formula
6251 @texline @math{\displaystyle{2 n! \over (2 \pi)^n}}.
6252 @infoline @expr{2 n!@: / (2 pi)^n}.
6253 Let's write a keyboard macro to compute (approximate) Bernoulli numbers.
6254 (Calc has a command, @kbd{k b}, to compute exact Bernoulli numbers, but
6255 this command is very slow for large @expr{n} since the higher Bernoulli
6256 numbers are very large fractions.)
6257
6258 @smallexample
6259 @group
6260 1: 10 1: 0.0756823
6261 . .
6262
6263 10 C-x ( @key{RET} 2 % Z [ @key{DEL} 0 Z : ' 2 $! / (2 pi)^$ @key{RET} = Z ] C-x )
6264 @end group
6265 @end smallexample
6266
6267 @noindent
6268 You can read @kbd{Z [} as ``then,'' @kbd{Z :} as ``else,'' and
6269 @kbd{Z ]} as ``end-if.'' There is no need for an explicit ``if''
6270 command. For the purposes of @w{@kbd{Z [}}, the condition is ``true''
6271 if the value it pops from the stack is a nonzero number, or ``false''
6272 if it pops zero or something that is not a number (like a formula).
6273 Here we take our integer argument modulo 2; this will be nonzero
6274 if we're asking for an odd Bernoulli number.
6275
6276 The actual tenth Bernoulli number is @expr{5/66}.
6277
6278 @smallexample
6279 @group
6280 3: 0.0756823 1: 0 1: 0.25305 1: 0 1: 1.16659
6281 2: 5:66 . . . .
6282 1: 0.0757575
6283 .
6284
6285 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
6286 @end group
6287 @end smallexample
6288
6289 Just to exercise loops a bit more, let's compute a table of even
6290 Bernoulli numbers.
6291
6292 @smallexample
6293 @group
6294 3: [] 1: [0.10132, 0.03079, 0.02340, 0.033197, ...]
6295 2: 2 .
6296 1: 30
6297 .
6298
6299 [ ] 2 @key{RET} 30 Z ( X | 2 Z )
6300 @end group
6301 @end smallexample
6302
6303 @noindent
6304 The vertical-bar @kbd{|} is the vector-concatenation command. When
6305 we execute it, the list we are building will be in stack level 2
6306 (initially this is an empty list), and the next Bernoulli number
6307 will be in level 1. The effect is to append the Bernoulli number
6308 onto the end of the list. (To create a table of exact fractional
6309 Bernoulli numbers, just replace @kbd{X} with @kbd{k b} in the above
6310 sequence of keystrokes.)
6311
6312 With loops and conditionals, you can program essentially anything
6313 in Calc. One other command that makes looping easier is @kbd{Z /},
6314 which takes a condition from the stack and breaks out of the enclosing
6315 loop if the condition is true (non-zero). You can use this to make
6316 ``while'' and ``until'' style loops.
6317
6318 If you make a mistake when entering a keyboard macro, you can edit
6319 it using @kbd{Z E}. First, you must attach it to a key with @kbd{Z K}.
6320 One technique is to enter a throwaway dummy definition for the macro,
6321 then enter the real one in the edit command.
6322
6323 @smallexample
6324 @group
6325 1: 3 1: 3 Calc Macro Edit Mode.
6326 . . Original keys: 1 <return> 2 +
6327
6328 1 ;; calc digits
6329 RET ;; calc-enter
6330 2 ;; calc digits
6331 + ;; calc-plus
6332
6333 C-x ( 1 @key{RET} 2 + C-x ) Z K h @key{RET} Z E h
6334 @end group
6335 @end smallexample
6336
6337 @noindent
6338 A keyboard macro is stored as a pure keystroke sequence. The
6339 @file{edmacro} package (invoked by @kbd{Z E}) scans along the
6340 macro and tries to decode it back into human-readable steps.
6341 Descriptions of the keystrokes are given as comments, which begin with
6342 @samp{;;}, and which are ignored when the edited macro is saved.
6343 Spaces and line breaks are also ignored when the edited macro is saved.
6344 To enter a space into the macro, type @code{SPC}. All the special
6345 characters @code{RET}, @code{LFD}, @code{TAB}, @code{SPC}, @code{DEL},
6346 and @code{NUL} must be written in all uppercase, as must the prefixes
6347 @code{C-} and @code{M-}.
6348
6349 Let's edit in a new definition, for computing harmonic numbers.
6350 First, erase the four lines of the old definition. Then, type
6351 in the new definition (or use Emacs @kbd{M-w} and @kbd{C-y} commands
6352 to copy it from this page of the Info file; you can of course skip
6353 typing the comments, which begin with @samp{;;}).
6354
6355 @smallexample
6356 Z` ;; calc-kbd-push (Save local values)
6357 0 ;; calc digits (Push a zero onto the stack)
6358 st ;; calc-store-into (Store it in the following variable)
6359 1 ;; calc quick variable (Quick variable q1)
6360 1 ;; calc digits (Initial value for the loop)
6361 TAB ;; calc-roll-down (Swap initial and final)
6362 Z( ;; calc-kbd-for (Begin the "for" loop)
6363 & ;; calc-inv (Take the reciprocal)
6364 s+ ;; calc-store-plus (Add to the following variable)
6365 1 ;; calc quick variable (Quick variable q1)
6366 1 ;; calc digits (The loop step is 1)
6367 Z) ;; calc-kbd-end-for (End the "for" loop)
6368 sr ;; calc-recall (Recall the final accumulated value)
6369 1 ;; calc quick variable (Quick variable q1)
6370 Z' ;; calc-kbd-pop (Restore values)
6371 @end smallexample
6372
6373 @noindent
6374 Press @kbd{C-c C-c} to finish editing and return to the Calculator.
6375
6376 @smallexample
6377 @group
6378 1: 20 1: 3.597739
6379 . .
6380
6381 20 z h
6382 @end group
6383 @end smallexample
6384
6385 The @file{edmacro} package defines a handy @code{read-kbd-macro} command
6386 which reads the current region of the current buffer as a sequence of
6387 keystroke names, and defines that sequence on the @kbd{X}
6388 (and @kbd{C-x e}) key. Because this is so useful, Calc puts this
6389 command on the @kbd{M-# m} key. Try reading in this macro in the
6390 following form: Press @kbd{C-@@} (or @kbd{C-@key{SPC}}) at
6391 one end of the text below, then type @kbd{M-# m} at the other.
6392
6393 @example
6394 @group
6395 Z ` 0 t 1
6396 1 TAB
6397 Z ( & s + 1 1 Z )
6398 r 1
6399 Z '
6400 @end group
6401 @end example
6402
6403 (@bullet{}) @strong{Exercise 8.} A general algorithm for solving
6404 equations numerically is @dfn{Newton's Method}. Given the equation
6405 @expr{f(x) = 0} for any function @expr{f}, and an initial guess
6406 @expr{x_0} which is reasonably close to the desired solution, apply
6407 this formula over and over:
6408
6409 @ifinfo
6410 @example
6411 new_x = x - f(x)/f'(x)
6412 @end example
6413 @end ifinfo
6414 @tex
6415 \beforedisplay
6416 $$ x_{\rm new} = x - {f(x) \over f'(x)} $$
6417 \afterdisplay
6418 @end tex
6419
6420 @noindent
6421 where @expr{f'(x)} is the derivative of @expr{f}. The @expr{x}
6422 values will quickly converge to a solution, i.e., eventually
6423 @texline @math{x_{\rm new}}
6424 @infoline @expr{new_x}
6425 and @expr{x} will be equal to within the limits
6426 of the current precision. Write a program which takes a formula
6427 involving the variable @expr{x}, and an initial guess @expr{x_0},
6428 on the stack, and produces a value of @expr{x} for which the formula
6429 is zero. Use it to find a solution of
6430 @texline @math{\sin(\cos x) = 0.5}
6431 @infoline @expr{sin(cos(x)) = 0.5}
6432 near @expr{x = 4.5}. (Use angles measured in radians.) Note that
6433 the built-in @w{@kbd{a R}} (@code{calc-find-root}) command uses Newton's
6434 method when it is able. @xref{Programming Answer 8, 8}. (@bullet{})
6435
6436 @cindex Digamma function
6437 @cindex Gamma constant, Euler's
6438 @cindex Euler's gamma constant
6439 (@bullet{}) @strong{Exercise 9.} The @dfn{digamma} function
6440 @texline @math{\psi(z) (``psi'')}
6441 @infoline @expr{psi(z)}
6442 is defined as the derivative of
6443 @texline @math{\ln \Gamma(z)}.
6444 @infoline @expr{ln(gamma(z))}.
6445 For large values of @expr{z}, it can be approximated by the infinite sum
6446
6447 @ifinfo
6448 @example
6449 psi(z) ~= ln(z) - 1/2z - sum(bern(2 n) / 2 n z^(2 n), n, 1, inf)
6450 @end example
6451 @end ifinfo
6452 @tex
6453 \beforedisplay
6454 $$ \psi(z) \approx \ln z - {1\over2z} -
6455 \sum_{n=1}^\infty {\code{bern}(2 n) \over 2 n z^{2n}}
6456 $$
6457 \afterdisplay
6458 @end tex
6459
6460 @noindent
6461 where
6462 @texline @math{\sum}
6463 @infoline @expr{sum}
6464 represents the sum over @expr{n} from 1 to infinity
6465 (or to some limit high enough to give the desired accuracy), and
6466 the @code{bern} function produces (exact) Bernoulli numbers.
6467 While this sum is not guaranteed to converge, in practice it is safe.
6468 An interesting mathematical constant is Euler's gamma, which is equal
6469 to about 0.5772. One way to compute it is by the formula,
6470 @texline @math{\gamma = -\psi(1)}.
6471 @infoline @expr{gamma = -psi(1)}.
6472 Unfortunately, 1 isn't a large enough argument
6473 for the above formula to work (5 is a much safer value for @expr{z}).
6474 Fortunately, we can compute
6475 @texline @math{\psi(1)}
6476 @infoline @expr{psi(1)}
6477 from
6478 @texline @math{\psi(5)}
6479 @infoline @expr{psi(5)}
6480 using the recurrence
6481 @texline @math{\psi(z+1) = \psi(z) + {1 \over z}}.
6482 @infoline @expr{psi(z+1) = psi(z) + 1/z}.
6483 Your task: Develop a program to compute
6484 @texline @math{\psi(z)};
6485 @infoline @expr{psi(z)};
6486 it should ``pump up'' @expr{z}
6487 if necessary to be greater than 5, then use the above summation
6488 formula. Use looping commands to compute the sum. Use your function
6489 to compute
6490 @texline @math{\gamma}
6491 @infoline @expr{gamma}
6492 to twelve decimal places. (Calc has a built-in command
6493 for Euler's constant, @kbd{I P}, which you can use to check your answer.)
6494 @xref{Programming Answer 9, 9}. (@bullet{})
6495
6496 @cindex Polynomial, list of coefficients
6497 (@bullet{}) @strong{Exercise 10.} Given a polynomial in @expr{x} and
6498 a number @expr{m} on the stack, where the polynomial is of degree
6499 @expr{m} or less (i.e., does not have any terms higher than @expr{x^m}),
6500 write a program to convert the polynomial into a list-of-coefficients
6501 notation. For example, @expr{5 x^4 + (x + 1)^2} with @expr{m = 6}
6502 should produce the list @expr{[1, 2, 1, 0, 5, 0, 0]}. Also develop
6503 a way to convert from this form back to the standard algebraic form.
6504 @xref{Programming Answer 10, 10}. (@bullet{})
6505
6506 @cindex Recursion
6507 (@bullet{}) @strong{Exercise 11.} The @dfn{Stirling numbers of the
6508 first kind} are defined by the recurrences,
6509
6510 @ifinfo
6511 @example
6512 s(n,n) = 1 for n >= 0,
6513 s(n,0) = 0 for n > 0,
6514 s(n+1,m) = s(n,m-1) - n s(n,m) for n >= m >= 1.
6515 @end example
6516 @end ifinfo
6517 @tex
6518 \turnoffactive
6519 \beforedisplay
6520 $$ \eqalign{ s(n,n) &= 1 \qquad \hbox{for } n \ge 0, \cr
6521 s(n,0) &= 0 \qquad \hbox{for } n > 0, \cr
6522 s(n+1,m) &= s(n,m-1) - n \, s(n,m) \qquad
6523 \hbox{for } n \ge m \ge 1.}
6524 $$
6525 \afterdisplay
6526 \vskip5pt
6527 (These numbers are also sometimes written $\displaystyle{n \brack m}$.)
6528 @end tex
6529
6530 This can be implemented using a @dfn{recursive} program in Calc; the
6531 program must invoke itself in order to calculate the two righthand
6532 terms in the general formula. Since it always invokes itself with
6533 ``simpler'' arguments, it's easy to see that it must eventually finish
6534 the computation. Recursion is a little difficult with Emacs keyboard
6535 macros since the macro is executed before its definition is complete.
6536 So here's the recommended strategy: Create a ``dummy macro'' and assign
6537 it to a key with, e.g., @kbd{Z K s}. Now enter the true definition,
6538 using the @kbd{z s} command to call itself recursively, then assign it
6539 to the same key with @kbd{Z K s}. Now the @kbd{z s} command will run
6540 the complete recursive program. (Another way is to use @w{@kbd{Z E}}
6541 or @kbd{M-# m} (@code{read-kbd-macro}) to read the whole macro at once,
6542 thus avoiding the ``training'' phase.) The task: Write a program
6543 that computes Stirling numbers of the first kind, given @expr{n} and
6544 @expr{m} on the stack. Test it with @emph{small} inputs like
6545 @expr{s(4,2)}. (There is a built-in command for Stirling numbers,
6546 @kbd{k s}, which you can use to check your answers.)
6547 @xref{Programming Answer 11, 11}. (@bullet{})
6548
6549 The programming commands we've seen in this part of the tutorial
6550 are low-level, general-purpose operations. Often you will find
6551 that a higher-level function, such as vector mapping or rewrite
6552 rules, will do the job much more easily than a detailed, step-by-step
6553 program can:
6554
6555 (@bullet{}) @strong{Exercise 12.} Write another program for
6556 computing Stirling numbers of the first kind, this time using
6557 rewrite rules. Once again, @expr{n} and @expr{m} should be taken
6558 from the stack. @xref{Programming Answer 12, 12}. (@bullet{})
6559
6560 @example
6561
6562 @end example
6563 This ends the tutorial section of the Calc manual. Now you know enough
6564 about Calc to use it effectively for many kinds of calculations. But
6565 Calc has many features that were not even touched upon in this tutorial.
6566 @c [not-split]
6567 The rest of this manual tells the whole story.
6568 @c [when-split]
6569 @c Volume II of this manual, the @dfn{Calc Reference}, tells the whole story.
6570
6571 @page
6572 @node Answers to Exercises, , Programming Tutorial, Tutorial
6573 @section Answers to Exercises
6574
6575 @noindent
6576 This section includes answers to all the exercises in the Calc tutorial.
6577
6578 @menu
6579 * RPN Answer 1:: 1 @key{RET} 2 @key{RET} 3 @key{RET} 4 + * -
6580 * RPN Answer 2:: 2*4 + 7*9.5 + 5/4
6581 * RPN Answer 3:: Operating on levels 2 and 3
6582 * RPN Answer 4:: Joe's complex problems
6583 * Algebraic Answer 1:: Simulating Q command
6584 * Algebraic Answer 2:: Joe's algebraic woes
6585 * Algebraic Answer 3:: 1 / 0
6586 * Modes Answer 1:: 3#0.1 = 3#0.0222222?
6587 * Modes Answer 2:: 16#f.e8fe15
6588 * Modes Answer 3:: Joe's rounding bug
6589 * Modes Answer 4:: Why floating point?
6590 * Arithmetic Answer 1:: Why the \ command?
6591 * Arithmetic Answer 2:: Tripping up the B command
6592 * Vector Answer 1:: Normalizing a vector
6593 * Vector Answer 2:: Average position
6594 * Matrix Answer 1:: Row and column sums
6595 * Matrix Answer 2:: Symbolic system of equations
6596 * Matrix Answer 3:: Over-determined system
6597 * List Answer 1:: Powers of two
6598 * List Answer 2:: Least-squares fit with matrices
6599 * List Answer 3:: Geometric mean
6600 * List Answer 4:: Divisor function
6601 * List Answer 5:: Duplicate factors
6602 * List Answer 6:: Triangular list
6603 * List Answer 7:: Another triangular list
6604 * List Answer 8:: Maximum of Bessel function
6605 * List Answer 9:: Integers the hard way
6606 * List Answer 10:: All elements equal
6607 * List Answer 11:: Estimating pi with darts
6608 * List Answer 12:: Estimating pi with matchsticks
6609 * List Answer 13:: Hash codes
6610 * List Answer 14:: Random walk
6611 * Types Answer 1:: Square root of pi times rational
6612 * Types Answer 2:: Infinities
6613 * Types Answer 3:: What can "nan" be?
6614 * Types Answer 4:: Abbey Road
6615 * Types Answer 5:: Friday the 13th
6616 * Types Answer 6:: Leap years
6617 * Types Answer 7:: Erroneous donut
6618 * Types Answer 8:: Dividing intervals
6619 * Types Answer 9:: Squaring intervals
6620 * Types Answer 10:: Fermat's primality test
6621 * Types Answer 11:: pi * 10^7 seconds
6622 * Types Answer 12:: Abbey Road on CD
6623 * Types Answer 13:: Not quite pi * 10^7 seconds
6624 * Types Answer 14:: Supercomputers and c
6625 * Types Answer 15:: Sam the Slug
6626 * Algebra Answer 1:: Squares and square roots
6627 * Algebra Answer 2:: Building polynomial from roots
6628 * Algebra Answer 3:: Integral of x sin(pi x)
6629 * Algebra Answer 4:: Simpson's rule
6630 * Rewrites Answer 1:: Multiplying by conjugate
6631 * Rewrites Answer 2:: Alternative fib rule
6632 * Rewrites Answer 3:: Rewriting opt(a) + opt(b) x
6633 * Rewrites Answer 4:: Sequence of integers
6634 * Rewrites Answer 5:: Number of terms in sum
6635 * Rewrites Answer 6:: Truncated Taylor series
6636 * Programming Answer 1:: Fresnel's C(x)
6637 * Programming Answer 2:: Negate third stack element
6638 * Programming Answer 3:: Compute sin(x) / x, etc.
6639 * Programming Answer 4:: Average value of a list
6640 * Programming Answer 5:: Continued fraction phi
6641 * Programming Answer 6:: Matrix Fibonacci numbers
6642 * Programming Answer 7:: Harmonic number greater than 4
6643 * Programming Answer 8:: Newton's method
6644 * Programming Answer 9:: Digamma function
6645 * Programming Answer 10:: Unpacking a polynomial
6646 * Programming Answer 11:: Recursive Stirling numbers
6647 * Programming Answer 12:: Stirling numbers with rewrites
6648 @end menu
6649
6650 @c The following kludgery prevents the individual answers from
6651 @c being entered on the table of contents.
6652 @tex
6653 \global\let\oldwrite=\write
6654 \gdef\skipwrite#1#2{\let\write=\oldwrite}
6655 \global\let\oldchapternofonts=\chapternofonts
6656 \gdef\chapternofonts{\let\write=\skipwrite\oldchapternofonts}
6657 @end tex
6658
6659 @node RPN Answer 1, RPN Answer 2, Answers to Exercises, Answers to Exercises
6660 @subsection RPN Tutorial Exercise 1
6661
6662 @noindent
6663 @kbd{1 @key{RET} 2 @key{RET} 3 @key{RET} 4 + * -}
6664
6665 The result is
6666 @texline @math{1 - (2 \times (3 + 4)) = -13}.
6667 @infoline @expr{1 - (2 * (3 + 4)) = -13}.
6668
6669 @node RPN Answer 2, RPN Answer 3, RPN Answer 1, Answers to Exercises
6670 @subsection RPN Tutorial Exercise 2
6671
6672 @noindent
6673 @texline @math{2\times4 + 7\times9.5 + {5\over4} = 75.75}
6674 @infoline @expr{2*4 + 7*9.5 + 5/4 = 75.75}
6675
6676 After computing the intermediate term
6677 @texline @math{2\times4 = 8},
6678 @infoline @expr{2*4 = 8},
6679 you can leave that result on the stack while you compute the second
6680 term. With both of these results waiting on the stack you can then
6681 compute the final term, then press @kbd{+ +} to add everything up.
6682
6683 @smallexample
6684 @group
6685 2: 2 1: 8 3: 8 2: 8
6686 1: 4 . 2: 7 1: 66.5
6687 . 1: 9.5 .
6688 .
6689
6690 2 @key{RET} 4 * 7 @key{RET} 9.5 *
6691
6692 @end group
6693 @end smallexample
6694 @noindent
6695 @smallexample
6696 @group
6697 4: 8 3: 8 2: 8 1: 75.75
6698 3: 66.5 2: 66.5 1: 67.75 .
6699 2: 5 1: 1.25 .
6700 1: 4 .
6701 .
6702
6703 5 @key{RET} 4 / + +
6704 @end group
6705 @end smallexample
6706
6707 Alternatively, you could add the first two terms before going on
6708 with the third term.
6709
6710 @smallexample
6711 @group
6712 2: 8 1: 74.5 3: 74.5 2: 74.5 1: 75.75
6713 1: 66.5 . 2: 5 1: 1.25 .
6714 . 1: 4 .
6715 .
6716
6717 ... + 5 @key{RET} 4 / +
6718 @end group
6719 @end smallexample
6720
6721 On an old-style RPN calculator this second method would have the
6722 advantage of using only three stack levels. But since Calc's stack
6723 can grow arbitrarily large this isn't really an issue. Which method
6724 you choose is purely a matter of taste.
6725
6726 @node RPN Answer 3, RPN Answer 4, RPN Answer 2, Answers to Exercises
6727 @subsection RPN Tutorial Exercise 3
6728
6729 @noindent
6730 The @key{TAB} key provides a way to operate on the number in level 2.
6731
6732 @smallexample
6733 @group
6734 3: 10 3: 10 4: 10 3: 10 3: 10
6735 2: 20 2: 30 3: 30 2: 30 2: 21
6736 1: 30 1: 20 2: 20 1: 21 1: 30
6737 . . 1: 1 . .
6738 .
6739
6740 @key{TAB} 1 + @key{TAB}
6741 @end group
6742 @end smallexample
6743
6744 Similarly, @kbd{M-@key{TAB}} gives you access to the number in level 3.
6745
6746 @smallexample
6747 @group
6748 3: 10 3: 21 3: 21 3: 30 3: 11
6749 2: 21 2: 30 2: 30 2: 11 2: 21
6750 1: 30 1: 10 1: 11 1: 21 1: 30
6751 . . . . .
6752
6753 M-@key{TAB} 1 + M-@key{TAB} M-@key{TAB}
6754 @end group
6755 @end smallexample
6756
6757 @node RPN Answer 4, Algebraic Answer 1, RPN Answer 3, Answers to Exercises
6758 @subsection RPN Tutorial Exercise 4
6759
6760 @noindent
6761 Either @kbd{( 2 , 3 )} or @kbd{( 2 @key{SPC} 3 )} would have worked,
6762 but using both the comma and the space at once yields:
6763
6764 @smallexample
6765 @group
6766 1: ( ... 2: ( ... 1: (2, ... 2: (2, ... 2: (2, ...
6767 . 1: 2 . 1: (2, ... 1: (2, 3)
6768 . . .
6769
6770 ( 2 , @key{SPC} 3 )
6771 @end group
6772 @end smallexample
6773
6774 Joe probably tried to type @kbd{@key{TAB} @key{DEL}} to swap the
6775 extra incomplete object to the top of the stack and delete it.
6776 But a feature of Calc is that @key{DEL} on an incomplete object
6777 deletes just one component out of that object, so he had to press
6778 @key{DEL} twice to finish the job.
6779
6780 @smallexample
6781 @group
6782 2: (2, ... 2: (2, 3) 2: (2, 3) 1: (2, 3)
6783 1: (2, 3) 1: (2, ... 1: ( ... .
6784 . . .
6785
6786 @key{TAB} @key{DEL} @key{DEL}
6787 @end group
6788 @end smallexample
6789
6790 (As it turns out, deleting the second-to-top stack entry happens often
6791 enough that Calc provides a special key, @kbd{M-@key{DEL}}, to do just that.
6792 @kbd{M-@key{DEL}} is just like @kbd{@key{TAB} @key{DEL}}, except that it doesn't exhibit
6793 the ``feature'' that tripped poor Joe.)
6794
6795 @node Algebraic Answer 1, Algebraic Answer 2, RPN Answer 4, Answers to Exercises
6796 @subsection Algebraic Entry Tutorial Exercise 1
6797
6798 @noindent
6799 Type @kbd{' sqrt($) @key{RET}}.
6800
6801 If the @kbd{Q} key is broken, you could use @kbd{' $^0.5 @key{RET}}.
6802 Or, RPN style, @kbd{0.5 ^}.
6803
6804 (Actually, @samp{$^1:2}, using the fraction one-half as the power, is
6805 a closer equivalent, since @samp{9^0.5} yields @expr{3.0} whereas
6806 @samp{sqrt(9)} and @samp{9^1:2} yield the exact integer @expr{3}.)
6807
6808 @node Algebraic Answer 2, Algebraic Answer 3, Algebraic Answer 1, Answers to Exercises
6809 @subsection Algebraic Entry Tutorial Exercise 2
6810
6811 @noindent
6812 In the formula @samp{2 x (1+y)}, @samp{x} was interpreted as a function
6813 name with @samp{1+y} as its argument. Assigning a value to a variable
6814 has no relation to a function by the same name. Joe needed to use an
6815 explicit @samp{*} symbol here: @samp{2 x*(1+y)}.
6816
6817 @node Algebraic Answer 3, Modes Answer 1, Algebraic Answer 2, Answers to Exercises
6818 @subsection Algebraic Entry Tutorial Exercise 3
6819
6820 @noindent
6821 The result from @kbd{1 @key{RET} 0 /} will be the formula @expr{1 / 0}.
6822 The ``function'' @samp{/} cannot be evaluated when its second argument
6823 is zero, so it is left in symbolic form. When you now type @kbd{0 *},
6824 the result will be zero because Calc uses the general rule that ``zero
6825 times anything is zero.''
6826
6827 @c [fix-ref Infinities]
6828 The @kbd{m i} command enables an @dfn{Infinite mode} in which @expr{1 / 0}
6829 results in a special symbol that represents ``infinity.'' If you
6830 multiply infinity by zero, Calc uses another special new symbol to
6831 show that the answer is ``indeterminate.'' @xref{Infinities}, for
6832 further discussion of infinite and indeterminate values.
6833
6834 @node Modes Answer 1, Modes Answer 2, Algebraic Answer 3, Answers to Exercises
6835 @subsection Modes Tutorial Exercise 1
6836
6837 @noindent
6838 Calc always stores its numbers in decimal, so even though one-third has
6839 an exact base-3 representation (@samp{3#0.1}), it is still stored as
6840 0.3333333 (chopped off after 12 or however many decimal digits) inside
6841 the calculator's memory. When this inexact number is converted back
6842 to base 3 for display, it may still be slightly inexact. When we
6843 multiply this number by 3, we get 0.999999, also an inexact value.
6844
6845 When Calc displays a number in base 3, it has to decide how many digits
6846 to show. If the current precision is 12 (decimal) digits, that corresponds
6847 to @samp{12 / log10(3) = 25.15} base-3 digits. Because 25.15 is not an
6848 exact integer, Calc shows only 25 digits, with the result that stored
6849 numbers carry a little bit of extra information that may not show up on
6850 the screen. When Joe entered @samp{3#0.2}, the stored number 0.666666
6851 happened to round to a pleasing value when it lost that last 0.15 of a
6852 digit, but it was still inexact in Calc's memory. When he divided by 2,
6853 he still got the dreaded inexact value 0.333333. (Actually, he divided
6854 0.666667 by 2 to get 0.333334, which is why he got something a little
6855 higher than @code{3#0.1} instead of a little lower.)
6856
6857 If Joe didn't want to be bothered with all this, he could have typed
6858 @kbd{M-24 d n} to display with one less digit than the default. (If
6859 you give @kbd{d n} a negative argument, it uses default-minus-that,
6860 so @kbd{M-- d n} would be an easier way to get the same effect.) Those
6861 inexact results would still be lurking there, but they would now be
6862 rounded to nice, natural-looking values for display purposes. (Remember,
6863 @samp{0.022222} in base 3 is like @samp{0.099999} in base 10; rounding
6864 off one digit will round the number up to @samp{0.1}.) Depending on the
6865 nature of your work, this hiding of the inexactness may be a benefit or
6866 a danger. With the @kbd{d n} command, Calc gives you the choice.
6867
6868 Incidentally, another consequence of all this is that if you type
6869 @kbd{M-30 d n} to display more digits than are ``really there,''
6870 you'll see garbage digits at the end of the number. (In decimal
6871 display mode, with decimally-stored numbers, these garbage digits are
6872 always zero so they vanish and you don't notice them.) Because Calc
6873 rounds off that 0.15 digit, there is the danger that two numbers could
6874 be slightly different internally but still look the same. If you feel
6875 uneasy about this, set the @kbd{d n} precision to be a little higher
6876 than normal; you'll get ugly garbage digits, but you'll always be able
6877 to tell two distinct numbers apart.
6878
6879 An interesting side note is that most computers store their
6880 floating-point numbers in binary, and convert to decimal for display.
6881 Thus everyday programs have the same problem: Decimal 0.1 cannot be
6882 represented exactly in binary (try it: @kbd{0.1 d 2}), so @samp{0.1 * 10}
6883 comes out as an inexact approximation to 1 on some machines (though
6884 they generally arrange to hide it from you by rounding off one digit as
6885 we did above). Because Calc works in decimal instead of binary, you can
6886 be sure that numbers that look exact @emph{are} exact as long as you stay
6887 in decimal display mode.
6888
6889 It's not hard to show that any number that can be represented exactly
6890 in binary, octal, or hexadecimal is also exact in decimal, so the kinds
6891 of problems we saw in this exercise are likely to be severe only when
6892 you use a relatively unusual radix like 3.
6893
6894 @node Modes Answer 2, Modes Answer 3, Modes Answer 1, Answers to Exercises
6895 @subsection Modes Tutorial Exercise 2
6896
6897 If the radix is 15 or higher, we can't use the letter @samp{e} to mark
6898 the exponent because @samp{e} is interpreted as a digit. When Calc
6899 needs to display scientific notation in a high radix, it writes
6900 @samp{16#F.E8F*16.^15}. You can enter a number like this as an
6901 algebraic entry. Also, pressing @kbd{e} without any digits before it
6902 normally types @kbd{1e}, but in a high radix it types @kbd{16.^} and
6903 puts you in algebraic entry: @kbd{16#f.e8f @key{RET} e 15 @key{RET} *} is another
6904 way to enter this number.
6905
6906 The reason Calc puts a decimal point in the @samp{16.^} is to prevent
6907 huge integers from being generated if the exponent is large (consider
6908 @samp{16#1.23*16^1000}, where we compute @samp{16^1000} as a giant
6909 exact integer and then throw away most of the digits when we multiply
6910 it by the floating-point @samp{16#1.23}). While this wouldn't normally
6911 matter for display purposes, it could give you a nasty surprise if you
6912 copied that number into a file and later moved it back into Calc.
6913
6914 @node Modes Answer 3, Modes Answer 4, Modes Answer 2, Answers to Exercises
6915 @subsection Modes Tutorial Exercise 3
6916
6917 @noindent
6918 The answer he got was @expr{0.5000000000006399}.
6919
6920 The problem is not that the square operation is inexact, but that the
6921 sine of 45 that was already on the stack was accurate to only 12 places.
6922 Arbitrary-precision calculations still only give answers as good as
6923 their inputs.
6924
6925 The real problem is that there is no 12-digit number which, when
6926 squared, comes out to 0.5 exactly. The @kbd{f [} and @kbd{f ]}
6927 commands decrease or increase a number by one unit in the last
6928 place (according to the current precision). They are useful for
6929 determining facts like this.
6930
6931 @smallexample
6932 @group
6933 1: 0.707106781187 1: 0.500000000001
6934 . .
6935
6936 45 S 2 ^
6937
6938 @end group
6939 @end smallexample
6940 @noindent
6941 @smallexample
6942 @group
6943 1: 0.707106781187 1: 0.707106781186 1: 0.499999999999
6944 . . .
6945
6946 U @key{DEL} f [ 2 ^
6947 @end group
6948 @end smallexample
6949
6950 A high-precision calculation must be carried out in high precision
6951 all the way. The only number in the original problem which was known
6952 exactly was the quantity 45 degrees, so the precision must be raised
6953 before anything is done after the number 45 has been entered in order
6954 for the higher precision to be meaningful.
6955
6956 @node Modes Answer 4, Arithmetic Answer 1, Modes Answer 3, Answers to Exercises
6957 @subsection Modes Tutorial Exercise 4
6958
6959 @noindent
6960 Many calculations involve real-world quantities, like the width and
6961 height of a piece of wood or the volume of a jar. Such quantities
6962 can't be measured exactly anyway, and if the data that is input to
6963 a calculation is inexact, doing exact arithmetic on it is a waste
6964 of time.
6965
6966 Fractions become unwieldy after too many calculations have been
6967 done with them. For example, the sum of the reciprocals of the
6968 integers from 1 to 10 is 7381:2520. The sum from 1 to 30 is
6969 9304682830147:2329089562800. After a point it will take a long
6970 time to add even one more term to this sum, but a floating-point
6971 calculation of the sum will not have this problem.
6972
6973 Also, rational numbers cannot express the results of all calculations.
6974 There is no fractional form for the square root of two, so if you type
6975 @w{@kbd{2 Q}}, Calc has no choice but to give you a floating-point answer.
6976
6977 @node Arithmetic Answer 1, Arithmetic Answer 2, Modes Answer 4, Answers to Exercises
6978 @subsection Arithmetic Tutorial Exercise 1
6979
6980 @noindent
6981 Dividing two integers that are larger than the current precision may
6982 give a floating-point result that is inaccurate even when rounded
6983 down to an integer. Consider @expr{123456789 / 2} when the current
6984 precision is 6 digits. The true answer is @expr{61728394.5}, but
6985 with a precision of 6 this will be rounded to
6986 @texline @math{12345700.0/2.0 = 61728500.0}.
6987 @infoline @expr{12345700.@: / 2.@: = 61728500.}.
6988 The result, when converted to an integer, will be off by 106.
6989
6990 Here are two solutions: Raise the precision enough that the
6991 floating-point round-off error is strictly to the right of the
6992 decimal point. Or, convert to Fraction mode so that @expr{123456789 / 2}
6993 produces the exact fraction @expr{123456789:2}, which can be rounded
6994 down by the @kbd{F} command without ever switching to floating-point
6995 format.
6996
6997 @node Arithmetic Answer 2, Vector Answer 1, Arithmetic Answer 1, Answers to Exercises
6998 @subsection Arithmetic Tutorial Exercise 2
6999
7000 @noindent
7001 @kbd{27 @key{RET} 9 B} could give the exact result @expr{3:2}, but it
7002 does a floating-point calculation instead and produces @expr{1.5}.
7003
7004 Calc will find an exact result for a logarithm if the result is an integer
7005 or (when in Fraction mode) the reciprocal of an integer. But there is
7006 no efficient way to search the space of all possible rational numbers
7007 for an exact answer, so Calc doesn't try.
7008
7009 @node Vector Answer 1, Vector Answer 2, Arithmetic Answer 2, Answers to Exercises
7010 @subsection Vector Tutorial Exercise 1
7011
7012 @noindent
7013 Duplicate the vector, compute its length, then divide the vector
7014 by its length: @kbd{@key{RET} A /}.
7015
7016 @smallexample
7017 @group
7018 1: [1, 2, 3] 2: [1, 2, 3] 1: [0.27, 0.53, 0.80] 1: 1.
7019 . 1: 3.74165738677 . .
7020 .
7021
7022 r 1 @key{RET} A / A
7023 @end group
7024 @end smallexample
7025
7026 The final @kbd{A} command shows that the normalized vector does
7027 indeed have unit length.
7028
7029 @node Vector Answer 2, Matrix Answer 1, Vector Answer 1, Answers to Exercises
7030 @subsection Vector Tutorial Exercise 2
7031
7032 @noindent
7033 The average position is equal to the sum of the products of the
7034 positions times their corresponding probabilities. This is the
7035 definition of the dot product operation. So all you need to do
7036 is to put the two vectors on the stack and press @kbd{*}.
7037
7038 @node Matrix Answer 1, Matrix Answer 2, Vector Answer 2, Answers to Exercises
7039 @subsection Matrix Tutorial Exercise 1
7040
7041 @noindent
7042 The trick is to multiply by a vector of ones. Use @kbd{r 4 [1 1 1] *} to
7043 get the row sum. Similarly, use @kbd{[1 1] r 4 *} to get the column sum.
7044
7045 @node Matrix Answer 2, Matrix Answer 3, Matrix Answer 1, Answers to Exercises
7046 @subsection Matrix Tutorial Exercise 2
7047
7048 @ifinfo
7049 @example
7050 @group
7051 x + a y = 6
7052 x + b y = 10
7053 @end group
7054 @end example
7055 @end ifinfo
7056 @tex
7057 \turnoffactive
7058 \beforedisplay
7059 $$ \eqalign{ x &+ a y = 6 \cr
7060 x &+ b y = 10}
7061 $$
7062 \afterdisplay
7063 @end tex
7064
7065 Just enter the righthand side vector, then divide by the lefthand side
7066 matrix as usual.
7067
7068 @smallexample
7069 @group
7070 1: [6, 10] 2: [6, 10] 1: [6 - 4 a / (b - a), 4 / (b - a) ]
7071 . 1: [ [ 1, a ] .
7072 [ 1, b ] ]
7073 .
7074
7075 ' [6 10] @key{RET} ' [1 a; 1 b] @key{RET} /
7076 @end group
7077 @end smallexample
7078
7079 This can be made more readable using @kbd{d B} to enable Big display
7080 mode:
7081
7082 @smallexample
7083 @group
7084 4 a 4
7085 1: [6 - -----, -----]
7086 b - a b - a
7087 @end group
7088 @end smallexample
7089
7090 Type @kbd{d N} to return to Normal display mode afterwards.
7091
7092 @node Matrix Answer 3, List Answer 1, Matrix Answer 2, Answers to Exercises
7093 @subsection Matrix Tutorial Exercise 3
7094
7095 @noindent
7096 To solve
7097 @texline @math{A^T A \, X = A^T B},
7098 @infoline @expr{trn(A) * A * X = trn(A) * B},
7099 first we compute
7100 @texline @math{A' = A^T A}
7101 @infoline @expr{A2 = trn(A) * A}
7102 and
7103 @texline @math{B' = A^T B};
7104 @infoline @expr{B2 = trn(A) * B};
7105 now, we have a system
7106 @texline @math{A' X = B'}
7107 @infoline @expr{A2 * X = B2}
7108 which we can solve using Calc's @samp{/} command.
7109
7110 @ifinfo
7111 @example
7112 @group
7113 a + 2b + 3c = 6
7114 4a + 5b + 6c = 2
7115 7a + 6b = 3
7116 2a + 4b + 6c = 11
7117 @end group
7118 @end example
7119 @end ifinfo
7120 @tex
7121 \turnoffactive
7122 \beforedisplayh
7123 $$ \openup1\jot \tabskip=0pt plus1fil
7124 \halign to\displaywidth{\tabskip=0pt
7125 $\hfil#$&$\hfil{}#{}$&
7126 $\hfil#$&$\hfil{}#{}$&
7127 $\hfil#$&${}#\hfil$\tabskip=0pt plus1fil\cr
7128 a&+&2b&+&3c&=6 \cr
7129 4a&+&5b&+&6c&=2 \cr
7130 7a&+&6b& & &=3 \cr
7131 2a&+&4b&+&6c&=11 \cr}
7132 $$
7133 \afterdisplayh
7134 @end tex
7135
7136 The first step is to enter the coefficient matrix. We'll store it in
7137 quick variable number 7 for later reference. Next, we compute the
7138 @texline @math{B'}
7139 @infoline @expr{B2}
7140 vector.
7141
7142 @smallexample
7143 @group
7144 1: [ [ 1, 2, 3 ] 2: [ [ 1, 4, 7, 2 ] 1: [57, 84, 96]
7145 [ 4, 5, 6 ] [ 2, 5, 6, 4 ] .
7146 [ 7, 6, 0 ] [ 3, 6, 0, 6 ] ]
7147 [ 2, 4, 6 ] ] 1: [6, 2, 3, 11]
7148 . .
7149
7150 ' [1 2 3; 4 5 6; 7 6 0; 2 4 6] @key{RET} s 7 v t [6 2 3 11] *
7151 @end group
7152 @end smallexample
7153
7154 @noindent
7155 Now we compute the matrix
7156 @texline @math{A'}
7157 @infoline @expr{A2}
7158 and divide.
7159
7160 @smallexample
7161 @group
7162 2: [57, 84, 96] 1: [-11.64, 14.08, -3.64]
7163 1: [ [ 70, 72, 39 ] .
7164 [ 72, 81, 60 ]
7165 [ 39, 60, 81 ] ]
7166 .
7167
7168 r 7 v t r 7 * /
7169 @end group
7170 @end smallexample
7171
7172 @noindent
7173 (The actual computed answer will be slightly inexact due to
7174 round-off error.)
7175
7176 Notice that the answers are similar to those for the
7177 @texline @math{3\times3}
7178 @infoline 3x3
7179 system solved in the text. That's because the fourth equation that was
7180 added to the system is almost identical to the first one multiplied
7181 by two. (If it were identical, we would have gotten the exact same
7182 answer since the
7183 @texline @math{4\times3}
7184 @infoline 4x3
7185 system would be equivalent to the original
7186 @texline @math{3\times3}
7187 @infoline 3x3
7188 system.)
7189
7190 Since the first and fourth equations aren't quite equivalent, they
7191 can't both be satisfied at once. Let's plug our answers back into
7192 the original system of equations to see how well they match.
7193
7194 @smallexample
7195 @group
7196 2: [-11.64, 14.08, -3.64] 1: [5.6, 2., 3., 11.2]
7197 1: [ [ 1, 2, 3 ] .
7198 [ 4, 5, 6 ]
7199 [ 7, 6, 0 ]
7200 [ 2, 4, 6 ] ]
7201 .
7202
7203 r 7 @key{TAB} *
7204 @end group
7205 @end smallexample
7206
7207 @noindent
7208 This is reasonably close to our original @expr{B} vector,
7209 @expr{[6, 2, 3, 11]}.
7210
7211 @node List Answer 1, List Answer 2, Matrix Answer 3, Answers to Exercises
7212 @subsection List Tutorial Exercise 1
7213
7214 @noindent
7215 We can use @kbd{v x} to build a vector of integers. This needs to be
7216 adjusted to get the range of integers we desire. Mapping @samp{-}
7217 across the vector will accomplish this, although it turns out the
7218 plain @samp{-} key will work just as well.
7219
7220 @smallexample
7221 @group
7222 2: 2 2: 2
7223 1: [1, 2, 3, 4, 5, 6, 7, 8, 9] 1: [-4, -3, -2, -1, 0, 1, 2, 3, 4]
7224 . .
7225
7226 2 v x 9 @key{RET} 5 V M - or 5 -
7227 @end group
7228 @end smallexample
7229
7230 @noindent
7231 Now we use @kbd{V M ^} to map the exponentiation operator across the
7232 vector.
7233
7234 @smallexample
7235 @group
7236 1: [0.0625, 0.125, 0.25, 0.5, 1, 2, 4, 8, 16]
7237 .
7238
7239 V M ^
7240 @end group
7241 @end smallexample
7242
7243 @node List Answer 2, List Answer 3, List Answer 1, Answers to Exercises
7244 @subsection List Tutorial Exercise 2
7245
7246 @noindent
7247 Given @expr{x} and @expr{y} vectors in quick variables 1 and 2 as before,
7248 the first job is to form the matrix that describes the problem.
7249
7250 @ifinfo
7251 @example
7252 m*x + b*1 = y
7253 @end example
7254 @end ifinfo
7255 @tex
7256 \turnoffactive
7257 \beforedisplay
7258 $$ m \times x + b \times 1 = y $$
7259 \afterdisplay
7260 @end tex
7261
7262 Thus we want a
7263 @texline @math{19\times2}
7264 @infoline 19x2
7265 matrix with our @expr{x} vector as one column and
7266 ones as the other column. So, first we build the column of ones, then
7267 we combine the two columns to form our @expr{A} matrix.
7268
7269 @smallexample
7270 @group
7271 2: [1.34, 1.41, 1.49, ... ] 1: [ [ 1.34, 1 ]
7272 1: [1, 1, 1, ...] [ 1.41, 1 ]
7273 . [ 1.49, 1 ]
7274 @dots{}
7275
7276 r 1 1 v b 19 @key{RET} M-2 v p v t s 3
7277 @end group
7278 @end smallexample
7279
7280 @noindent
7281 Now we compute
7282 @texline @math{A^T y}
7283 @infoline @expr{trn(A) * y}
7284 and
7285 @texline @math{A^T A}
7286 @infoline @expr{trn(A) * A}
7287 and divide.
7288
7289 @smallexample
7290 @group
7291 1: [33.36554, 13.613] 2: [33.36554, 13.613]
7292 . 1: [ [ 98.0003, 41.63 ]
7293 [ 41.63, 19 ] ]
7294 .
7295
7296 v t r 2 * r 3 v t r 3 *
7297 @end group
7298 @end smallexample
7299
7300 @noindent
7301 (Hey, those numbers look familiar!)
7302
7303 @smallexample
7304 @group
7305 1: [0.52141679, -0.425978]
7306 .
7307
7308 /
7309 @end group
7310 @end smallexample
7311
7312 Since we were solving equations of the form
7313 @texline @math{m \times x + b \times 1 = y},
7314 @infoline @expr{m*x + b*1 = y},
7315 these numbers should be @expr{m} and @expr{b}, respectively. Sure
7316 enough, they agree exactly with the result computed using @kbd{V M} and
7317 @kbd{V R}!
7318
7319 The moral of this story: @kbd{V M} and @kbd{V R} will probably solve
7320 your problem, but there is often an easier way using the higher-level
7321 arithmetic functions!
7322
7323 @c [fix-ref Curve Fitting]
7324 In fact, there is a built-in @kbd{a F} command that does least-squares
7325 fits. @xref{Curve Fitting}.
7326
7327 @node List Answer 3, List Answer 4, List Answer 2, Answers to Exercises
7328 @subsection List Tutorial Exercise 3
7329
7330 @noindent
7331 Move to one end of the list and press @kbd{C-@@} (or @kbd{C-@key{SPC}} or
7332 whatever) to set the mark, then move to the other end of the list
7333 and type @w{@kbd{M-# g}}.
7334
7335 @smallexample
7336 @group
7337 1: [2.3, 6, 22, 15.1, 7, 15, 14, 7.5, 2.5]
7338 .
7339 @end group
7340 @end smallexample
7341
7342 To make things interesting, let's assume we don't know at a glance
7343 how many numbers are in this list. Then we could type:
7344
7345 @smallexample
7346 @group
7347 2: [2.3, 6, 22, ... ] 2: [2.3, 6, 22, ... ]
7348 1: [2.3, 6, 22, ... ] 1: 126356422.5
7349 . .
7350
7351 @key{RET} V R *
7352
7353 @end group
7354 @end smallexample
7355 @noindent
7356 @smallexample
7357 @group
7358 2: 126356422.5 2: 126356422.5 1: 7.94652913734
7359 1: [2.3, 6, 22, ... ] 1: 9 .
7360 . .
7361
7362 @key{TAB} v l I ^
7363 @end group
7364 @end smallexample
7365
7366 @noindent
7367 (The @kbd{I ^} command computes the @var{n}th root of a number.
7368 You could also type @kbd{& ^} to take the reciprocal of 9 and
7369 then raise the number to that power.)
7370
7371 @node List Answer 4, List Answer 5, List Answer 3, Answers to Exercises
7372 @subsection List Tutorial Exercise 4
7373
7374 @noindent
7375 A number @expr{j} is a divisor of @expr{n} if
7376 @texline @math{n \mathbin{\hbox{\code{\%}}} j = 0}.
7377 @infoline @samp{n % j = 0}.
7378 The first step is to get a vector that identifies the divisors.
7379
7380 @smallexample
7381 @group
7382 2: 30 2: [0, 0, 0, 2, ...] 1: [1, 1, 1, 0, ...]
7383 1: [1, 2, 3, 4, ...] 1: 0 .
7384 . .
7385
7386 30 @key{RET} v x 30 @key{RET} s 1 V M % 0 V M a = s 2
7387 @end group
7388 @end smallexample
7389
7390 @noindent
7391 This vector has 1's marking divisors of 30 and 0's marking non-divisors.
7392
7393 The zeroth divisor function is just the total number of divisors.
7394 The first divisor function is the sum of the divisors.
7395
7396 @smallexample
7397 @group
7398 1: 8 3: 8 2: 8 2: 8
7399 2: [1, 2, 3, 4, ...] 1: [1, 2, 3, 0, ...] 1: 72
7400 1: [1, 1, 1, 0, ...] . .
7401 .
7402
7403 V R + r 1 r 2 V M * V R +
7404 @end group
7405 @end smallexample
7406
7407 @noindent
7408 Once again, the last two steps just compute a dot product for which
7409 a simple @kbd{*} would have worked equally well.
7410
7411 @node List Answer 5, List Answer 6, List Answer 4, Answers to Exercises
7412 @subsection List Tutorial Exercise 5
7413
7414 @noindent
7415 The obvious first step is to obtain the list of factors with @kbd{k f}.
7416 This list will always be in sorted order, so if there are duplicates
7417 they will be right next to each other. A suitable method is to compare
7418 the list with a copy of itself shifted over by one.
7419
7420 @smallexample
7421 @group
7422 1: [3, 7, 7, 7, 19] 2: [3, 7, 7, 7, 19] 2: [3, 7, 7, 7, 19, 0]
7423 . 1: [3, 7, 7, 7, 19, 0] 1: [0, 3, 7, 7, 7, 19]
7424 . .
7425
7426 19551 k f @key{RET} 0 | @key{TAB} 0 @key{TAB} |
7427
7428 @end group
7429 @end smallexample
7430 @noindent
7431 @smallexample
7432 @group
7433 1: [0, 0, 1, 1, 0, 0] 1: 2 1: 0
7434 . . .
7435
7436 V M a = V R + 0 a =
7437 @end group
7438 @end smallexample
7439
7440 @noindent
7441 Note that we have to arrange for both vectors to have the same length
7442 so that the mapping operation works; no prime factor will ever be
7443 zero, so adding zeros on the left and right is safe. From then on
7444 the job is pretty straightforward.
7445
7446 Incidentally, Calc provides the
7447 @texline @dfn{M@"obius} @math{\mu}
7448 @infoline @dfn{Moebius mu}
7449 function which is zero if and only if its argument is square-free. It
7450 would be a much more convenient way to do the above test in practice.
7451
7452 @node List Answer 6, List Answer 7, List Answer 5, Answers to Exercises
7453 @subsection List Tutorial Exercise 6
7454
7455 @noindent
7456 First use @kbd{v x 6 @key{RET}} to get a list of integers, then @kbd{V M v x}
7457 to get a list of lists of integers!
7458
7459 @node List Answer 7, List Answer 8, List Answer 6, Answers to Exercises
7460 @subsection List Tutorial Exercise 7
7461
7462 @noindent
7463 Here's one solution. First, compute the triangular list from the previous
7464 exercise and type @kbd{1 -} to subtract one from all the elements.
7465
7466 @smallexample
7467 @group
7468 1: [ [0],
7469 [0, 1],
7470 [0, 1, 2],
7471 @dots{}
7472
7473 1 -
7474 @end group
7475 @end smallexample
7476
7477 The numbers down the lefthand edge of the list we desire are called
7478 the ``triangular numbers'' (now you know why!). The @expr{n}th
7479 triangular number is the sum of the integers from 1 to @expr{n}, and
7480 can be computed directly by the formula
7481 @texline @math{n (n+1) \over 2}.
7482 @infoline @expr{n * (n+1) / 2}.
7483
7484 @smallexample
7485 @group
7486 2: [ [0], [0, 1], ... ] 2: [ [0], [0, 1], ... ]
7487 1: [0, 1, 2, 3, 4, 5] 1: [0, 1, 3, 6, 10, 15]
7488 . .
7489
7490 v x 6 @key{RET} 1 - V M ' $ ($+1)/2 @key{RET}
7491 @end group
7492 @end smallexample
7493
7494 @noindent
7495 Adding this list to the above list of lists produces the desired
7496 result:
7497
7498 @smallexample
7499 @group
7500 1: [ [0],
7501 [1, 2],
7502 [3, 4, 5],
7503 [6, 7, 8, 9],
7504 [10, 11, 12, 13, 14],
7505 [15, 16, 17, 18, 19, 20] ]
7506 .
7507
7508 V M +
7509 @end group
7510 @end smallexample
7511
7512 If we did not know the formula for triangular numbers, we could have
7513 computed them using a @kbd{V U +} command. We could also have
7514 gotten them the hard way by mapping a reduction across the original
7515 triangular list.
7516
7517 @smallexample
7518 @group
7519 2: [ [0], [0, 1], ... ] 2: [ [0], [0, 1], ... ]
7520 1: [ [0], [0, 1], ... ] 1: [0, 1, 3, 6, 10, 15]
7521 . .
7522
7523 @key{RET} V M V R +
7524 @end group
7525 @end smallexample
7526
7527 @noindent
7528 (This means ``map a @kbd{V R +} command across the vector,'' and
7529 since each element of the main vector is itself a small vector,
7530 @kbd{V R +} computes the sum of its elements.)
7531
7532 @node List Answer 8, List Answer 9, List Answer 7, Answers to Exercises
7533 @subsection List Tutorial Exercise 8
7534
7535 @noindent
7536 The first step is to build a list of values of @expr{x}.
7537
7538 @smallexample
7539 @group
7540 1: [1, 2, 3, ..., 21] 1: [0, 1, 2, ..., 20] 1: [0, 0.25, 0.5, ..., 5]
7541 . . .
7542
7543 v x 21 @key{RET} 1 - 4 / s 1
7544 @end group
7545 @end smallexample
7546
7547 Next, we compute the Bessel function values.
7548
7549 @smallexample
7550 @group
7551 1: [0., 0.124, 0.242, ..., -0.328]
7552 .
7553
7554 V M ' besJ(1,$) @key{RET}
7555 @end group
7556 @end smallexample
7557
7558 @noindent
7559 (Another way to do this would be @kbd{1 @key{TAB} V M f j}.)
7560
7561 A way to isolate the maximum value is to compute the maximum using
7562 @kbd{V R X}, then compare all the Bessel values with that maximum.
7563
7564 @smallexample
7565 @group
7566 2: [0., 0.124, 0.242, ... ] 1: [0, 0, 0, ... ] 2: [0, 0, 0, ... ]
7567 1: 0.5801562 . 1: 1
7568 . .
7569
7570 @key{RET} V R X V M a = @key{RET} V R + @key{DEL}
7571 @end group
7572 @end smallexample
7573
7574 @noindent
7575 It's a good idea to verify, as in the last step above, that only
7576 one value is equal to the maximum. (After all, a plot of
7577 @texline @math{\sin x}
7578 @infoline @expr{sin(x)}
7579 might have many points all equal to the maximum value, 1.)
7580
7581 The vector we have now has a single 1 in the position that indicates
7582 the maximum value of @expr{x}. Now it is a simple matter to convert
7583 this back into the corresponding value itself.
7584
7585 @smallexample
7586 @group
7587 2: [0, 0, 0, ... ] 1: [0, 0., 0., ... ] 1: 1.75
7588 1: [0, 0.25, 0.5, ... ] . .
7589 .
7590
7591 r 1 V M * V R +
7592 @end group
7593 @end smallexample
7594
7595 If @kbd{a =} had produced more than one @expr{1} value, this method
7596 would have given the sum of all maximum @expr{x} values; not very
7597 useful! In this case we could have used @kbd{v m} (@code{calc-mask-vector})
7598 instead. This command deletes all elements of a ``data'' vector that
7599 correspond to zeros in a ``mask'' vector, leaving us with, in this
7600 example, a vector of maximum @expr{x} values.
7601
7602 The built-in @kbd{a X} command maximizes a function using more
7603 efficient methods. Just for illustration, let's use @kbd{a X}
7604 to maximize @samp{besJ(1,x)} over this same interval.
7605
7606 @smallexample
7607 @group
7608 2: besJ(1, x) 1: [1.84115, 0.581865]
7609 1: [0 .. 5] .
7610 .
7611
7612 ' besJ(1,x), [0..5] @key{RET} a X x @key{RET}
7613 @end group
7614 @end smallexample
7615
7616 @noindent
7617 The output from @kbd{a X} is a vector containing the value of @expr{x}
7618 that maximizes the function, and the function's value at that maximum.
7619 As you can see, our simple search got quite close to the right answer.
7620
7621 @node List Answer 9, List Answer 10, List Answer 8, Answers to Exercises
7622 @subsection List Tutorial Exercise 9
7623
7624 @noindent
7625 Step one is to convert our integer into vector notation.
7626
7627 @smallexample
7628 @group
7629 1: 25129925999 3: 25129925999
7630 . 2: 10
7631 1: [11, 10, 9, ..., 1, 0]
7632 .
7633
7634 25129925999 @key{RET} 10 @key{RET} 12 @key{RET} v x 12 @key{RET} -
7635
7636 @end group
7637 @end smallexample
7638 @noindent
7639 @smallexample
7640 @group
7641 1: 25129925999 1: [0, 2, 25, 251, 2512, ... ]
7642 2: [100000000000, ... ] .
7643 .
7644
7645 V M ^ s 1 V M \
7646 @end group
7647 @end smallexample
7648
7649 @noindent
7650 (Recall, the @kbd{\} command computes an integer quotient.)
7651
7652 @smallexample
7653 @group
7654 1: [0, 2, 5, 1, 2, 9, 9, 2, 5, 9, 9, 9]
7655 .
7656
7657 10 V M % s 2
7658 @end group
7659 @end smallexample
7660
7661 Next we must increment this number. This involves adding one to
7662 the last digit, plus handling carries. There is a carry to the
7663 left out of a digit if that digit is a nine and all the digits to
7664 the right of it are nines.
7665
7666 @smallexample
7667 @group
7668 1: [0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1] 1: [1, 1, 1, 0, 0, 1, ... ]
7669 . .
7670
7671 9 V M a = v v
7672
7673 @end group
7674 @end smallexample
7675 @noindent
7676 @smallexample
7677 @group
7678 1: [1, 1, 1, 0, 0, 0, ... ] 1: [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1]
7679 . .
7680
7681 V U * v v 1 |
7682 @end group
7683 @end smallexample
7684
7685 @noindent
7686 Accumulating @kbd{*} across a vector of ones and zeros will preserve
7687 only the initial run of ones. These are the carries into all digits
7688 except the rightmost digit. Concatenating a one on the right takes
7689 care of aligning the carries properly, and also adding one to the
7690 rightmost digit.
7691
7692 @smallexample
7693 @group
7694 2: [0, 0, 0, 0, ... ] 1: [0, 0, 2, 5, 1, 2, 9, 9, 2, 6, 0, 0, 0]
7695 1: [0, 0, 2, 5, ... ] .
7696 .
7697
7698 0 r 2 | V M + 10 V M %
7699 @end group
7700 @end smallexample
7701
7702 @noindent
7703 Here we have concatenated 0 to the @emph{left} of the original number;
7704 this takes care of shifting the carries by one with respect to the
7705 digits that generated them.
7706
7707 Finally, we must convert this list back into an integer.
7708
7709 @smallexample
7710 @group
7711 3: [0, 0, 2, 5, ... ] 2: [0, 0, 2, 5, ... ]
7712 2: 1000000000000 1: [1000000000000, 100000000000, ... ]
7713 1: [100000000000, ... ] .
7714 .
7715
7716 10 @key{RET} 12 ^ r 1 |
7717
7718 @end group
7719 @end smallexample
7720 @noindent
7721 @smallexample
7722 @group
7723 1: [0, 0, 20000000000, 5000000000, ... ] 1: 25129926000
7724 . .
7725
7726 V M * V R +
7727 @end group
7728 @end smallexample
7729
7730 @noindent
7731 Another way to do this final step would be to reduce the formula
7732 @w{@samp{10 $$ + $}} across the vector of digits.
7733
7734 @smallexample
7735 @group
7736 1: [0, 0, 2, 5, ... ] 1: 25129926000
7737 . .
7738
7739 V R ' 10 $$ + $ @key{RET}
7740 @end group
7741 @end smallexample
7742
7743 @node List Answer 10, List Answer 11, List Answer 9, Answers to Exercises
7744 @subsection List Tutorial Exercise 10
7745
7746 @noindent
7747 For the list @expr{[a, b, c, d]}, the result is @expr{((a = b) = c) = d},
7748 which will compare @expr{a} and @expr{b} to produce a 1 or 0, which is
7749 then compared with @expr{c} to produce another 1 or 0, which is then
7750 compared with @expr{d}. This is not at all what Joe wanted.
7751
7752 Here's a more correct method:
7753
7754 @smallexample
7755 @group
7756 1: [7, 7, 7, 8, 7] 2: [7, 7, 7, 8, 7]
7757 . 1: 7
7758 .
7759
7760 ' [7,7,7,8,7] @key{RET} @key{RET} v r 1 @key{RET}
7761
7762 @end group
7763 @end smallexample
7764 @noindent
7765 @smallexample
7766 @group
7767 1: [1, 1, 1, 0, 1] 1: 0
7768 . .
7769
7770 V M a = V R *
7771 @end group
7772 @end smallexample
7773
7774 @node List Answer 11, List Answer 12, List Answer 10, Answers to Exercises
7775 @subsection List Tutorial Exercise 11
7776
7777 @noindent
7778 The circle of unit radius consists of those points @expr{(x,y)} for which
7779 @expr{x^2 + y^2 < 1}. We start by generating a vector of @expr{x^2}
7780 and a vector of @expr{y^2}.
7781
7782 We can make this go a bit faster by using the @kbd{v .} and @kbd{t .}
7783 commands.
7784
7785 @smallexample
7786 @group
7787 2: [2., 2., ..., 2.] 2: [2., 2., ..., 2.]
7788 1: [2., 2., ..., 2.] 1: [1.16, 1.98, ..., 0.81]
7789 . .
7790
7791 v . t . 2. v b 100 @key{RET} @key{RET} V M k r
7792
7793 @end group
7794 @end smallexample
7795 @noindent
7796 @smallexample
7797 @group
7798 2: [2., 2., ..., 2.] 1: [0.026, 0.96, ..., 0.036]
7799 1: [0.026, 0.96, ..., 0.036] 2: [0.53, 0.81, ..., 0.094]
7800 . .
7801
7802 1 - 2 V M ^ @key{TAB} V M k r 1 - 2 V M ^
7803 @end group
7804 @end smallexample
7805
7806 Now we sum the @expr{x^2} and @expr{y^2} values, compare with 1 to
7807 get a vector of 1/0 truth values, then sum the truth values.
7808
7809 @smallexample
7810 @group
7811 1: [0.56, 1.78, ..., 0.13] 1: [1, 0, ..., 1] 1: 84
7812 . . .
7813
7814 + 1 V M a < V R +
7815 @end group
7816 @end smallexample
7817
7818 @noindent
7819 The ratio @expr{84/100} should approximate the ratio @cpiover{4}.
7820
7821 @smallexample
7822 @group
7823 1: 0.84 1: 3.36 2: 3.36 1: 1.0695
7824 . . 1: 3.14159 .
7825
7826 100 / 4 * P /
7827 @end group
7828 @end smallexample
7829
7830 @noindent
7831 Our estimate, 3.36, is off by about 7%. We could get a better estimate
7832 by taking more points (say, 1000), but it's clear that this method is
7833 not very efficient!
7834
7835 (Naturally, since this example uses random numbers your own answer
7836 will be slightly different from the one shown here!)
7837
7838 If you typed @kbd{v .} and @kbd{t .} before, type them again to
7839 return to full-sized display of vectors.
7840
7841 @node List Answer 12, List Answer 13, List Answer 11, Answers to Exercises
7842 @subsection List Tutorial Exercise 12
7843
7844 @noindent
7845 This problem can be made a lot easier by taking advantage of some
7846 symmetries. First of all, after some thought it's clear that the
7847 @expr{y} axis can be ignored altogether. Just pick a random @expr{x}
7848 component for one end of the match, pick a random direction
7849 @texline @math{\theta},
7850 @infoline @expr{theta},
7851 and see if @expr{x} and
7852 @texline @math{x + \cos \theta}
7853 @infoline @expr{x + cos(theta)}
7854 (which is the @expr{x} coordinate of the other endpoint) cross a line.
7855 The lines are at integer coordinates, so this happens when the two
7856 numbers surround an integer.
7857
7858 Since the two endpoints are equivalent, we may as well choose the leftmost
7859 of the two endpoints as @expr{x}. Then @expr{theta} is an angle pointing
7860 to the right, in the range -90 to 90 degrees. (We could use radians, but
7861 it would feel like cheating to refer to @cpiover{2} radians while trying
7862 to estimate @cpi{}!)
7863
7864 In fact, since the field of lines is infinite we can choose the
7865 coordinates 0 and 1 for the lines on either side of the leftmost
7866 endpoint. The rightmost endpoint will be between 0 and 1 if the
7867 match does not cross a line, or between 1 and 2 if it does. So:
7868 Pick random @expr{x} and
7869 @texline @math{\theta},
7870 @infoline @expr{theta},
7871 compute
7872 @texline @math{x + \cos \theta},
7873 @infoline @expr{x + cos(theta)},
7874 and count how many of the results are greater than one. Simple!
7875
7876 We can make this go a bit faster by using the @kbd{v .} and @kbd{t .}
7877 commands.
7878
7879 @smallexample
7880 @group
7881 1: [0.52, 0.71, ..., 0.72] 2: [0.52, 0.71, ..., 0.72]
7882 . 1: [78.4, 64.5, ..., -42.9]
7883 .
7884
7885 v . t . 1. v b 100 @key{RET} V M k r 180. v b 100 @key{RET} V M k r 90 -
7886 @end group
7887 @end smallexample
7888
7889 @noindent
7890 (The next step may be slow, depending on the speed of your computer.)
7891
7892 @smallexample
7893 @group
7894 2: [0.52, 0.71, ..., 0.72] 1: [0.72, 1.14, ..., 1.45]
7895 1: [0.20, 0.43, ..., 0.73] .
7896 .
7897
7898 m d V M C +
7899
7900 @end group
7901 @end smallexample
7902 @noindent
7903 @smallexample
7904 @group
7905 1: [0, 1, ..., 1] 1: 0.64 1: 3.125
7906 . . .
7907
7908 1 V M a > V R + 100 / 2 @key{TAB} /
7909 @end group
7910 @end smallexample
7911
7912 Let's try the third method, too. We'll use random integers up to
7913 one million. The @kbd{k r} command with an integer argument picks
7914 a random integer.
7915
7916 @smallexample
7917 @group
7918 2: [1000000, 1000000, ..., 1000000] 2: [78489, 527587, ..., 814975]
7919 1: [1000000, 1000000, ..., 1000000] 1: [324014, 358783, ..., 955450]
7920 . .
7921
7922 1000000 v b 100 @key{RET} @key{RET} V M k r @key{TAB} V M k r
7923
7924 @end group
7925 @end smallexample
7926 @noindent
7927 @smallexample
7928 @group
7929 1: [1, 1, ..., 25] 1: [1, 1, ..., 0] 1: 0.56
7930 . . .
7931
7932 V M k g 1 V M a = V R + 100 /
7933
7934 @end group
7935 @end smallexample
7936 @noindent
7937 @smallexample
7938 @group
7939 1: 10.714 1: 3.273
7940 . .
7941
7942 6 @key{TAB} / Q
7943 @end group
7944 @end smallexample
7945
7946 For a proof of this property of the GCD function, see section 4.5.2,
7947 exercise 10, of Knuth's @emph{Art of Computer Programming}, volume II.
7948
7949 If you typed @kbd{v .} and @kbd{t .} before, type them again to
7950 return to full-sized display of vectors.
7951
7952 @node List Answer 13, List Answer 14, List Answer 12, Answers to Exercises
7953 @subsection List Tutorial Exercise 13
7954
7955 @noindent
7956 First, we put the string on the stack as a vector of ASCII codes.
7957
7958 @smallexample
7959 @group
7960 1: [84, 101, 115, ..., 51]
7961 .
7962
7963 "Testing, 1, 2, 3 @key{RET}
7964 @end group
7965 @end smallexample
7966
7967 @noindent
7968 Note that the @kbd{"} key, like @kbd{$}, initiates algebraic entry so
7969 there was no need to type an apostrophe. Also, Calc didn't mind that
7970 we omitted the closing @kbd{"}. (The same goes for all closing delimiters
7971 like @kbd{)} and @kbd{]} at the end of a formula.
7972
7973 We'll show two different approaches here. In the first, we note that
7974 if the input vector is @expr{[a, b, c, d]}, then the hash code is
7975 @expr{3 (3 (3a + b) + c) + d = 27a + 9b + 3c + d}. In other words,
7976 it's a sum of descending powers of three times the ASCII codes.
7977
7978 @smallexample
7979 @group
7980 2: [84, 101, 115, ..., 51] 2: [84, 101, 115, ..., 51]
7981 1: 16 1: [15, 14, 13, ..., 0]
7982 . .
7983
7984 @key{RET} v l v x 16 @key{RET} -
7985
7986 @end group
7987 @end smallexample
7988 @noindent
7989 @smallexample
7990 @group
7991 2: [84, 101, 115, ..., 51] 1: 1960915098 1: 121
7992 1: [14348907, ..., 1] . .
7993 .
7994
7995 3 @key{TAB} V M ^ * 511 %
7996 @end group
7997 @end smallexample
7998
7999 @noindent
8000 Once again, @kbd{*} elegantly summarizes most of the computation.
8001 But there's an even more elegant approach: Reduce the formula
8002 @kbd{3 $$ + $} across the vector. Recall that this represents a
8003 function of two arguments that computes its first argument times three
8004 plus its second argument.
8005
8006 @smallexample
8007 @group
8008 1: [84, 101, 115, ..., 51] 1: 1960915098
8009 . .
8010
8011 "Testing, 1, 2, 3 @key{RET} V R ' 3$$+$ @key{RET}
8012 @end group
8013 @end smallexample
8014
8015 @noindent
8016 If you did the decimal arithmetic exercise, this will be familiar.
8017 Basically, we're turning a base-3 vector of digits into an integer,
8018 except that our ``digits'' are much larger than real digits.
8019
8020 Instead of typing @kbd{511 %} again to reduce the result, we can be
8021 cleverer still and notice that rather than computing a huge integer
8022 and taking the modulo at the end, we can take the modulo at each step
8023 without affecting the result. While this means there are more
8024 arithmetic operations, the numbers we operate on remain small so
8025 the operations are faster.
8026
8027 @smallexample
8028 @group
8029 1: [84, 101, 115, ..., 51] 1: 121
8030 . .
8031
8032 "Testing, 1, 2, 3 @key{RET} V R ' (3$$+$)%511 @key{RET}
8033 @end group
8034 @end smallexample
8035
8036 Why does this work? Think about a two-step computation:
8037 @w{@expr{3 (3a + b) + c}}. Taking a result modulo 511 basically means
8038 subtracting off enough 511's to put the result in the desired range.
8039 So the result when we take the modulo after every step is,
8040
8041 @ifinfo
8042 @example
8043 3 (3 a + b - 511 m) + c - 511 n
8044 @end example
8045 @end ifinfo
8046 @tex
8047 \turnoffactive
8048 \beforedisplay
8049 $$ 3 (3 a + b - 511 m) + c - 511 n $$
8050 \afterdisplay
8051 @end tex
8052
8053 @noindent
8054 for some suitable integers @expr{m} and @expr{n}. Expanding out by
8055 the distributive law yields
8056
8057 @ifinfo
8058 @example
8059 9 a + 3 b + c - 511*3 m - 511 n
8060 @end example
8061 @end ifinfo
8062 @tex
8063 \turnoffactive
8064 \beforedisplay
8065 $$ 9 a + 3 b + c - 511\times3 m - 511 n $$
8066 \afterdisplay
8067 @end tex
8068
8069 @noindent
8070 The @expr{m} term in the latter formula is redundant because any
8071 contribution it makes could just as easily be made by the @expr{n}
8072 term. So we can take it out to get an equivalent formula with
8073 @expr{n' = 3m + n},
8074
8075 @ifinfo
8076 @example
8077 9 a + 3 b + c - 511 n'
8078 @end example
8079 @end ifinfo
8080 @tex
8081 \turnoffactive
8082 \beforedisplay
8083 $$ 9 a + 3 b + c - 511 n' $$
8084 \afterdisplay
8085 @end tex
8086
8087 @noindent
8088 which is just the formula for taking the modulo only at the end of
8089 the calculation. Therefore the two methods are essentially the same.
8090
8091 Later in the tutorial we will encounter @dfn{modulo forms}, which
8092 basically automate the idea of reducing every intermediate result
8093 modulo some value @var{m}.
8094
8095 @node List Answer 14, Types Answer 1, List Answer 13, Answers to Exercises
8096 @subsection List Tutorial Exercise 14
8097
8098 We want to use @kbd{H V U} to nest a function which adds a random
8099 step to an @expr{(x,y)} coordinate. The function is a bit long, but
8100 otherwise the problem is quite straightforward.
8101
8102 @smallexample
8103 @group
8104 2: [0, 0] 1: [ [ 0, 0 ]
8105 1: 50 [ 0.4288, -0.1695 ]
8106 . [ -0.4787, -0.9027 ]
8107 ...
8108
8109 [0,0] 50 H V U ' <# + [random(2.0)-1, random(2.0)-1]> @key{RET}
8110 @end group
8111 @end smallexample
8112
8113 Just as the text recommended, we used @samp{< >} nameless function
8114 notation to keep the two @code{random} calls from being evaluated
8115 before nesting even begins.
8116
8117 We now have a vector of @expr{[x, y]} sub-vectors, which by Calc's
8118 rules acts like a matrix. We can transpose this matrix and unpack
8119 to get a pair of vectors, @expr{x} and @expr{y}, suitable for graphing.
8120
8121 @smallexample
8122 @group
8123 2: [ 0, 0.4288, -0.4787, ... ]
8124 1: [ 0, -0.1696, -0.9027, ... ]
8125 .
8126
8127 v t v u g f
8128 @end group
8129 @end smallexample
8130
8131 Incidentally, because the @expr{x} and @expr{y} are completely
8132 independent in this case, we could have done two separate commands
8133 to create our @expr{x} and @expr{y} vectors of numbers directly.
8134
8135 To make a random walk of unit steps, we note that @code{sincos} of
8136 a random direction exactly gives us an @expr{[x, y]} step of unit
8137 length; in fact, the new nesting function is even briefer, though
8138 we might want to lower the precision a bit for it.
8139
8140 @smallexample
8141 @group
8142 2: [0, 0] 1: [ [ 0, 0 ]
8143 1: 50 [ 0.1318, 0.9912 ]
8144 . [ -0.5965, 0.3061 ]
8145 ...
8146
8147 [0,0] 50 m d p 6 @key{RET} H V U ' <# + sincos(random(360.0))> @key{RET}
8148 @end group
8149 @end smallexample
8150
8151 Another @kbd{v t v u g f} sequence will graph this new random walk.
8152
8153 An interesting twist on these random walk functions would be to use
8154 complex numbers instead of 2-vectors to represent points on the plane.
8155 In the first example, we'd use something like @samp{random + random*(0,1)},
8156 and in the second we could use polar complex numbers with random phase
8157 angles. (This exercise was first suggested in this form by Randal
8158 Schwartz.)
8159
8160 @node Types Answer 1, Types Answer 2, List Answer 14, Answers to Exercises
8161 @subsection Types Tutorial Exercise 1
8162
8163 @noindent
8164 If the number is the square root of @cpi{} times a rational number,
8165 then its square, divided by @cpi{}, should be a rational number.
8166
8167 @smallexample
8168 @group
8169 1: 1.26508260337 1: 0.509433962268 1: 2486645810:4881193627
8170 . . .
8171
8172 2 ^ P / c F
8173 @end group
8174 @end smallexample
8175
8176 @noindent
8177 Technically speaking this is a rational number, but not one that is
8178 likely to have arisen in the original problem. More likely, it just
8179 happens to be the fraction which most closely represents some
8180 irrational number to within 12 digits.
8181
8182 But perhaps our result was not quite exact. Let's reduce the
8183 precision slightly and try again:
8184
8185 @smallexample
8186 @group
8187 1: 0.509433962268 1: 27:53
8188 . .
8189
8190 U p 10 @key{RET} c F
8191 @end group
8192 @end smallexample
8193
8194 @noindent
8195 Aha! It's unlikely that an irrational number would equal a fraction
8196 this simple to within ten digits, so our original number was probably
8197 @texline @math{\sqrt{27 \pi / 53}}.
8198 @infoline @expr{sqrt(27 pi / 53)}.
8199
8200 Notice that we didn't need to re-round the number when we reduced the
8201 precision. Remember, arithmetic operations always round their inputs
8202 to the current precision before they begin.
8203
8204 @node Types Answer 2, Types Answer 3, Types Answer 1, Answers to Exercises
8205 @subsection Types Tutorial Exercise 2
8206
8207 @noindent
8208 @samp{inf / inf = nan}. Perhaps @samp{1} is the ``obvious'' answer.
8209 But if @w{@samp{17 inf = inf}}, then @samp{17 inf / inf = inf / inf = 17}, too.
8210
8211 @samp{exp(inf) = inf}. It's tempting to say that the exponential
8212 of infinity must be ``bigger'' than ``regular'' infinity, but as
8213 far as Calc is concerned all infinities are as just as big.
8214 In other words, as @expr{x} goes to infinity, @expr{e^x} also goes
8215 to infinity, but the fact the @expr{e^x} grows much faster than
8216 @expr{x} is not relevant here.
8217
8218 @samp{exp(-inf) = 0}. Here we have a finite answer even though
8219 the input is infinite.
8220
8221 @samp{sqrt(-inf) = (0, 1) inf}. Remember that @expr{(0, 1)}
8222 represents the imaginary number @expr{i}. Here's a derivation:
8223 @samp{sqrt(-inf) = @w{sqrt((-1) * inf)} = sqrt(-1) * sqrt(inf)}.
8224 The first part is, by definition, @expr{i}; the second is @code{inf}
8225 because, once again, all infinities are the same size.
8226
8227 @samp{sqrt(uinf) = uinf}. In fact, we do know something about the
8228 direction because @code{sqrt} is defined to return a value in the
8229 right half of the complex plane. But Calc has no notation for this,
8230 so it settles for the conservative answer @code{uinf}.
8231
8232 @samp{abs(uinf) = inf}. No matter which direction @expr{x} points,
8233 @samp{abs(x)} always points along the positive real axis.
8234
8235 @samp{ln(0) = -inf}. Here we have an infinite answer to a finite
8236 input. As in the @expr{1 / 0} case, Calc will only use infinities
8237 here if you have turned on Infinite mode. Otherwise, it will
8238 treat @samp{ln(0)} as an error.
8239
8240 @node Types Answer 3, Types Answer 4, Types Answer 2, Answers to Exercises
8241 @subsection Types Tutorial Exercise 3
8242
8243 @noindent
8244 We can make @samp{inf - inf} be any real number we like, say,
8245 @expr{a}, just by claiming that we added @expr{a} to the first
8246 infinity but not to the second. This is just as true for complex
8247 values of @expr{a}, so @code{nan} can stand for a complex number.
8248 (And, similarly, @code{uinf} can stand for an infinity that points
8249 in any direction in the complex plane, such as @samp{(0, 1) inf}).
8250
8251 In fact, we can multiply the first @code{inf} by two. Surely
8252 @w{@samp{2 inf - inf = inf}}, but also @samp{2 inf - inf = inf - inf = nan}.
8253 So @code{nan} can even stand for infinity. Obviously it's just
8254 as easy to make it stand for minus infinity as for plus infinity.
8255
8256 The moral of this story is that ``infinity'' is a slippery fish
8257 indeed, and Calc tries to handle it by having a very simple model
8258 for infinities (only the direction counts, not the ``size''); but
8259 Calc is careful to write @code{nan} any time this simple model is
8260 unable to tell what the true answer is.
8261
8262 @node Types Answer 4, Types Answer 5, Types Answer 3, Answers to Exercises
8263 @subsection Types Tutorial Exercise 4
8264
8265 @smallexample
8266 @group
8267 2: 0@@ 47' 26" 1: 0@@ 2' 47.411765"
8268 1: 17 .
8269 .
8270
8271 0@@ 47' 26" @key{RET} 17 /
8272 @end group
8273 @end smallexample
8274
8275 @noindent
8276 The average song length is two minutes and 47.4 seconds.
8277
8278 @smallexample
8279 @group
8280 2: 0@@ 2' 47.411765" 1: 0@@ 3' 7.411765" 1: 0@@ 53' 6.000005"
8281 1: 0@@ 0' 20" . .
8282 .
8283
8284 20" + 17 *
8285 @end group
8286 @end smallexample
8287
8288 @noindent
8289 The album would be 53 minutes and 6 seconds long.
8290
8291 @node Types Answer 5, Types Answer 6, Types Answer 4, Answers to Exercises
8292 @subsection Types Tutorial Exercise 5
8293
8294 @noindent
8295 Let's suppose it's January 14, 1991. The easiest thing to do is
8296 to keep trying 13ths of months until Calc reports a Friday.
8297 We can do this by manually entering dates, or by using @kbd{t I}:
8298
8299 @smallexample
8300 @group
8301 1: <Wed Feb 13, 1991> 1: <Wed Mar 13, 1991> 1: <Sat Apr 13, 1991>
8302 . . .
8303
8304 ' <2/13> @key{RET} @key{DEL} ' <3/13> @key{RET} t I
8305 @end group
8306 @end smallexample
8307
8308 @noindent
8309 (Calc assumes the current year if you don't say otherwise.)
8310
8311 This is getting tedious---we can keep advancing the date by typing
8312 @kbd{t I} over and over again, but let's automate the job by using
8313 vector mapping. The @kbd{t I} command actually takes a second
8314 ``how-many-months'' argument, which defaults to one. This
8315 argument is exactly what we want to map over:
8316
8317 @smallexample
8318 @group
8319 2: <Sat Apr 13, 1991> 1: [<Mon May 13, 1991>, <Thu Jun 13, 1991>,
8320 1: [1, 2, 3, 4, 5, 6] <Sat Jul 13, 1991>, <Tue Aug 13, 1991>,
8321 . <Fri Sep 13, 1991>, <Sun Oct 13, 1991>]
8322 .
8323
8324 v x 6 @key{RET} V M t I
8325 @end group
8326 @end smallexample
8327
8328 @noindent
8329 Et voil@`a, September 13, 1991 is a Friday.
8330
8331 @smallexample
8332 @group
8333 1: 242
8334 .
8335
8336 ' <sep 13> - <jan 14> @key{RET}
8337 @end group
8338 @end smallexample
8339
8340 @noindent
8341 And the answer to our original question: 242 days to go.
8342
8343 @node Types Answer 6, Types Answer 7, Types Answer 5, Answers to Exercises
8344 @subsection Types Tutorial Exercise 6
8345
8346 @noindent
8347 The full rule for leap years is that they occur in every year divisible
8348 by four, except that they don't occur in years divisible by 100, except
8349 that they @emph{do} in years divisible by 400. We could work out the
8350 answer by carefully counting the years divisible by four and the
8351 exceptions, but there is a much simpler way that works even if we
8352 don't know the leap year rule.
8353
8354 Let's assume the present year is 1991. Years have 365 days, except
8355 that leap years (whenever they occur) have 366 days. So let's count
8356 the number of days between now and then, and compare that to the
8357 number of years times 365. The number of extra days we find must be
8358 equal to the number of leap years there were.
8359
8360 @smallexample
8361 @group
8362 1: <Mon Jan 1, 10001> 2: <Mon Jan 1, 10001> 1: 2925593
8363 . 1: <Tue Jan 1, 1991> .
8364 .
8365
8366 ' <jan 1 10001> @key{RET} ' <jan 1 1991> @key{RET} -
8367
8368 @end group
8369 @end smallexample
8370 @noindent
8371 @smallexample
8372 @group
8373 3: 2925593 2: 2925593 2: 2925593 1: 1943
8374 2: 10001 1: 8010 1: 2923650 .
8375 1: 1991 . .
8376 .
8377
8378 10001 @key{RET} 1991 - 365 * -
8379 @end group
8380 @end smallexample
8381
8382 @c [fix-ref Date Forms]
8383 @noindent
8384 There will be 1943 leap years before the year 10001. (Assuming,
8385 of course, that the algorithm for computing leap years remains
8386 unchanged for that long. @xref{Date Forms}, for some interesting
8387 background information in that regard.)
8388
8389 @node Types Answer 7, Types Answer 8, Types Answer 6, Answers to Exercises
8390 @subsection Types Tutorial Exercise 7
8391
8392 @noindent
8393 The relative errors must be converted to absolute errors so that
8394 @samp{+/-} notation may be used.
8395
8396 @smallexample
8397 @group
8398 1: 1. 2: 1.
8399 . 1: 0.2
8400 .
8401
8402 20 @key{RET} .05 * 4 @key{RET} .05 *
8403 @end group
8404 @end smallexample
8405
8406 Now we simply chug through the formula.
8407
8408 @smallexample
8409 @group
8410 1: 19.7392088022 1: 394.78 +/- 19.739 1: 6316.5 +/- 706.21
8411 . . .
8412
8413 2 P 2 ^ * 20 p 1 * 4 p .2 @key{RET} 2 ^ *
8414 @end group
8415 @end smallexample
8416
8417 It turns out the @kbd{v u} command will unpack an error form as
8418 well as a vector. This saves us some retyping of numbers.
8419
8420 @smallexample
8421 @group
8422 3: 6316.5 +/- 706.21 2: 6316.5 +/- 706.21
8423 2: 6316.5 1: 0.1118
8424 1: 706.21 .
8425 .
8426
8427 @key{RET} v u @key{TAB} /
8428 @end group
8429 @end smallexample
8430
8431 @noindent
8432 Thus the volume is 6316 cubic centimeters, within about 11 percent.
8433
8434 @node Types Answer 8, Types Answer 9, Types Answer 7, Answers to Exercises
8435 @subsection Types Tutorial Exercise 8
8436
8437 @noindent
8438 The first answer is pretty simple: @samp{1 / (0 .. 10) = (0.1 .. inf)}.
8439 Since a number in the interval @samp{(0 .. 10)} can get arbitrarily
8440 close to zero, its reciprocal can get arbitrarily large, so the answer
8441 is an interval that effectively means, ``any number greater than 0.1''
8442 but with no upper bound.
8443
8444 The second answer, similarly, is @samp{1 / (-10 .. 0) = (-inf .. -0.1)}.
8445
8446 Calc normally treats division by zero as an error, so that the formula
8447 @w{@samp{1 / 0}} is left unsimplified. Our third problem,
8448 @w{@samp{1 / [0 .. 10]}}, also (potentially) divides by zero because zero
8449 is now a member of the interval. So Calc leaves this one unevaluated, too.
8450
8451 If you turn on Infinite mode by pressing @kbd{m i}, you will
8452 instead get the answer @samp{[0.1 .. inf]}, which includes infinity
8453 as a possible value.
8454
8455 The fourth calculation, @samp{1 / (-10 .. 10)}, has the same problem.
8456 Zero is buried inside the interval, but it's still a possible value.
8457 It's not hard to see that the actual result of @samp{1 / (-10 .. 10)}
8458 will be either greater than @mathit{0.1}, or less than @mathit{-0.1}. Thus
8459 the interval goes from minus infinity to plus infinity, with a ``hole''
8460 in it from @mathit{-0.1} to @mathit{0.1}. Calc doesn't have any way to
8461 represent this, so it just reports @samp{[-inf .. inf]} as the answer.
8462 It may be disappointing to hear ``the answer lies somewhere between
8463 minus infinity and plus infinity, inclusive,'' but that's the best
8464 that interval arithmetic can do in this case.
8465
8466 @node Types Answer 9, Types Answer 10, Types Answer 8, Answers to Exercises
8467 @subsection Types Tutorial Exercise 9
8468
8469 @smallexample
8470 @group
8471 1: [-3 .. 3] 2: [-3 .. 3] 2: [0 .. 9]
8472 . 1: [0 .. 9] 1: [-9 .. 9]
8473 . .
8474
8475 [ 3 n .. 3 ] @key{RET} 2 ^ @key{TAB} @key{RET} *
8476 @end group
8477 @end smallexample
8478
8479 @noindent
8480 In the first case the result says, ``if a number is between @mathit{-3} and
8481 3, its square is between 0 and 9.'' The second case says, ``the product
8482 of two numbers each between @mathit{-3} and 3 is between @mathit{-9} and 9.''
8483
8484 An interval form is not a number; it is a symbol that can stand for
8485 many different numbers. Two identical-looking interval forms can stand
8486 for different numbers.
8487
8488 The same issue arises when you try to square an error form.
8489
8490 @node Types Answer 10, Types Answer 11, Types Answer 9, Answers to Exercises
8491 @subsection Types Tutorial Exercise 10
8492
8493 @noindent
8494 Testing the first number, we might arbitrarily choose 17 for @expr{x}.
8495
8496 @smallexample
8497 @group
8498 1: 17 mod 811749613 2: 17 mod 811749613 1: 533694123 mod 811749613
8499 . 811749612 .
8500 .
8501
8502 17 M 811749613 @key{RET} 811749612 ^
8503 @end group
8504 @end smallexample
8505
8506 @noindent
8507 Since 533694123 is (considerably) different from 1, the number 811749613
8508 must not be prime.
8509
8510 It's awkward to type the number in twice as we did above. There are
8511 various ways to avoid this, and algebraic entry is one. In fact, using
8512 a vector mapping operation we can perform several tests at once. Let's
8513 use this method to test the second number.
8514
8515 @smallexample
8516 @group
8517 2: [17, 42, 100000] 1: [1 mod 15485863, 1 mod ... ]
8518 1: 15485863 .
8519 .
8520
8521 [17 42 100000] 15485863 @key{RET} V M ' ($$ mod $)^($-1) @key{RET}
8522 @end group
8523 @end smallexample
8524
8525 @noindent
8526 The result is three ones (modulo @expr{n}), so it's very probable that
8527 15485863 is prime. (In fact, this number is the millionth prime.)
8528
8529 Note that the functions @samp{($$^($-1)) mod $} or @samp{$$^($-1) % $}
8530 would have been hopelessly inefficient, since they would have calculated
8531 the power using full integer arithmetic.
8532
8533 Calc has a @kbd{k p} command that does primality testing. For small
8534 numbers it does an exact test; for large numbers it uses a variant
8535 of the Fermat test we used here. You can use @kbd{k p} repeatedly
8536 to prove that a large integer is prime with any desired probability.
8537
8538 @node Types Answer 11, Types Answer 12, Types Answer 10, Answers to Exercises
8539 @subsection Types Tutorial Exercise 11
8540
8541 @noindent
8542 There are several ways to insert a calculated number into an HMS form.
8543 One way to convert a number of seconds to an HMS form is simply to
8544 multiply the number by an HMS form representing one second:
8545
8546 @smallexample
8547 @group
8548 1: 31415926.5359 2: 31415926.5359 1: 8726@@ 38' 46.5359"
8549 . 1: 0@@ 0' 1" .
8550 .
8551
8552 P 1e7 * 0@@ 0' 1" *
8553
8554 @end group
8555 @end smallexample
8556 @noindent
8557 @smallexample
8558 @group
8559 2: 8726@@ 38' 46.5359" 1: 6@@ 6' 2.5359" mod 24@@ 0' 0"
8560 1: 15@@ 27' 16" mod 24@@ 0' 0" .
8561 .
8562
8563 x time @key{RET} +
8564 @end group
8565 @end smallexample
8566
8567 @noindent
8568 It will be just after six in the morning.
8569
8570 The algebraic @code{hms} function can also be used to build an
8571 HMS form:
8572
8573 @smallexample
8574 @group
8575 1: hms(0, 0, 10000000. pi) 1: 8726@@ 38' 46.5359"
8576 . .
8577
8578 ' hms(0, 0, 1e7 pi) @key{RET} =
8579 @end group
8580 @end smallexample
8581
8582 @noindent
8583 The @kbd{=} key is necessary to evaluate the symbol @samp{pi} to
8584 the actual number 3.14159...
8585
8586 @node Types Answer 12, Types Answer 13, Types Answer 11, Answers to Exercises
8587 @subsection Types Tutorial Exercise 12
8588
8589 @noindent
8590 As we recall, there are 17 songs of about 2 minutes and 47 seconds
8591 each.
8592
8593 @smallexample
8594 @group
8595 2: 0@@ 2' 47" 1: [0@@ 3' 7" .. 0@@ 3' 47"]
8596 1: [0@@ 0' 20" .. 0@@ 1' 0"] .
8597 .
8598
8599 [ 0@@ 20" .. 0@@ 1' ] +
8600
8601 @end group
8602 @end smallexample
8603 @noindent
8604 @smallexample
8605 @group
8606 1: [0@@ 52' 59." .. 1@@ 4' 19."]
8607 .
8608
8609 17 *
8610 @end group
8611 @end smallexample
8612
8613 @noindent
8614 No matter how long it is, the album will fit nicely on one CD.
8615
8616 @node Types Answer 13, Types Answer 14, Types Answer 12, Answers to Exercises
8617 @subsection Types Tutorial Exercise 13
8618
8619 @noindent
8620 Type @kbd{' 1 yr @key{RET} u c s @key{RET}}. The answer is 31557600 seconds.
8621
8622 @node Types Answer 14, Types Answer 15, Types Answer 13, Answers to Exercises
8623 @subsection Types Tutorial Exercise 14
8624
8625 @noindent
8626 How long will it take for a signal to get from one end of the computer
8627 to the other?
8628
8629 @smallexample
8630 @group
8631 1: m / c 1: 3.3356 ns
8632 . .
8633
8634 ' 1 m / c @key{RET} u c ns @key{RET}
8635 @end group
8636 @end smallexample
8637
8638 @noindent
8639 (Recall, @samp{c} is a ``unit'' corresponding to the speed of light.)
8640
8641 @smallexample
8642 @group
8643 1: 3.3356 ns 1: 0.81356 ns / ns 1: 0.81356
8644 2: 4.1 ns . .
8645 .
8646
8647 ' 4.1 ns @key{RET} / u s
8648 @end group
8649 @end smallexample
8650
8651 @noindent
8652 Thus a signal could take up to 81 percent of a clock cycle just to
8653 go from one place to another inside the computer, assuming the signal
8654 could actually attain the full speed of light. Pretty tight!
8655
8656 @node Types Answer 15, Algebra Answer 1, Types Answer 14, Answers to Exercises
8657 @subsection Types Tutorial Exercise 15
8658
8659 @noindent
8660 The speed limit is 55 miles per hour on most highways. We want to
8661 find the ratio of Sam's speed to the US speed limit.
8662
8663 @smallexample
8664 @group
8665 1: 55 mph 2: 55 mph 3: 11 hr mph / yd
8666 . 1: 5 yd / hr .
8667 .
8668
8669 ' 55 mph @key{RET} ' 5 yd/hr @key{RET} /
8670 @end group
8671 @end smallexample
8672
8673 The @kbd{u s} command cancels out these units to get a plain
8674 number. Now we take the logarithm base two to find the final
8675 answer, assuming that each successive pill doubles his speed.
8676
8677 @smallexample
8678 @group
8679 1: 19360. 2: 19360. 1: 14.24
8680 . 1: 2 .
8681 .
8682
8683 u s 2 B
8684 @end group
8685 @end smallexample
8686
8687 @noindent
8688 Thus Sam can take up to 14 pills without a worry.
8689
8690 @node Algebra Answer 1, Algebra Answer 2, Types Answer 15, Answers to Exercises
8691 @subsection Algebra Tutorial Exercise 1
8692
8693 @noindent
8694 @c [fix-ref Declarations]
8695 The result @samp{sqrt(x)^2} is simplified back to @expr{x} by the
8696 Calculator, but @samp{sqrt(x^2)} is not. (Consider what happens
8697 if @w{@expr{x = -4}}.) If @expr{x} is real, this formula could be
8698 simplified to @samp{abs(x)}, but for general complex arguments even
8699 that is not safe. (@xref{Declarations}, for a way to tell Calc
8700 that @expr{x} is known to be real.)
8701
8702 @node Algebra Answer 2, Algebra Answer 3, Algebra Answer 1, Answers to Exercises
8703 @subsection Algebra Tutorial Exercise 2
8704
8705 @noindent
8706 Suppose our roots are @expr{[a, b, c]}. We want a polynomial which
8707 is zero when @expr{x} is any of these values. The trivial polynomial
8708 @expr{x-a} is zero when @expr{x=a}, so the product @expr{(x-a)(x-b)(x-c)}
8709 will do the job. We can use @kbd{a c x} to write this in a more
8710 familiar form.
8711
8712 @smallexample
8713 @group
8714 1: 34 x - 24 x^3 1: [1.19023, -1.19023, 0]
8715 . .
8716
8717 r 2 a P x @key{RET}
8718
8719 @end group
8720 @end smallexample
8721 @noindent
8722 @smallexample
8723 @group
8724 1: [x - 1.19023, x + 1.19023, x] 1: (x - 1.19023) (x + 1.19023) x
8725 . .
8726
8727 V M ' x-$ @key{RET} V R *
8728
8729 @end group
8730 @end smallexample
8731 @noindent
8732 @smallexample
8733 @group
8734 1: x^3 - 1.41666 x 1: 34 x - 24 x^3
8735 . .
8736
8737 a c x @key{RET} 24 n * a x
8738 @end group
8739 @end smallexample
8740
8741 @noindent
8742 Sure enough, our answer (multiplied by a suitable constant) is the
8743 same as the original polynomial.
8744
8745 @node Algebra Answer 3, Algebra Answer 4, Algebra Answer 2, Answers to Exercises
8746 @subsection Algebra Tutorial Exercise 3
8747
8748 @smallexample
8749 @group
8750 1: x sin(pi x) 1: (sin(pi x) - pi x cos(pi x)) / pi^2
8751 . .
8752
8753 ' x sin(pi x) @key{RET} m r a i x @key{RET}
8754
8755 @end group
8756 @end smallexample
8757 @noindent
8758 @smallexample
8759 @group
8760 1: [y, 1]
8761 2: (sin(pi x) - pi x cos(pi x)) / pi^2
8762 .
8763
8764 ' [y,1] @key{RET} @key{TAB}
8765
8766 @end group
8767 @end smallexample
8768 @noindent
8769 @smallexample
8770 @group
8771 1: [(sin(pi y) - pi y cos(pi y)) / pi^2, (sin(pi) - pi cos(pi)) / pi^2]
8772 .
8773
8774 V M $ @key{RET}
8775
8776 @end group
8777 @end smallexample
8778 @noindent
8779 @smallexample
8780 @group
8781 1: (sin(pi y) - pi y cos(pi y)) / pi^2 + (pi cos(pi) - sin(pi)) / pi^2
8782 .
8783
8784 V R -
8785
8786 @end group
8787 @end smallexample
8788 @noindent
8789 @smallexample
8790 @group
8791 1: (sin(3.14159 y) - 3.14159 y cos(3.14159 y)) / 9.8696 - 0.3183
8792 .
8793
8794 =
8795
8796 @end group
8797 @end smallexample
8798 @noindent
8799 @smallexample
8800 @group
8801 1: [0., -0.95493, 0.63662, -1.5915, 1.2732]
8802 .
8803
8804 v x 5 @key{RET} @key{TAB} V M $ @key{RET}
8805 @end group
8806 @end smallexample
8807
8808 @node Algebra Answer 4, Rewrites Answer 1, Algebra Answer 3, Answers to Exercises
8809 @subsection Algebra Tutorial Exercise 4
8810
8811 @noindent
8812 The hard part is that @kbd{V R +} is no longer sufficient to add up all
8813 the contributions from the slices, since the slices have varying
8814 coefficients. So first we must come up with a vector of these
8815 coefficients. Here's one way:
8816
8817 @smallexample
8818 @group
8819 2: -1 2: 3 1: [4, 2, ..., 4]
8820 1: [1, 2, ..., 9] 1: [-1, 1, ..., -1] .
8821 . .
8822
8823 1 n v x 9 @key{RET} V M ^ 3 @key{TAB} -
8824
8825 @end group
8826 @end smallexample
8827 @noindent
8828 @smallexample
8829 @group
8830 1: [4, 2, ..., 4, 1] 1: [1, 4, 2, ..., 4, 1]
8831 . .
8832
8833 1 | 1 @key{TAB} |
8834 @end group
8835 @end smallexample
8836
8837 @noindent
8838 Now we compute the function values. Note that for this method we need
8839 eleven values, including both endpoints of the desired interval.
8840
8841 @smallexample
8842 @group
8843 2: [1, 4, 2, ..., 4, 1]
8844 1: [1, 1.1, 1.2, ... , 1.8, 1.9, 2.]
8845 .
8846
8847 11 @key{RET} 1 @key{RET} .1 @key{RET} C-u v x
8848
8849 @end group
8850 @end smallexample
8851 @noindent
8852 @smallexample
8853 @group
8854 2: [1, 4, 2, ..., 4, 1]
8855 1: [0., 0.084941, 0.16993, ... ]
8856 .
8857
8858 ' sin(x) ln(x) @key{RET} m r p 5 @key{RET} V M $ @key{RET}
8859 @end group
8860 @end smallexample
8861
8862 @noindent
8863 Once again this calls for @kbd{V M * V R +}; a simple @kbd{*} does the
8864 same thing.
8865
8866 @smallexample
8867 @group
8868 1: 11.22 1: 1.122 1: 0.374
8869 . . .
8870
8871 * .1 * 3 /
8872 @end group
8873 @end smallexample
8874
8875 @noindent
8876 Wow! That's even better than the result from the Taylor series method.
8877
8878 @node Rewrites Answer 1, Rewrites Answer 2, Algebra Answer 4, Answers to Exercises
8879 @subsection Rewrites Tutorial Exercise 1
8880
8881 @noindent
8882 We'll use Big mode to make the formulas more readable.
8883
8884 @smallexample
8885 @group
8886 ___
8887 2 + V 2
8888 1: (2 + sqrt(2)) / (1 + sqrt(2)) 1: --------
8889 . ___
8890 1 + V 2
8891
8892 .
8893
8894 ' (2+sqrt(2)) / (1+sqrt(2)) @key{RET} d B
8895 @end group
8896 @end smallexample
8897
8898 @noindent
8899 Multiplying by the conjugate helps because @expr{(a+b) (a-b) = a^2 - b^2}.
8900
8901 @smallexample
8902 @group
8903 ___ ___
8904 1: (2 + V 2 ) (V 2 - 1)
8905 .
8906
8907 a r a/(b+c) := a*(b-c) / (b^2-c^2) @key{RET}
8908
8909 @end group
8910 @end smallexample
8911 @noindent
8912 @smallexample
8913 @group
8914 ___ ___
8915 1: 2 + V 2 - 2 1: V 2
8916 . .
8917
8918 a r a*(b+c) := a*b + a*c a s
8919 @end group
8920 @end smallexample
8921
8922 @noindent
8923 (We could have used @kbd{a x} instead of a rewrite rule for the
8924 second step.)
8925
8926 The multiply-by-conjugate rule turns out to be useful in many
8927 different circumstances, such as when the denominator involves
8928 sines and cosines or the imaginary constant @code{i}.
8929
8930 @node Rewrites Answer 2, Rewrites Answer 3, Rewrites Answer 1, Answers to Exercises
8931 @subsection Rewrites Tutorial Exercise 2
8932
8933 @noindent
8934 Here is the rule set:
8935
8936 @smallexample
8937 @group
8938 [ fib(n) := fib(n, 1, 1) :: integer(n) :: n >= 1,
8939 fib(1, x, y) := x,
8940 fib(n, x, y) := fib(n-1, y, x+y) ]
8941 @end group
8942 @end smallexample
8943
8944 @noindent
8945 The first rule turns a one-argument @code{fib} that people like to write
8946 into a three-argument @code{fib} that makes computation easier. The
8947 second rule converts back from three-argument form once the computation
8948 is done. The third rule does the computation itself. It basically
8949 says that if @expr{x} and @expr{y} are two consecutive Fibonacci numbers,
8950 then @expr{y} and @expr{x+y} are the next (overlapping) pair of Fibonacci
8951 numbers.
8952
8953 Notice that because the number @expr{n} was ``validated'' by the
8954 conditions on the first rule, there is no need to put conditions on
8955 the other rules because the rule set would never get that far unless
8956 the input were valid. That further speeds computation, since no
8957 extra conditions need to be checked at every step.
8958
8959 Actually, a user with a nasty sense of humor could enter a bad
8960 three-argument @code{fib} call directly, say, @samp{fib(0, 1, 1)},
8961 which would get the rules into an infinite loop. One thing that would
8962 help keep this from happening by accident would be to use something like
8963 @samp{ZzFib} instead of @code{fib} as the name of the three-argument
8964 function.
8965
8966 @node Rewrites Answer 3, Rewrites Answer 4, Rewrites Answer 2, Answers to Exercises
8967 @subsection Rewrites Tutorial Exercise 3
8968
8969 @noindent
8970 He got an infinite loop. First, Calc did as expected and rewrote
8971 @w{@samp{2 + 3 x}} to @samp{f(2, 3, x)}. Then it looked for ways to
8972 apply the rule again, and found that @samp{f(2, 3, x)} looks like
8973 @samp{a + b x} with @w{@samp{a = 0}} and @samp{b = 1}, so it rewrote to
8974 @samp{f(0, 1, f(2, 3, x))}. It then wrapped another @samp{f(0, 1, ...)}
8975 around that, and so on, ad infinitum. Joe should have used @kbd{M-1 a r}
8976 to make sure the rule applied only once.
8977
8978 (Actually, even the first step didn't work as he expected. What Calc
8979 really gives for @kbd{M-1 a r} in this situation is @samp{f(3 x, 1, 2)},
8980 treating 2 as the ``variable,'' and @samp{3 x} as a constant being added
8981 to it. While this may seem odd, it's just as valid a solution as the
8982 ``obvious'' one. One way to fix this would be to add the condition
8983 @samp{:: variable(x)} to the rule, to make sure the thing that matches
8984 @samp{x} is indeed a variable, or to change @samp{x} to @samp{quote(x)}
8985 on the lefthand side, so that the rule matches the actual variable
8986 @samp{x} rather than letting @samp{x} stand for something else.)
8987
8988 @node Rewrites Answer 4, Rewrites Answer 5, Rewrites Answer 3, Answers to Exercises
8989 @subsection Rewrites Tutorial Exercise 4
8990
8991 @noindent
8992 @ignore
8993 @starindex
8994 @end ignore
8995 @tindex seq
8996 Here is a suitable set of rules to solve the first part of the problem:
8997
8998 @smallexample
8999 @group
9000 [ seq(n, c) := seq(n/2, c+1) :: n%2 = 0,
9001 seq(n, c) := seq(3n+1, c+1) :: n%2 = 1 :: n > 1 ]
9002 @end group
9003 @end smallexample
9004
9005 Given the initial formula @samp{seq(6, 0)}, application of these
9006 rules produces the following sequence of formulas:
9007
9008 @example
9009 seq( 3, 1)
9010 seq(10, 2)
9011 seq( 5, 3)
9012 seq(16, 4)
9013 seq( 8, 5)
9014 seq( 4, 6)
9015 seq( 2, 7)
9016 seq( 1, 8)
9017 @end example
9018
9019 @noindent
9020 whereupon neither of the rules match, and rewriting stops.
9021
9022 We can pretty this up a bit with a couple more rules:
9023
9024 @smallexample
9025 @group
9026 [ seq(n) := seq(n, 0),
9027 seq(1, c) := c,
9028 ... ]
9029 @end group
9030 @end smallexample
9031
9032 @noindent
9033 Now, given @samp{seq(6)} as the starting configuration, we get 8
9034 as the result.
9035
9036 The change to return a vector is quite simple:
9037
9038 @smallexample
9039 @group
9040 [ seq(n) := seq(n, []) :: integer(n) :: n > 0,
9041 seq(1, v) := v | 1,
9042 seq(n, v) := seq(n/2, v | n) :: n%2 = 0,
9043 seq(n, v) := seq(3n+1, v | n) :: n%2 = 1 ]
9044 @end group
9045 @end smallexample
9046
9047 @noindent
9048 Given @samp{seq(6)}, the result is @samp{[6, 3, 10, 5, 16, 8, 4, 2, 1]}.
9049
9050 Notice that the @expr{n > 1} guard is no longer necessary on the last
9051 rule since the @expr{n = 1} case is now detected by another rule.
9052 But a guard has been added to the initial rule to make sure the
9053 initial value is suitable before the computation begins.
9054
9055 While still a good idea, this guard is not as vitally important as it
9056 was for the @code{fib} function, since calling, say, @samp{seq(x, [])}
9057 will not get into an infinite loop. Calc will not be able to prove
9058 the symbol @samp{x} is either even or odd, so none of the rules will
9059 apply and the rewrites will stop right away.
9060
9061 @node Rewrites Answer 5, Rewrites Answer 6, Rewrites Answer 4, Answers to Exercises
9062 @subsection Rewrites Tutorial Exercise 5
9063
9064 @noindent
9065 @ignore
9066 @starindex
9067 @end ignore
9068 @tindex nterms
9069 If @expr{x} is the sum @expr{a + b}, then `@tfn{nterms(}@var{x}@tfn{)}' must
9070 be `@tfn{nterms(}@var{a}@tfn{)}' plus `@tfn{nterms(}@var{b}@tfn{)}'. If @expr{x}
9071 is not a sum, then `@tfn{nterms(}@var{x}@tfn{)}' = 1.
9072
9073 @smallexample
9074 @group
9075 [ nterms(a + b) := nterms(a) + nterms(b),
9076 nterms(x) := 1 ]
9077 @end group
9078 @end smallexample
9079
9080 @noindent
9081 Here we have taken advantage of the fact that earlier rules always
9082 match before later rules; @samp{nterms(x)} will only be tried if we
9083 already know that @samp{x} is not a sum.
9084
9085 @node Rewrites Answer 6, Programming Answer 1, Rewrites Answer 5, Answers to Exercises
9086 @subsection Rewrites Tutorial Exercise 6
9087
9088 @noindent
9089 Here is a rule set that will do the job:
9090
9091 @smallexample
9092 @group
9093 [ a*(b + c) := a*b + a*c,
9094 opt(a) O(x^n) + opt(b) O(x^m) := O(x^n) :: n <= m
9095 :: constant(a) :: constant(b),
9096 opt(a) O(x^n) + opt(b) x^m := O(x^n) :: n <= m
9097 :: constant(a) :: constant(b),
9098 a O(x^n) := O(x^n) :: constant(a),
9099 x^opt(m) O(x^n) := O(x^(n+m)),
9100 O(x^n) O(x^m) := O(x^(n+m)) ]
9101 @end group
9102 @end smallexample
9103
9104 If we really want the @kbd{+} and @kbd{*} keys to operate naturally
9105 on power series, we should put these rules in @code{EvalRules}. For
9106 testing purposes, it is better to put them in a different variable,
9107 say, @code{O}, first.
9108
9109 The first rule just expands products of sums so that the rest of the
9110 rules can assume they have an expanded-out polynomial to work with.
9111 Note that this rule does not mention @samp{O} at all, so it will
9112 apply to any product-of-sum it encounters---this rule may surprise
9113 you if you put it into @code{EvalRules}!
9114
9115 In the second rule, the sum of two O's is changed to the smaller O.
9116 The optional constant coefficients are there mostly so that
9117 @samp{O(x^2) - O(x^3)} and @samp{O(x^3) - O(x^2)} are handled
9118 as well as @samp{O(x^2) + O(x^3)}.
9119
9120 The third rule absorbs higher powers of @samp{x} into O's.
9121
9122 The fourth rule says that a constant times a negligible quantity
9123 is still negligible. (This rule will also match @samp{O(x^3) / 4},
9124 with @samp{a = 1/4}.)
9125
9126 The fifth rule rewrites, for example, @samp{x^2 O(x^3)} to @samp{O(x^5)}.
9127 (It is easy to see that if one of these forms is negligible, the other
9128 is, too.) Notice the @samp{x^opt(m)} to pick up terms like
9129 @w{@samp{x O(x^3)}}. Optional powers will match @samp{x} as @samp{x^1}
9130 but not 1 as @samp{x^0}. This turns out to be exactly what we want here.
9131
9132 The sixth rule is the corresponding rule for products of two O's.
9133
9134 Another way to solve this problem would be to create a new ``data type''
9135 that represents truncated power series. We might represent these as
9136 function calls @samp{series(@var{coefs}, @var{x})} where @var{coefs} is
9137 a vector of coefficients for @expr{x^0}, @expr{x^1}, @expr{x^2}, and so
9138 on. Rules would exist for sums and products of such @code{series}
9139 objects, and as an optional convenience could also know how to combine a
9140 @code{series} object with a normal polynomial. (With this, and with a
9141 rule that rewrites @samp{O(x^n)} to the equivalent @code{series} form,
9142 you could still enter power series in exactly the same notation as
9143 before.) Operations on such objects would probably be more efficient,
9144 although the objects would be a bit harder to read.
9145
9146 @c [fix-ref Compositions]
9147 Some other symbolic math programs provide a power series data type
9148 similar to this. Mathematica, for example, has an object that looks
9149 like @samp{PowerSeries[@var{x}, @var{x0}, @var{coefs}, @var{nmin},
9150 @var{nmax}, @var{den}]}, where @var{x0} is the point about which the
9151 power series is taken (we've been assuming this was always zero),
9152 and @var{nmin}, @var{nmax}, and @var{den} allow pseudo-power-series
9153 with fractional or negative powers. Also, the @code{PowerSeries}
9154 objects have a special display format that makes them look like
9155 @samp{2 x^2 + O(x^4)} when they are printed out. (@xref{Compositions},
9156 for a way to do this in Calc, although for something as involved as
9157 this it would probably be better to write the formatting routine
9158 in Lisp.)
9159
9160 @node Programming Answer 1, Programming Answer 2, Rewrites Answer 6, Answers to Exercises
9161 @subsection Programming Tutorial Exercise 1
9162
9163 @noindent
9164 Just enter the formula @samp{ninteg(sin(t)/t, t, 0, x)}, type
9165 @kbd{Z F}, and answer the questions. Since this formula contains two
9166 variables, the default argument list will be @samp{(t x)}. We want to
9167 change this to @samp{(x)} since @expr{t} is really a dummy variable
9168 to be used within @code{ninteg}.
9169
9170 The exact keystrokes are @kbd{Z F s Si @key{RET} @key{RET} C-b C-b @key{DEL} @key{DEL} @key{RET} y}.
9171 (The @kbd{C-b C-b @key{DEL} @key{DEL}} are what fix the argument list.)
9172
9173 @node Programming Answer 2, Programming Answer 3, Programming Answer 1, Answers to Exercises
9174 @subsection Programming Tutorial Exercise 2
9175
9176 @noindent
9177 One way is to move the number to the top of the stack, operate on
9178 it, then move it back: @kbd{C-x ( M-@key{TAB} n M-@key{TAB} M-@key{TAB} C-x )}.
9179
9180 Another way is to negate the top three stack entries, then negate
9181 again the top two stack entries: @kbd{C-x ( M-3 n M-2 n C-x )}.
9182
9183 Finally, it turns out that a negative prefix argument causes a
9184 command like @kbd{n} to operate on the specified stack entry only,
9185 which is just what we want: @kbd{C-x ( M-- 3 n C-x )}.
9186
9187 Just for kicks, let's also do it algebraically:
9188 @w{@kbd{C-x ( ' -$$$, $$, $ @key{RET} C-x )}}.
9189
9190 @node Programming Answer 3, Programming Answer 4, Programming Answer 2, Answers to Exercises
9191 @subsection Programming Tutorial Exercise 3
9192
9193 @noindent
9194 Each of these functions can be computed using the stack, or using
9195 algebraic entry, whichever way you prefer:
9196
9197 @noindent
9198 Computing
9199 @texline @math{\displaystyle{\sin x \over x}}:
9200 @infoline @expr{sin(x) / x}:
9201
9202 Using the stack: @kbd{C-x ( @key{RET} S @key{TAB} / C-x )}.
9203
9204 Using algebraic entry: @kbd{C-x ( ' sin($)/$ @key{RET} C-x )}.
9205
9206 @noindent
9207 Computing the logarithm:
9208
9209 Using the stack: @kbd{C-x ( @key{TAB} B C-x )}
9210
9211 Using algebraic entry: @kbd{C-x ( ' log($,$$) @key{RET} C-x )}.
9212
9213 @noindent
9214 Computing the vector of integers:
9215
9216 Using the stack: @kbd{C-x ( 1 @key{RET} 1 C-u v x C-x )}. (Recall that
9217 @kbd{C-u v x} takes the vector size, starting value, and increment
9218 from the stack.)
9219
9220 Alternatively: @kbd{C-x ( ~ v x C-x )}. (The @kbd{~} key pops a
9221 number from the stack and uses it as the prefix argument for the
9222 next command.)
9223
9224 Using algebraic entry: @kbd{C-x ( ' index($) @key{RET} C-x )}.
9225
9226 @node Programming Answer 4, Programming Answer 5, Programming Answer 3, Answers to Exercises
9227 @subsection Programming Tutorial Exercise 4
9228
9229 @noindent
9230 Here's one way: @kbd{C-x ( @key{RET} V R + @key{TAB} v l / C-x )}.
9231
9232 @node Programming Answer 5, Programming Answer 6, Programming Answer 4, Answers to Exercises
9233 @subsection Programming Tutorial Exercise 5
9234
9235 @smallexample
9236 @group
9237 2: 1 1: 1.61803398502 2: 1.61803398502
9238 1: 20 . 1: 1.61803398875
9239 . .
9240
9241 1 @key{RET} 20 Z < & 1 + Z > I H P
9242 @end group
9243 @end smallexample
9244
9245 @noindent
9246 This answer is quite accurate.
9247
9248 @node Programming Answer 6, Programming Answer 7, Programming Answer 5, Answers to Exercises
9249 @subsection Programming Tutorial Exercise 6
9250
9251 @noindent
9252 Here is the matrix:
9253
9254 @example
9255 [ [ 0, 1 ] * [a, b] = [b, a + b]
9256 [ 1, 1 ] ]
9257 @end example
9258
9259 @noindent
9260 Thus @samp{[0, 1; 1, 1]^n * [1, 1]} computes Fibonacci numbers @expr{n+1}
9261 and @expr{n+2}. Here's one program that does the job:
9262
9263 @example
9264 C-x ( ' [0, 1; 1, 1] ^ ($-1) * [1, 1] @key{RET} v u @key{DEL} C-x )
9265 @end example
9266
9267 @noindent
9268 This program is quite efficient because Calc knows how to raise a
9269 matrix (or other value) to the power @expr{n} in only
9270 @texline @math{\log_2 n}
9271 @infoline @expr{log(n,2)}
9272 steps. For example, this program can compute the 1000th Fibonacci
9273 number (a 209-digit integer!) in about 10 steps; even though the
9274 @kbd{Z < ... Z >} solution had much simpler steps, it would have
9275 required so many steps that it would not have been practical.
9276
9277 @node Programming Answer 7, Programming Answer 8, Programming Answer 6, Answers to Exercises
9278 @subsection Programming Tutorial Exercise 7
9279
9280 @noindent
9281 The trick here is to compute the harmonic numbers differently, so that
9282 the loop counter itself accumulates the sum of reciprocals. We use
9283 a separate variable to hold the integer counter.
9284
9285 @smallexample
9286 @group
9287 1: 1 2: 1 1: .
9288 . 1: 4
9289 .
9290
9291 1 t 1 1 @key{RET} 4 Z ( t 2 r 1 1 + s 1 & Z )
9292 @end group
9293 @end smallexample
9294
9295 @noindent
9296 The body of the loop goes as follows: First save the harmonic sum
9297 so far in variable 2. Then delete it from the stack; the for loop
9298 itself will take care of remembering it for us. Next, recall the
9299 count from variable 1, add one to it, and feed its reciprocal to
9300 the for loop to use as the step value. The for loop will increase
9301 the ``loop counter'' by that amount and keep going until the
9302 loop counter exceeds 4.
9303
9304 @smallexample
9305 @group
9306 2: 31 3: 31
9307 1: 3.99498713092 2: 3.99498713092
9308 . 1: 4.02724519544
9309 .
9310
9311 r 1 r 2 @key{RET} 31 & +
9312 @end group
9313 @end smallexample
9314
9315 Thus we find that the 30th harmonic number is 3.99, and the 31st
9316 harmonic number is 4.02.
9317
9318 @node Programming Answer 8, Programming Answer 9, Programming Answer 7, Answers to Exercises
9319 @subsection Programming Tutorial Exercise 8
9320
9321 @noindent
9322 The first step is to compute the derivative @expr{f'(x)} and thus
9323 the formula
9324 @texline @math{\displaystyle{x - {f(x) \over f'(x)}}}.
9325 @infoline @expr{x - f(x)/f'(x)}.
9326
9327 (Because this definition is long, it will be repeated in concise form
9328 below. You can use @w{@kbd{M-# m}} to load it from there. While you are
9329 entering a @kbd{Z ` Z '} body in a macro, Calc simply collects
9330 keystrokes without executing them. In the following diagrams we'll
9331 pretend Calc actually executed the keystrokes as you typed them,
9332 just for purposes of illustration.)
9333
9334 @smallexample
9335 @group
9336 2: sin(cos(x)) - 0.5 3: 4.5
9337 1: 4.5 2: sin(cos(x)) - 0.5
9338 . 1: -(sin(x) cos(cos(x)))
9339 .
9340
9341 ' sin(cos(x))-0.5 @key{RET} 4.5 m r C-x ( Z ` @key{TAB} @key{RET} a d x @key{RET}
9342
9343 @end group
9344 @end smallexample
9345 @noindent
9346 @smallexample
9347 @group
9348 2: 4.5
9349 1: x + (sin(cos(x)) - 0.5) / sin(x) cos(cos(x))
9350 .
9351
9352 / ' x @key{RET} @key{TAB} - t 1
9353 @end group
9354 @end smallexample
9355
9356 Now, we enter the loop. We'll use a repeat loop with a 20-repetition
9357 limit just in case the method fails to converge for some reason.
9358 (Normally, the @w{@kbd{Z /}} command will stop the loop before all 20
9359 repetitions are done.)
9360
9361 @smallexample
9362 @group
9363 1: 4.5 3: 4.5 2: 4.5
9364 . 2: x + (sin(cos(x)) ... 1: 5.24196456928
9365 1: 4.5 .
9366 .
9367
9368 20 Z < @key{RET} r 1 @key{TAB} s l x @key{RET}
9369 @end group
9370 @end smallexample
9371
9372 This is the new guess for @expr{x}. Now we compare it with the
9373 old one to see if we've converged.
9374
9375 @smallexample
9376 @group
9377 3: 5.24196 2: 5.24196 1: 5.24196 1: 5.26345856348
9378 2: 5.24196 1: 0 . .
9379 1: 4.5 .
9380 .
9381
9382 @key{RET} M-@key{TAB} a = Z / Z > Z ' C-x )
9383 @end group
9384 @end smallexample
9385
9386 The loop converges in just a few steps to this value. To check
9387 the result, we can simply substitute it back into the equation.
9388
9389 @smallexample
9390 @group
9391 2: 5.26345856348
9392 1: 0.499999999997
9393 .
9394
9395 @key{RET} ' sin(cos($)) @key{RET}
9396 @end group
9397 @end smallexample
9398
9399 Let's test the new definition again:
9400
9401 @smallexample
9402 @group
9403 2: x^2 - 9 1: 3.
9404 1: 1 .
9405 .
9406
9407 ' x^2-9 @key{RET} 1 X
9408 @end group
9409 @end smallexample
9410
9411 Once again, here's the full Newton's Method definition:
9412
9413 @example
9414 @group
9415 C-x ( Z ` @key{TAB} @key{RET} a d x @key{RET} / ' x @key{RET} @key{TAB} - t 1
9416 20 Z < @key{RET} r 1 @key{TAB} s l x @key{RET}
9417 @key{RET} M-@key{TAB} a = Z /
9418 Z >
9419 Z '
9420 C-x )
9421 @end group
9422 @end example
9423
9424 @c [fix-ref Nesting and Fixed Points]
9425 It turns out that Calc has a built-in command for applying a formula
9426 repeatedly until it converges to a number. @xref{Nesting and Fixed Points},
9427 to see how to use it.
9428
9429 @c [fix-ref Root Finding]
9430 Also, of course, @kbd{a R} is a built-in command that uses Newton's
9431 method (among others) to look for numerical solutions to any equation.
9432 @xref{Root Finding}.
9433
9434 @node Programming Answer 9, Programming Answer 10, Programming Answer 8, Answers to Exercises
9435 @subsection Programming Tutorial Exercise 9
9436
9437 @noindent
9438 The first step is to adjust @expr{z} to be greater than 5. A simple
9439 ``for'' loop will do the job here. If @expr{z} is less than 5, we
9440 reduce the problem using
9441 @texline @math{\psi(z) = \psi(z+1) - 1/z}.
9442 @infoline @expr{psi(z) = psi(z+1) - 1/z}. We go
9443 on to compute
9444 @texline @math{\psi(z+1)},
9445 @infoline @expr{psi(z+1)},
9446 and remember to add back a factor of @expr{-1/z} when we're done. This
9447 step is repeated until @expr{z > 5}.
9448
9449 (Because this definition is long, it will be repeated in concise form
9450 below. You can use @w{@kbd{M-# m}} to load it from there. While you are
9451 entering a @kbd{Z ` Z '} body in a macro, Calc simply collects
9452 keystrokes without executing them. In the following diagrams we'll
9453 pretend Calc actually executed the keystrokes as you typed them,
9454 just for purposes of illustration.)
9455
9456 @smallexample
9457 @group
9458 1: 1. 1: 1.
9459 . .
9460
9461 1.0 @key{RET} C-x ( Z ` s 1 0 t 2
9462 @end group
9463 @end smallexample
9464
9465 Here, variable 1 holds @expr{z} and variable 2 holds the adjustment
9466 factor. If @expr{z < 5}, we use a loop to increase it.
9467
9468 (By the way, we started with @samp{1.0} instead of the integer 1 because
9469 otherwise the calculation below will try to do exact fractional arithmetic,
9470 and will never converge because fractions compare equal only if they
9471 are exactly equal, not just equal to within the current precision.)
9472
9473 @smallexample
9474 @group
9475 3: 1. 2: 1. 1: 6.
9476 2: 1. 1: 1 .
9477 1: 5 .
9478 .
9479
9480 @key{RET} 5 a < Z [ 5 Z ( & s + 2 1 s + 1 1 Z ) r 1 Z ]
9481 @end group
9482 @end smallexample
9483
9484 Now we compute the initial part of the sum:
9485 @texline @math{\ln z - {1 \over 2z}}
9486 @infoline @expr{ln(z) - 1/2z}
9487 minus the adjustment factor.
9488
9489 @smallexample
9490 @group
9491 2: 1.79175946923 2: 1.7084261359 1: -0.57490719743
9492 1: 0.0833333333333 1: 2.28333333333 .
9493 . .
9494
9495 L r 1 2 * & - r 2 -
9496 @end group
9497 @end smallexample
9498
9499 Now we evaluate the series. We'll use another ``for'' loop counting
9500 up the value of @expr{2 n}. (Calc does have a summation command,
9501 @kbd{a +}, but we'll use loops just to get more practice with them.)
9502
9503 @smallexample
9504 @group
9505 3: -0.5749 3: -0.5749 4: -0.5749 2: -0.5749
9506 2: 2 2: 1:6 3: 1:6 1: 2.3148e-3
9507 1: 40 1: 2 2: 2 .
9508 . . 1: 36.
9509 .
9510
9511 2 @key{RET} 40 Z ( @key{RET} k b @key{TAB} @key{RET} r 1 @key{TAB} ^ * /
9512
9513 @end group
9514 @end smallexample
9515 @noindent
9516 @smallexample
9517 @group
9518 3: -0.5749 3: -0.5772 2: -0.5772 1: -0.577215664892
9519 2: -0.5749 2: -0.5772 1: 0 .
9520 1: 2.3148e-3 1: -0.5749 .
9521 . .
9522
9523 @key{TAB} @key{RET} M-@key{TAB} - @key{RET} M-@key{TAB} a = Z / 2 Z ) Z ' C-x )
9524 @end group
9525 @end smallexample
9526
9527 This is the value of
9528 @texline @math{-\gamma},
9529 @infoline @expr{- gamma},
9530 with a slight bit of roundoff error. To get a full 12 digits, let's use
9531 a higher precision:
9532
9533 @smallexample
9534 @group
9535 2: -0.577215664892 2: -0.577215664892
9536 1: 1. 1: -0.577215664901532
9537
9538 1. @key{RET} p 16 @key{RET} X
9539 @end group
9540 @end smallexample
9541
9542 Here's the complete sequence of keystrokes:
9543
9544 @example
9545 @group
9546 C-x ( Z ` s 1 0 t 2
9547 @key{RET} 5 a < Z [ 5 Z ( & s + 2 1 s + 1 1 Z ) r 1 Z ]
9548 L r 1 2 * & - r 2 -
9549 2 @key{RET} 40 Z ( @key{RET} k b @key{TAB} @key{RET} r 1 @key{TAB} ^ * /
9550 @key{TAB} @key{RET} M-@key{TAB} - @key{RET} M-@key{TAB} a = Z /
9551 2 Z )
9552 Z '
9553 C-x )
9554 @end group
9555 @end example
9556
9557 @node Programming Answer 10, Programming Answer 11, Programming Answer 9, Answers to Exercises
9558 @subsection Programming Tutorial Exercise 10
9559
9560 @noindent
9561 Taking the derivative of a term of the form @expr{x^n} will produce
9562 a term like
9563 @texline @math{n x^{n-1}}.
9564 @infoline @expr{n x^(n-1)}.
9565 Taking the derivative of a constant
9566 produces zero. From this it is easy to see that the @expr{n}th
9567 derivative of a polynomial, evaluated at @expr{x = 0}, will equal the
9568 coefficient on the @expr{x^n} term times @expr{n!}.
9569
9570 (Because this definition is long, it will be repeated in concise form
9571 below. You can use @w{@kbd{M-# m}} to load it from there. While you are
9572 entering a @kbd{Z ` Z '} body in a macro, Calc simply collects
9573 keystrokes without executing them. In the following diagrams we'll
9574 pretend Calc actually executed the keystrokes as you typed them,
9575 just for purposes of illustration.)
9576
9577 @smallexample
9578 @group
9579 2: 5 x^4 + (x + 1)^2 3: 5 x^4 + (x + 1)^2
9580 1: 6 2: 0
9581 . 1: 6
9582 .
9583
9584 ' 5 x^4 + (x+1)^2 @key{RET} 6 C-x ( Z ` [ ] t 1 0 @key{TAB}
9585 @end group
9586 @end smallexample
9587
9588 @noindent
9589 Variable 1 will accumulate the vector of coefficients.
9590
9591 @smallexample
9592 @group
9593 2: 0 3: 0 2: 5 x^4 + ...
9594 1: 5 x^4 + ... 2: 5 x^4 + ... 1: 1
9595 . 1: 1 .
9596 .
9597
9598 Z ( @key{TAB} @key{RET} 0 s l x @key{RET} M-@key{TAB} ! / s | 1
9599 @end group
9600 @end smallexample
9601
9602 @noindent
9603 Note that @kbd{s | 1} appends the top-of-stack value to the vector
9604 in a variable; it is completely analogous to @kbd{s + 1}. We could
9605 have written instead, @kbd{r 1 @key{TAB} | t 1}.
9606
9607 @smallexample
9608 @group
9609 1: 20 x^3 + 2 x + 2 1: 0 1: [1, 2, 1, 0, 5, 0, 0]
9610 . . .
9611
9612 a d x @key{RET} 1 Z ) @key{DEL} r 1 Z ' C-x )
9613 @end group
9614 @end smallexample
9615
9616 To convert back, a simple method is just to map the coefficients
9617 against a table of powers of @expr{x}.
9618
9619 @smallexample
9620 @group
9621 2: [1, 2, 1, 0, 5, 0, 0] 2: [1, 2, 1, 0, 5, 0, 0]
9622 1: 6 1: [0, 1, 2, 3, 4, 5, 6]
9623 . .
9624
9625 6 @key{RET} 1 + 0 @key{RET} 1 C-u v x
9626
9627 @end group
9628 @end smallexample
9629 @noindent
9630 @smallexample
9631 @group
9632 2: [1, 2, 1, 0, 5, 0, 0] 2: 1 + 2 x + x^2 + 5 x^4
9633 1: [1, x, x^2, x^3, ... ] .
9634 .
9635
9636 ' x @key{RET} @key{TAB} V M ^ *
9637 @end group
9638 @end smallexample
9639
9640 Once again, here are the whole polynomial to/from vector programs:
9641
9642 @example
9643 @group
9644 C-x ( Z ` [ ] t 1 0 @key{TAB}
9645 Z ( @key{TAB} @key{RET} 0 s l x @key{RET} M-@key{TAB} ! / s | 1
9646 a d x @key{RET}
9647 1 Z ) r 1
9648 Z '
9649 C-x )
9650
9651 C-x ( 1 + 0 @key{RET} 1 C-u v x ' x @key{RET} @key{TAB} V M ^ * C-x )
9652 @end group
9653 @end example
9654
9655 @node Programming Answer 11, Programming Answer 12, Programming Answer 10, Answers to Exercises
9656 @subsection Programming Tutorial Exercise 11
9657
9658 @noindent
9659 First we define a dummy program to go on the @kbd{z s} key. The true
9660 @w{@kbd{z s}} key is supposed to take two numbers from the stack and
9661 return one number, so @key{DEL} as a dummy definition will make
9662 sure the stack comes out right.
9663
9664 @smallexample
9665 @group
9666 2: 4 1: 4 2: 4
9667 1: 2 . 1: 2
9668 . .
9669
9670 4 @key{RET} 2 C-x ( @key{DEL} C-x ) Z K s @key{RET} 2
9671 @end group
9672 @end smallexample
9673
9674 The last step replaces the 2 that was eaten during the creation
9675 of the dummy @kbd{z s} command. Now we move on to the real
9676 definition. The recurrence needs to be rewritten slightly,
9677 to the form @expr{s(n,m) = s(n-1,m-1) - (n-1) s(n-1,m)}.
9678
9679 (Because this definition is long, it will be repeated in concise form
9680 below. You can use @kbd{M-# m} to load it from there.)
9681
9682 @smallexample
9683 @group
9684 2: 4 4: 4 3: 4 2: 4
9685 1: 2 3: 2 2: 2 1: 2
9686 . 2: 4 1: 0 .
9687 1: 2 .
9688 .
9689
9690 C-x ( M-2 @key{RET} a = Z [ @key{DEL} @key{DEL} 1 Z :
9691
9692 @end group
9693 @end smallexample
9694 @noindent
9695 @smallexample
9696 @group
9697 4: 4 2: 4 2: 3 4: 3 4: 3 3: 3
9698 3: 2 1: 2 1: 2 3: 2 3: 2 2: 2
9699 2: 2 . . 2: 3 2: 3 1: 3
9700 1: 0 1: 2 1: 1 .
9701 . . .
9702
9703 @key{RET} 0 a = Z [ @key{DEL} @key{DEL} 0 Z : @key{TAB} 1 - @key{TAB} M-2 @key{RET} 1 - z s
9704 @end group
9705 @end smallexample
9706
9707 @noindent
9708 (Note that the value 3 that our dummy @kbd{z s} produces is not correct;
9709 it is merely a placeholder that will do just as well for now.)
9710
9711 @smallexample
9712 @group
9713 3: 3 4: 3 3: 3 2: 3 1: -6
9714 2: 3 3: 3 2: 3 1: 9 .
9715 1: 2 2: 3 1: 3 .
9716 . 1: 2 .
9717 .
9718
9719 M-@key{TAB} M-@key{TAB} @key{TAB} @key{RET} M-@key{TAB} z s * -
9720
9721 @end group
9722 @end smallexample
9723 @noindent
9724 @smallexample
9725 @group
9726 1: -6 2: 4 1: 11 2: 11
9727 . 1: 2 . 1: 11
9728 . .
9729
9730 Z ] Z ] C-x ) Z K s @key{RET} @key{DEL} 4 @key{RET} 2 z s M-@key{RET} k s
9731 @end group
9732 @end smallexample
9733
9734 Even though the result that we got during the definition was highly
9735 bogus, once the definition is complete the @kbd{z s} command gets
9736 the right answers.
9737
9738 Here's the full program once again:
9739
9740 @example
9741 @group
9742 C-x ( M-2 @key{RET} a =
9743 Z [ @key{DEL} @key{DEL} 1
9744 Z : @key{RET} 0 a =
9745 Z [ @key{DEL} @key{DEL} 0
9746 Z : @key{TAB} 1 - @key{TAB} M-2 @key{RET} 1 - z s
9747 M-@key{TAB} M-@key{TAB} @key{TAB} @key{RET} M-@key{TAB} z s * -
9748 Z ]
9749 Z ]
9750 C-x )
9751 @end group
9752 @end example
9753
9754 You can read this definition using @kbd{M-# m} (@code{read-kbd-macro})
9755 followed by @kbd{Z K s}, without having to make a dummy definition
9756 first, because @code{read-kbd-macro} doesn't need to execute the
9757 definition as it reads it in. For this reason, @code{M-# m} is often
9758 the easiest way to create recursive programs in Calc.
9759
9760 @node Programming Answer 12, , Programming Answer 11, Answers to Exercises
9761 @subsection Programming Tutorial Exercise 12
9762
9763 @noindent
9764 This turns out to be a much easier way to solve the problem. Let's
9765 denote Stirling numbers as calls of the function @samp{s}.
9766
9767 First, we store the rewrite rules corresponding to the definition of
9768 Stirling numbers in a convenient variable:
9769
9770 @smallexample
9771 s e StirlingRules @key{RET}
9772 [ s(n,n) := 1 :: n >= 0,
9773 s(n,0) := 0 :: n > 0,
9774 s(n,m) := s(n-1,m-1) - (n-1) s(n-1,m) :: n >= m :: m >= 1 ]
9775 C-c C-c
9776 @end smallexample
9777
9778 Now, it's just a matter of applying the rules:
9779
9780 @smallexample
9781 @group
9782 2: 4 1: s(4, 2) 1: 11
9783 1: 2 . .
9784 .
9785
9786 4 @key{RET} 2 C-x ( ' s($$,$) @key{RET} a r StirlingRules @key{RET} C-x )
9787 @end group
9788 @end smallexample
9789
9790 As in the case of the @code{fib} rules, it would be useful to put these
9791 rules in @code{EvalRules} and to add a @samp{:: remember} condition to
9792 the last rule.
9793
9794 @c This ends the table-of-contents kludge from above:
9795 @tex
9796 \global\let\chapternofonts=\oldchapternofonts
9797 @end tex
9798
9799 @c [reference]
9800
9801 @node Introduction, Data Types, Tutorial, Top
9802 @chapter Introduction
9803
9804 @noindent
9805 This chapter is the beginning of the Calc reference manual.
9806 It covers basic concepts such as the stack, algebraic and
9807 numeric entry, undo, numeric prefix arguments, etc.
9808
9809 @c [when-split]
9810 @c (Chapter 2, the Tutorial, has been printed in a separate volume.)
9811
9812 @menu
9813 * Basic Commands::
9814 * Help Commands::
9815 * Stack Basics::
9816 * Numeric Entry::
9817 * Algebraic Entry::
9818 * Quick Calculator::
9819 * Keypad Mode::
9820 * Prefix Arguments::
9821 * Undo::
9822 * Error Messages::
9823 * Multiple Calculators::
9824 * Troubleshooting Commands::
9825 @end menu
9826
9827 @node Basic Commands, Help Commands, Introduction, Introduction
9828 @section Basic Commands
9829
9830 @noindent
9831 @pindex calc
9832 @pindex calc-mode
9833 @cindex Starting the Calculator
9834 @cindex Running the Calculator
9835 To start the Calculator in its standard interface, type @kbd{M-x calc}.
9836 By default this creates a pair of small windows, @samp{*Calculator*}
9837 and @samp{*Calc Trail*}. The former displays the contents of the
9838 Calculator stack and is manipulated exclusively through Calc commands.
9839 It is possible (though not usually necessary) to create several Calc
9840 mode buffers each of which has an independent stack, undo list, and
9841 mode settings. There is exactly one Calc Trail buffer; it records a
9842 list of the results of all calculations that have been done. The
9843 Calc Trail buffer uses a variant of Calc mode, so Calculator commands
9844 still work when the trail buffer's window is selected. It is possible
9845 to turn the trail window off, but the @samp{*Calc Trail*} buffer itself
9846 still exists and is updated silently. @xref{Trail Commands}.
9847
9848 @kindex M-# c
9849 @kindex M-# M-#
9850 @ignore
9851 @mindex @null
9852 @end ignore
9853 @kindex M-# #
9854 In most installations, the @kbd{M-# c} key sequence is a more
9855 convenient way to start the Calculator. Also, @kbd{M-# M-#} and
9856 @kbd{M-# #} are synonyms for @kbd{M-# c} unless you last used Calc
9857 in its Keypad mode.
9858
9859 @kindex x
9860 @kindex M-x
9861 @pindex calc-execute-extended-command
9862 Most Calc commands use one or two keystrokes. Lower- and upper-case
9863 letters are distinct. Commands may also be entered in full @kbd{M-x} form;
9864 for some commands this is the only form. As a convenience, the @kbd{x}
9865 key (@code{calc-execute-extended-command})
9866 is like @kbd{M-x} except that it enters the initial string @samp{calc-}
9867 for you. For example, the following key sequences are equivalent:
9868 @kbd{S}, @kbd{M-x calc-sin @key{RET}}, @kbd{x sin @key{RET}}.
9869
9870 @cindex Extensions module
9871 @cindex @file{calc-ext} module
9872 The Calculator exists in many parts. When you type @kbd{M-# c}, the
9873 Emacs ``auto-load'' mechanism will bring in only the first part, which
9874 contains the basic arithmetic functions. The other parts will be
9875 auto-loaded the first time you use the more advanced commands like trig
9876 functions or matrix operations. This is done to improve the response time
9877 of the Calculator in the common case when all you need to do is a
9878 little arithmetic. If for some reason the Calculator fails to load an
9879 extension module automatically, you can force it to load all the
9880 extensions by using the @kbd{M-# L} (@code{calc-load-everything})
9881 command. @xref{Mode Settings}.
9882
9883 If you type @kbd{M-x calc} or @kbd{M-# c} with any numeric prefix argument,
9884 the Calculator is loaded if necessary, but it is not actually started.
9885 If the argument is positive, the @file{calc-ext} extensions are also
9886 loaded if necessary. User-written Lisp code that wishes to make use
9887 of Calc's arithmetic routines can use @samp{(calc 0)} or @samp{(calc 1)}
9888 to auto-load the Calculator.
9889
9890 @kindex M-# b
9891 @pindex full-calc
9892 If you type @kbd{M-# b}, then next time you use @kbd{M-# c} you
9893 will get a Calculator that uses the full height of the Emacs screen.
9894 When full-screen mode is on, @kbd{M-# c} runs the @code{full-calc}
9895 command instead of @code{calc}. From the Unix shell you can type
9896 @samp{emacs -f full-calc} to start a new Emacs specifically for use
9897 as a calculator. When Calc is started from the Emacs command line
9898 like this, Calc's normal ``quit'' commands actually quit Emacs itself.
9899
9900 @kindex M-# o
9901 @pindex calc-other-window
9902 The @kbd{M-# o} command is like @kbd{M-# c} except that the Calc
9903 window is not actually selected. If you are already in the Calc
9904 window, @kbd{M-# o} switches you out of it. (The regular Emacs
9905 @kbd{C-x o} command would also work for this, but it has a
9906 tendency to drop you into the Calc Trail window instead, which
9907 @kbd{M-# o} takes care not to do.)
9908
9909 @ignore
9910 @mindex M-# q
9911 @end ignore
9912 For one quick calculation, you can type @kbd{M-# q} (@code{quick-calc})
9913 which prompts you for a formula (like @samp{2+3/4}). The result is
9914 displayed at the bottom of the Emacs screen without ever creating
9915 any special Calculator windows. @xref{Quick Calculator}.
9916
9917 @ignore
9918 @mindex M-# k
9919 @end ignore
9920 Finally, if you are using the X window system you may want to try
9921 @kbd{M-# k} (@code{calc-keypad}) which runs Calc with a
9922 ``calculator keypad'' picture as well as a stack display. Click on
9923 the keys with the mouse to operate the calculator. @xref{Keypad Mode}.
9924
9925 @kindex q
9926 @pindex calc-quit
9927 @cindex Quitting the Calculator
9928 @cindex Exiting the Calculator
9929 The @kbd{q} key (@code{calc-quit}) exits Calc mode and closes the
9930 Calculator's window(s). It does not delete the Calculator buffers.
9931 If you type @kbd{M-x calc} again, the Calculator will reappear with the
9932 contents of the stack intact. Typing @kbd{M-# c} or @kbd{M-# M-#}
9933 again from inside the Calculator buffer is equivalent to executing
9934 @code{calc-quit}; you can think of @kbd{M-# M-#} as toggling the
9935 Calculator on and off.
9936
9937 @kindex M-# x
9938 The @kbd{M-# x} command also turns the Calculator off, no matter which
9939 user interface (standard, Keypad, or Embedded) is currently active.
9940 It also cancels @code{calc-edit} mode if used from there.
9941
9942 @kindex d @key{SPC}
9943 @pindex calc-refresh
9944 @cindex Refreshing a garbled display
9945 @cindex Garbled displays, refreshing
9946 The @kbd{d @key{SPC}} key sequence (@code{calc-refresh}) redraws the contents
9947 of the Calculator buffer from memory. Use this if the contents of the
9948 buffer have been damaged somehow.
9949
9950 @ignore
9951 @mindex o
9952 @end ignore
9953 The @kbd{o} key (@code{calc-realign}) moves the cursor back to its
9954 ``home'' position at the bottom of the Calculator buffer.
9955
9956 @kindex <
9957 @kindex >
9958 @pindex calc-scroll-left
9959 @pindex calc-scroll-right
9960 @cindex Horizontal scrolling
9961 @cindex Scrolling
9962 @cindex Wide text, scrolling
9963 The @kbd{<} and @kbd{>} keys are bound to @code{calc-scroll-left} and
9964 @code{calc-scroll-right}. These are just like the normal horizontal
9965 scrolling commands except that they scroll one half-screen at a time by
9966 default. (Calc formats its output to fit within the bounds of the
9967 window whenever it can.)
9968
9969 @kindex @{
9970 @kindex @}
9971 @pindex calc-scroll-down
9972 @pindex calc-scroll-up
9973 @cindex Vertical scrolling
9974 The @kbd{@{} and @kbd{@}} keys are bound to @code{calc-scroll-down}
9975 and @code{calc-scroll-up}. They scroll up or down by one-half the
9976 height of the Calc window.
9977
9978 @kindex M-# 0
9979 @pindex calc-reset
9980 The @kbd{M-# 0} command (@code{calc-reset}; that's @kbd{M-#} followed
9981 by a zero) resets the Calculator to its initial state. This clears
9982 the stack, resets all the modes to their initial values (the values
9983 that were saved with @kbd{m m} (@code{calc-save-modes})), clears the
9984 caches (@pxref{Caches}), and so on. (It does @emph{not} erase the
9985 values of any variables.) With an argument of 0, Calc will be reset to
9986 its default state; namely, the modes will be given their default values.
9987 With a positive prefix argument, @kbd{M-# 0} preserves the contents of
9988 the stack but resets everything else to its initial state; with a
9989 negative prefix argument, @kbd{M-# 0} preserves the contents of the
9990 stack but resets everything else to its default state.
9991
9992 @pindex calc-version
9993 The @kbd{M-x calc-version} command displays the current version number
9994 of Calc and the name of the person who installed it on your system.
9995 (This information is also present in the @samp{*Calc Trail*} buffer,
9996 and in the output of the @kbd{h h} command.)
9997
9998 @node Help Commands, Stack Basics, Basic Commands, Introduction
9999 @section Help Commands
10000
10001 @noindent
10002 @cindex Help commands
10003 @kindex ?
10004 @pindex calc-help
10005 The @kbd{?} key (@code{calc-help}) displays a series of brief help messages.
10006 Some keys (such as @kbd{b} and @kbd{d}) are prefix keys, like Emacs'
10007 @key{ESC} and @kbd{C-x} prefixes. You can type
10008 @kbd{?} after a prefix to see a list of commands beginning with that
10009 prefix. (If the message includes @samp{[MORE]}, press @kbd{?} again
10010 to see additional commands for that prefix.)
10011
10012 @kindex h h
10013 @pindex calc-full-help
10014 The @kbd{h h} (@code{calc-full-help}) command displays all the @kbd{?}
10015 responses at once. When printed, this makes a nice, compact (three pages)
10016 summary of Calc keystrokes.
10017
10018 In general, the @kbd{h} key prefix introduces various commands that
10019 provide help within Calc. Many of the @kbd{h} key functions are
10020 Calc-specific analogues to the @kbd{C-h} functions for Emacs help.
10021
10022 @kindex h i
10023 @kindex M-# i
10024 @kindex i
10025 @pindex calc-info
10026 The @kbd{h i} (@code{calc-info}) command runs the Emacs Info system
10027 to read this manual on-line. This is basically the same as typing
10028 @kbd{C-h i} (the regular way to run the Info system), then, if Info
10029 is not already in the Calc manual, selecting the beginning of the
10030 manual. The @kbd{M-# i} command is another way to read the Calc
10031 manual; it is different from @kbd{h i} in that it works any time,
10032 not just inside Calc. The plain @kbd{i} key is also equivalent to
10033 @kbd{h i}, though this key is obsolete and may be replaced with a
10034 different command in a future version of Calc.
10035
10036 @kindex h t
10037 @kindex M-# t
10038 @pindex calc-tutorial
10039 The @kbd{h t} (@code{calc-tutorial}) command runs the Info system on
10040 the Tutorial section of the Calc manual. It is like @kbd{h i},
10041 except that it selects the starting node of the tutorial rather
10042 than the beginning of the whole manual. (It actually selects the
10043 node ``Interactive Tutorial'' which tells a few things about
10044 using the Info system before going on to the actual tutorial.)
10045 The @kbd{M-# t} key is equivalent to @kbd{h t} (but it works at
10046 all times).
10047
10048 @kindex h s
10049 @kindex M-# s
10050 @pindex calc-info-summary
10051 The @kbd{h s} (@code{calc-info-summary}) command runs the Info system
10052 on the Summary node of the Calc manual. @xref{Summary}. The @kbd{M-# s}
10053 key is equivalent to @kbd{h s}.
10054
10055 @kindex h k
10056 @pindex calc-describe-key
10057 The @kbd{h k} (@code{calc-describe-key}) command looks up a key
10058 sequence in the Calc manual. For example, @kbd{h k H a S} looks
10059 up the documentation on the @kbd{H a S} (@code{calc-solve-for})
10060 command. This works by looking up the textual description of
10061 the key(s) in the Key Index of the manual, then jumping to the
10062 node indicated by the index.
10063
10064 Most Calc commands do not have traditional Emacs documentation
10065 strings, since the @kbd{h k} command is both more convenient and
10066 more instructive. This means the regular Emacs @kbd{C-h k}
10067 (@code{describe-key}) command will not be useful for Calc keystrokes.
10068
10069 @kindex h c
10070 @pindex calc-describe-key-briefly
10071 The @kbd{h c} (@code{calc-describe-key-briefly}) command reads a
10072 key sequence and displays a brief one-line description of it at
10073 the bottom of the screen. It looks for the key sequence in the
10074 Summary node of the Calc manual; if it doesn't find the sequence
10075 there, it acts just like its regular Emacs counterpart @kbd{C-h c}
10076 (@code{describe-key-briefly}). For example, @kbd{h c H a S}
10077 gives the description:
10078
10079 @smallexample
10080 H a S runs calc-solve-for: a `H a S' v => fsolve(a,v) (?=notes)
10081 @end smallexample
10082
10083 @noindent
10084 which means the command @kbd{H a S} or @kbd{H M-x calc-solve-for}
10085 takes a value @expr{a} from the stack, prompts for a value @expr{v},
10086 then applies the algebraic function @code{fsolve} to these values.
10087 The @samp{?=notes} message means you can now type @kbd{?} to see
10088 additional notes from the summary that apply to this command.
10089
10090 @kindex h f
10091 @pindex calc-describe-function
10092 The @kbd{h f} (@code{calc-describe-function}) command looks up an
10093 algebraic function or a command name in the Calc manual. Enter an
10094 algebraic function name to look up that function in the Function
10095 Index or enter a command name beginning with @samp{calc-} to look it
10096 up in the Command Index. This command will also look up operator
10097 symbols that can appear in algebraic formulas, like @samp{%} and
10098 @samp{=>}.
10099
10100 @kindex h v
10101 @pindex calc-describe-variable
10102 The @kbd{h v} (@code{calc-describe-variable}) command looks up a
10103 variable in the Calc manual. Enter a variable name like @code{pi} or
10104 @code{PlotRejects}.
10105
10106 @kindex h b
10107 @pindex describe-bindings
10108 The @kbd{h b} (@code{calc-describe-bindings}) command is just like
10109 @kbd{C-h b}, except that only local (Calc-related) key bindings are
10110 listed.
10111
10112 @kindex h n
10113 The @kbd{h n} or @kbd{h C-n} (@code{calc-view-news}) command displays
10114 the ``news'' or change history of Calc. This is kept in the file
10115 @file{README}, which Calc looks for in the same directory as the Calc
10116 source files.
10117
10118 @kindex h C-c
10119 @kindex h C-d
10120 @kindex h C-w
10121 The @kbd{h C-c}, @kbd{h C-d}, and @kbd{h C-w} keys display copying,
10122 distribution, and warranty information about Calc. These work by
10123 pulling up the appropriate parts of the ``Copying'' or ``Reporting
10124 Bugs'' sections of the manual.
10125
10126 @node Stack Basics, Numeric Entry, Help Commands, Introduction
10127 @section Stack Basics
10128
10129 @noindent
10130 @cindex Stack basics
10131 @c [fix-tut RPN Calculations and the Stack]
10132 Calc uses RPN notation. If you are not familiar with RPN, @pxref{RPN
10133 Tutorial}.
10134
10135 To add the numbers 1 and 2 in Calc you would type the keys:
10136 @kbd{1 @key{RET} 2 +}.
10137 (@key{RET} corresponds to the @key{ENTER} key on most calculators.)
10138 The first three keystrokes ``push'' the numbers 1 and 2 onto the stack. The
10139 @kbd{+} key always ``pops'' the top two numbers from the stack, adds them,
10140 and pushes the result (3) back onto the stack. This number is ready for
10141 further calculations: @kbd{5 -} pushes 5 onto the stack, then pops the
10142 3 and 5, subtracts them, and pushes the result (@mathit{-2}).
10143
10144 Note that the ``top'' of the stack actually appears at the @emph{bottom}
10145 of the buffer. A line containing a single @samp{.} character signifies
10146 the end of the buffer; Calculator commands operate on the number(s)
10147 directly above this line. The @kbd{d t} (@code{calc-truncate-stack})
10148 command allows you to move the @samp{.} marker up and down in the stack;
10149 @pxref{Truncating the Stack}.
10150
10151 @kindex d l
10152 @pindex calc-line-numbering
10153 Stack elements are numbered consecutively, with number 1 being the top of
10154 the stack. These line numbers are ordinarily displayed on the lefthand side
10155 of the window. The @kbd{d l} (@code{calc-line-numbering}) command controls
10156 whether these numbers appear. (Line numbers may be turned off since they
10157 slow the Calculator down a bit and also clutter the display.)
10158
10159 @kindex o
10160 @pindex calc-realign
10161 The unshifted letter @kbd{o} (@code{calc-realign}) command repositions
10162 the cursor to its top-of-stack ``home'' position. It also undoes any
10163 horizontal scrolling in the window. If you give it a numeric prefix
10164 argument, it instead moves the cursor to the specified stack element.
10165
10166 The @key{RET} (or equivalent @key{SPC}) key is only required to separate
10167 two consecutive numbers.
10168 (After all, if you typed @kbd{1 2} by themselves the Calculator
10169 would enter the number 12.) If you press @key{RET} or @key{SPC} @emph{not}
10170 right after typing a number, the key duplicates the number on the top of
10171 the stack. @kbd{@key{RET} *} is thus a handy way to square a number.
10172
10173 The @key{DEL} key pops and throws away the top number on the stack.
10174 The @key{TAB} key swaps the top two objects on the stack.
10175 @xref{Stack and Trail}, for descriptions of these and other stack-related
10176 commands.
10177
10178 @node Numeric Entry, Algebraic Entry, Stack Basics, Introduction
10179 @section Numeric Entry
10180
10181 @noindent
10182 @kindex 0-9
10183 @kindex .
10184 @kindex e
10185 @cindex Numeric entry
10186 @cindex Entering numbers
10187 Pressing a digit or other numeric key begins numeric entry using the
10188 minibuffer. The number is pushed on the stack when you press the @key{RET}
10189 or @key{SPC} keys. If you press any other non-numeric key, the number is
10190 pushed onto the stack and the appropriate operation is performed. If
10191 you press a numeric key which is not valid, the key is ignored.
10192
10193 @cindex Minus signs
10194 @cindex Negative numbers, entering
10195 @kindex _
10196 There are three different concepts corresponding to the word ``minus,''
10197 typified by @expr{a-b} (subtraction), @expr{-x}
10198 (change-sign), and @expr{-5} (negative number). Calc uses three
10199 different keys for these operations, respectively:
10200 @kbd{-}, @kbd{n}, and @kbd{_} (the underscore). The @kbd{-} key subtracts
10201 the two numbers on the top of the stack. The @kbd{n} key changes the sign
10202 of the number on the top of the stack or the number currently being entered.
10203 The @kbd{_} key begins entry of a negative number or changes the sign of
10204 the number currently being entered. The following sequences all enter the
10205 number @mathit{-5} onto the stack: @kbd{0 @key{RET} 5 -}, @kbd{5 n @key{RET}},
10206 @kbd{5 @key{RET} n}, @kbd{_ 5 @key{RET}}, @kbd{5 _ @key{RET}}.
10207
10208 Some other keys are active during numeric entry, such as @kbd{#} for
10209 non-decimal numbers, @kbd{:} for fractions, and @kbd{@@} for HMS forms.
10210 These notations are described later in this manual with the corresponding
10211 data types. @xref{Data Types}.
10212
10213 During numeric entry, the only editing key available is @key{DEL}.
10214
10215 @node Algebraic Entry, Quick Calculator, Numeric Entry, Introduction
10216 @section Algebraic Entry
10217
10218 @noindent
10219 @kindex '
10220 @pindex calc-algebraic-entry
10221 @cindex Algebraic notation
10222 @cindex Formulas, entering
10223 Calculations can also be entered in algebraic form. This is accomplished
10224 by typing the apostrophe key, @kbd{'}, followed by the expression in
10225 standard format: @kbd{@key{'} 2+3*4 @key{RET}} computes
10226 @texline @math{2+(3\times4) = 14}
10227 @infoline @expr{2+(3*4) = 14}
10228 and pushes that on the stack. If you wish you can
10229 ignore the RPN aspect of Calc altogether and simply enter algebraic
10230 expressions in this way. You may want to use @key{DEL} every so often to
10231 clear previous results off the stack.
10232
10233 You can press the apostrophe key during normal numeric entry to switch
10234 the half-entered number into Algebraic entry mode. One reason to do this
10235 would be to use the full Emacs cursor motion and editing keys, which are
10236 available during algebraic entry but not during numeric entry.
10237
10238 In the same vein, during either numeric or algebraic entry you can
10239 press @kbd{`} (backquote) to switch to @code{calc-edit} mode, where
10240 you complete your half-finished entry in a separate buffer.
10241 @xref{Editing Stack Entries}.
10242
10243 @kindex m a
10244 @pindex calc-algebraic-mode
10245 @cindex Algebraic Mode
10246 If you prefer algebraic entry, you can use the command @kbd{m a}
10247 (@code{calc-algebraic-mode}) to set Algebraic mode. In this mode,
10248 digits and other keys that would normally start numeric entry instead
10249 start full algebraic entry; as long as your formula begins with a digit
10250 you can omit the apostrophe. Open parentheses and square brackets also
10251 begin algebraic entry. You can still do RPN calculations in this mode,
10252 but you will have to press @key{RET} to terminate every number:
10253 @kbd{2 @key{RET} 3 @key{RET} * 4 @key{RET} +} would accomplish the same
10254 thing as @kbd{2*3+4 @key{RET}}.
10255
10256 @cindex Incomplete Algebraic Mode
10257 If you give a numeric prefix argument like @kbd{C-u} to the @kbd{m a}
10258 command, it enables Incomplete Algebraic mode; this is like regular
10259 Algebraic mode except that it applies to the @kbd{(} and @kbd{[} keys
10260 only. Numeric keys still begin a numeric entry in this mode.
10261
10262 @kindex m t
10263 @pindex calc-total-algebraic-mode
10264 @cindex Total Algebraic Mode
10265 The @kbd{m t} (@code{calc-total-algebraic-mode}) gives you an even
10266 stronger algebraic-entry mode, in which @emph{all} regular letter and
10267 punctuation keys begin algebraic entry. Use this if you prefer typing
10268 @w{@kbd{sqrt( )}} instead of @kbd{Q}, @w{@kbd{factor( )}} instead of
10269 @kbd{a f}, and so on. To type regular Calc commands when you are in
10270 Total Algebraic mode, hold down the @key{META} key. Thus @kbd{M-q}
10271 is the command to quit Calc, @kbd{M-p} sets the precision, and
10272 @kbd{M-m t} (or @kbd{M-m M-t}, if you prefer) turns Total Algebraic
10273 mode back off again. Meta keys also terminate algebraic entry, so
10274 that @kbd{2+3 M-S} is equivalent to @kbd{2+3 @key{RET} M-S}. The symbol
10275 @samp{Alg*} will appear in the mode line whenever you are in this mode.
10276
10277 Pressing @kbd{'} (the apostrophe) a second time re-enters the previous
10278 algebraic formula. You can then use the normal Emacs editing keys to
10279 modify this formula to your liking before pressing @key{RET}.
10280
10281 @kindex $
10282 @cindex Formulas, referring to stack
10283 Within a formula entered from the keyboard, the symbol @kbd{$}
10284 represents the number on the top of the stack. If an entered formula
10285 contains any @kbd{$} characters, the Calculator replaces the top of
10286 stack with that formula rather than simply pushing the formula onto the
10287 stack. Thus, @kbd{' 1+2 @key{RET}} pushes 3 on the stack, and @kbd{$*2
10288 @key{RET}} replaces it with 6. Note that the @kbd{$} key always
10289 initiates algebraic entry; the @kbd{'} is unnecessary if @kbd{$} is the
10290 first character in the new formula.
10291
10292 Higher stack elements can be accessed from an entered formula with the
10293 symbols @kbd{$$}, @kbd{$$$}, and so on. The number of stack elements
10294 removed (to be replaced by the entered values) equals the number of dollar
10295 signs in the longest such symbol in the formula. For example, @samp{$$+$$$}
10296 adds the second and third stack elements, replacing the top three elements
10297 with the answer. (All information about the top stack element is thus lost
10298 since no single @samp{$} appears in this formula.)
10299
10300 A slightly different way to refer to stack elements is with a dollar
10301 sign followed by a number: @samp{$1}, @samp{$2}, and so on are much
10302 like @samp{$}, @samp{$$}, etc., except that stack entries referred
10303 to numerically are not replaced by the algebraic entry. That is, while
10304 @samp{$+1} replaces 5 on the stack with 6, @samp{$1+1} leaves the 5
10305 on the stack and pushes an additional 6.
10306
10307 If a sequence of formulas are entered separated by commas, each formula
10308 is pushed onto the stack in turn. For example, @samp{1,2,3} pushes
10309 those three numbers onto the stack (leaving the 3 at the top), and
10310 @samp{$+1,$-1} replaces a 5 on the stack with 4 followed by 6. Also,
10311 @samp{$,$$} exchanges the top two elements of the stack, just like the
10312 @key{TAB} key.
10313
10314 You can finish an algebraic entry with @kbd{M-=} or @kbd{M-@key{RET}} instead
10315 of @key{RET}. This uses @kbd{=} to evaluate the variables in each
10316 formula that goes onto the stack. (Thus @kbd{' pi @key{RET}} pushes
10317 the variable @samp{pi}, but @kbd{' pi M-@key{RET}} pushes 3.1415.)
10318
10319 If you finish your algebraic entry by pressing @key{LFD} (or @kbd{C-j})
10320 instead of @key{RET}, Calc disables the default simplifications
10321 (as if by @kbd{m O}; @pxref{Simplification Modes}) while the entry
10322 is being pushed on the stack. Thus @kbd{' 1+2 @key{RET}} pushes 3
10323 on the stack, but @kbd{' 1+2 @key{LFD}} pushes the formula @expr{1+2};
10324 you might then press @kbd{=} when it is time to evaluate this formula.
10325
10326 @node Quick Calculator, Prefix Arguments, Algebraic Entry, Introduction
10327 @section ``Quick Calculator'' Mode
10328
10329 @noindent
10330 @kindex M-# q
10331 @pindex quick-calc
10332 @cindex Quick Calculator
10333 There is another way to invoke the Calculator if all you need to do
10334 is make one or two quick calculations. Type @kbd{M-# q} (or
10335 @kbd{M-x quick-calc}), then type any formula as an algebraic entry.
10336 The Calculator will compute the result and display it in the echo
10337 area, without ever actually putting up a Calc window.
10338
10339 You can use the @kbd{$} character in a Quick Calculator formula to
10340 refer to the previous Quick Calculator result. Older results are
10341 not retained; the Quick Calculator has no effect on the full
10342 Calculator's stack or trail. If you compute a result and then
10343 forget what it was, just run @code{M-# q} again and enter
10344 @samp{$} as the formula.
10345
10346 If this is the first time you have used the Calculator in this Emacs
10347 session, the @kbd{M-# q} command will create the @code{*Calculator*}
10348 buffer and perform all the usual initializations; it simply will
10349 refrain from putting that buffer up in a new window. The Quick
10350 Calculator refers to the @code{*Calculator*} buffer for all mode
10351 settings. Thus, for example, to set the precision that the Quick
10352 Calculator uses, simply run the full Calculator momentarily and use
10353 the regular @kbd{p} command.
10354
10355 If you use @code{M-# q} from inside the Calculator buffer, the
10356 effect is the same as pressing the apostrophe key (algebraic entry).
10357
10358 The result of a Quick calculation is placed in the Emacs ``kill ring''
10359 as well as being displayed. A subsequent @kbd{C-y} command will
10360 yank the result into the editing buffer. You can also use this
10361 to yank the result into the next @kbd{M-# q} input line as a more
10362 explicit alternative to @kbd{$} notation, or to yank the result
10363 into the Calculator stack after typing @kbd{M-# c}.
10364
10365 If you finish your formula by typing @key{LFD} (or @kbd{C-j}) instead
10366 of @key{RET}, the result is inserted immediately into the current
10367 buffer rather than going into the kill ring.
10368
10369 Quick Calculator results are actually evaluated as if by the @kbd{=}
10370 key (which replaces variable names by their stored values, if any).
10371 If the formula you enter is an assignment to a variable using the
10372 @samp{:=} operator, say, @samp{foo := 2 + 3} or @samp{foo := foo + 1},
10373 then the result of the evaluation is stored in that Calc variable.
10374 @xref{Store and Recall}.
10375
10376 If the result is an integer and the current display radix is decimal,
10377 the number will also be displayed in hex and octal formats. If the
10378 integer is in the range from 1 to 126, it will also be displayed as
10379 an ASCII character.
10380
10381 For example, the quoted character @samp{"x"} produces the vector
10382 result @samp{[120]} (because 120 is the ASCII code of the lower-case
10383 `x'; @pxref{Strings}). Since this is a vector, not an integer, it
10384 is displayed only according to the current mode settings. But
10385 running Quick Calc again and entering @samp{120} will produce the
10386 result @samp{120 (16#78, 8#170, x)} which shows the number in its
10387 decimal, hexadecimal, octal, and ASCII forms.
10388
10389 Please note that the Quick Calculator is not any faster at loading
10390 or computing the answer than the full Calculator; the name ``quick''
10391 merely refers to the fact that it's much less hassle to use for
10392 small calculations.
10393
10394 @node Prefix Arguments, Undo, Quick Calculator, Introduction
10395 @section Numeric Prefix Arguments
10396
10397 @noindent
10398 Many Calculator commands use numeric prefix arguments. Some, such as
10399 @kbd{d s} (@code{calc-sci-notation}), set a parameter to the value of
10400 the prefix argument or use a default if you don't use a prefix.
10401 Others (like @kbd{d f} (@code{calc-fix-notation})) require an argument
10402 and prompt for a number if you don't give one as a prefix.
10403
10404 As a rule, stack-manipulation commands accept a numeric prefix argument
10405 which is interpreted as an index into the stack. A positive argument
10406 operates on the top @var{n} stack entries; a negative argument operates
10407 on the @var{n}th stack entry in isolation; and a zero argument operates
10408 on the entire stack.
10409
10410 Most commands that perform computations (such as the arithmetic and
10411 scientific functions) accept a numeric prefix argument that allows the
10412 operation to be applied across many stack elements. For unary operations
10413 (that is, functions of one argument like absolute value or complex
10414 conjugate), a positive prefix argument applies that function to the top
10415 @var{n} stack entries simultaneously, and a negative argument applies it
10416 to the @var{n}th stack entry only. For binary operations (functions of
10417 two arguments like addition, GCD, and vector concatenation), a positive
10418 prefix argument ``reduces'' the function across the top @var{n}
10419 stack elements (for example, @kbd{C-u 5 +} sums the top 5 stack entries;
10420 @pxref{Reducing and Mapping}), and a negative argument maps the next-to-top
10421 @var{n} stack elements with the top stack element as a second argument
10422 (for example, @kbd{7 c-u -5 +} adds 7 to the top 5 stack elements).
10423 This feature is not available for operations which use the numeric prefix
10424 argument for some other purpose.
10425
10426 Numeric prefixes are specified the same way as always in Emacs: Press
10427 a sequence of @key{META}-digits, or press @key{ESC} followed by digits,
10428 or press @kbd{C-u} followed by digits. Some commands treat plain
10429 @kbd{C-u} (without any actual digits) specially.
10430
10431 @kindex ~
10432 @pindex calc-num-prefix
10433 You can type @kbd{~} (@code{calc-num-prefix}) to pop an integer from the
10434 top of the stack and enter it as the numeric prefix for the next command.
10435 For example, @kbd{C-u 16 p} sets the precision to 16 digits; an alternate
10436 (silly) way to do this would be @kbd{2 @key{RET} 4 ^ ~ p}, i.e., compute 2
10437 to the fourth power and set the precision to that value.
10438
10439 Conversely, if you have typed a numeric prefix argument the @kbd{~} key
10440 pushes it onto the stack in the form of an integer.
10441
10442 @node Undo, Error Messages, Prefix Arguments, Introduction
10443 @section Undoing Mistakes
10444
10445 @noindent
10446 @kindex U
10447 @kindex C-_
10448 @pindex calc-undo
10449 @cindex Mistakes, undoing
10450 @cindex Undoing mistakes
10451 @cindex Errors, undoing
10452 The shift-@kbd{U} key (@code{calc-undo}) undoes the most recent operation.
10453 If that operation added or dropped objects from the stack, those objects
10454 are removed or restored. If it was a ``store'' operation, you are
10455 queried whether or not to restore the variable to its original value.
10456 The @kbd{U} key may be pressed any number of times to undo successively
10457 farther back in time; with a numeric prefix argument it undoes a
10458 specified number of operations. The undo history is cleared only by the
10459 @kbd{q} (@code{calc-quit}) command. (Recall that @kbd{M-# c} is
10460 synonymous with @code{calc-quit} while inside the Calculator; this
10461 also clears the undo history.)
10462
10463 Currently the mode-setting commands (like @code{calc-precision}) are not
10464 undoable. You can undo past a point where you changed a mode, but you
10465 will need to reset the mode yourself.
10466
10467 @kindex D
10468 @pindex calc-redo
10469 @cindex Redoing after an Undo
10470 The shift-@kbd{D} key (@code{calc-redo}) redoes an operation that was
10471 mistakenly undone. Pressing @kbd{U} with a negative prefix argument is
10472 equivalent to executing @code{calc-redo}. You can redo any number of
10473 times, up to the number of recent consecutive undo commands. Redo
10474 information is cleared whenever you give any command that adds new undo
10475 information, i.e., if you undo, then enter a number on the stack or make
10476 any other change, then it will be too late to redo.
10477
10478 @kindex M-@key{RET}
10479 @pindex calc-last-args
10480 @cindex Last-arguments feature
10481 @cindex Arguments, restoring
10482 The @kbd{M-@key{RET}} key (@code{calc-last-args}) is like undo in that
10483 it restores the arguments of the most recent command onto the stack;
10484 however, it does not remove the result of that command. Given a numeric
10485 prefix argument, this command applies to the @expr{n}th most recent
10486 command which removed items from the stack; it pushes those items back
10487 onto the stack.
10488
10489 The @kbd{K} (@code{calc-keep-args}) command provides a related function
10490 to @kbd{M-@key{RET}}. @xref{Stack and Trail}.
10491
10492 It is also possible to recall previous results or inputs using the trail.
10493 @xref{Trail Commands}.
10494
10495 The standard Emacs @kbd{C-_} undo key is recognized as a synonym for @kbd{U}.
10496
10497 @node Error Messages, Multiple Calculators, Undo, Introduction
10498 @section Error Messages
10499
10500 @noindent
10501 @kindex w
10502 @pindex calc-why
10503 @cindex Errors, messages
10504 @cindex Why did an error occur?
10505 Many situations that would produce an error message in other calculators
10506 simply create unsimplified formulas in the Emacs Calculator. For example,
10507 @kbd{1 @key{RET} 0 /} pushes the formula @expr{1 / 0}; @w{@kbd{0 L}} pushes
10508 the formula @samp{ln(0)}. Floating-point overflow and underflow are also
10509 reasons for this to happen.
10510
10511 When a function call must be left in symbolic form, Calc usually
10512 produces a message explaining why. Messages that are probably
10513 surprising or indicative of user errors are displayed automatically.
10514 Other messages are simply kept in Calc's memory and are displayed only
10515 if you type @kbd{w} (@code{calc-why}). You can also press @kbd{w} if
10516 the same computation results in several messages. (The first message
10517 will end with @samp{[w=more]} in this case.)
10518
10519 @kindex d w
10520 @pindex calc-auto-why
10521 The @kbd{d w} (@code{calc-auto-why}) command controls when error messages
10522 are displayed automatically. (Calc effectively presses @kbd{w} for you
10523 after your computation finishes.) By default, this occurs only for
10524 ``important'' messages. The other possible modes are to report
10525 @emph{all} messages automatically, or to report none automatically (so
10526 that you must always press @kbd{w} yourself to see the messages).
10527
10528 @node Multiple Calculators, Troubleshooting Commands, Error Messages, Introduction
10529 @section Multiple Calculators
10530
10531 @noindent
10532 @pindex another-calc
10533 It is possible to have any number of Calc mode buffers at once.
10534 Usually this is done by executing @kbd{M-x another-calc}, which
10535 is similar to @kbd{M-# c} except that if a @samp{*Calculator*}
10536 buffer already exists, a new, independent one with a name of the
10537 form @samp{*Calculator*<@var{n}>} is created. You can also use the
10538 command @code{calc-mode} to put any buffer into Calculator mode, but
10539 this would ordinarily never be done.
10540
10541 The @kbd{q} (@code{calc-quit}) command does not destroy a Calculator buffer;
10542 it only closes its window. Use @kbd{M-x kill-buffer} to destroy a
10543 Calculator buffer.
10544
10545 Each Calculator buffer keeps its own stack, undo list, and mode settings
10546 such as precision, angular mode, and display formats. In Emacs terms,
10547 variables such as @code{calc-stack} are buffer-local variables. The
10548 global default values of these variables are used only when a new
10549 Calculator buffer is created. The @code{calc-quit} command saves
10550 the stack and mode settings of the buffer being quit as the new defaults.
10551
10552 There is only one trail buffer, @samp{*Calc Trail*}, used by all
10553 Calculator buffers.
10554
10555 @node Troubleshooting Commands, , Multiple Calculators, Introduction
10556 @section Troubleshooting Commands
10557
10558 @noindent
10559 This section describes commands you can use in case a computation
10560 incorrectly fails or gives the wrong answer.
10561
10562 @xref{Reporting Bugs}, if you find a problem that appears to be due
10563 to a bug or deficiency in Calc.
10564
10565 @menu
10566 * Autoloading Problems::
10567 * Recursion Depth::
10568 * Caches::
10569 * Debugging Calc::
10570 @end menu
10571
10572 @node Autoloading Problems, Recursion Depth, Troubleshooting Commands, Troubleshooting Commands
10573 @subsection Autoloading Problems
10574
10575 @noindent
10576 The Calc program is split into many component files; components are
10577 loaded automatically as you use various commands that require them.
10578 Occasionally Calc may lose track of when a certain component is
10579 necessary; typically this means you will type a command and it won't
10580 work because some function you've never heard of was undefined.
10581
10582 @kindex M-# L
10583 @pindex calc-load-everything
10584 If this happens, the easiest workaround is to type @kbd{M-# L}
10585 (@code{calc-load-everything}) to force all the parts of Calc to be
10586 loaded right away. This will cause Emacs to take up a lot more
10587 memory than it would otherwise, but it's guaranteed to fix the problem.
10588
10589 If you seem to run into this problem no matter what you do, or if
10590 even the @kbd{M-# L} command crashes, Calc may have been improperly
10591 installed. @xref{Installation}, for details of the installation
10592 process.
10593
10594 @node Recursion Depth, Caches, Autoloading Problems, Troubleshooting Commands
10595 @subsection Recursion Depth
10596
10597 @noindent
10598 @kindex M
10599 @kindex I M
10600 @pindex calc-more-recursion-depth
10601 @pindex calc-less-recursion-depth
10602 @cindex Recursion depth
10603 @cindex ``Computation got stuck'' message
10604 @cindex @code{max-lisp-eval-depth}
10605 @cindex @code{max-specpdl-size}
10606 Calc uses recursion in many of its calculations. Emacs Lisp keeps a
10607 variable @code{max-lisp-eval-depth} which limits the amount of recursion
10608 possible in an attempt to recover from program bugs. If a calculation
10609 ever halts incorrectly with the message ``Computation got stuck or
10610 ran too long,'' use the @kbd{M} command (@code{calc-more-recursion-depth})
10611 to increase this limit. (Of course, this will not help if the
10612 calculation really did get stuck due to some problem inside Calc.)
10613
10614 The limit is always increased (multiplied) by a factor of two. There
10615 is also an @kbd{I M} (@code{calc-less-recursion-depth}) command which
10616 decreases this limit by a factor of two, down to a minimum value of 200.
10617 The default value is 1000.
10618
10619 These commands also double or halve @code{max-specpdl-size}, another
10620 internal Lisp recursion limit. The minimum value for this limit is 600.
10621
10622 @node Caches, Debugging Calc, Recursion Depth, Troubleshooting Commands
10623 @subsection Caches
10624
10625 @noindent
10626 @cindex Caches
10627 @cindex Flushing caches
10628 Calc saves certain values after they have been computed once. For
10629 example, the @kbd{P} (@code{calc-pi}) command initially ``knows'' the
10630 constant @cpi{} to about 20 decimal places; if the current precision
10631 is greater than this, it will recompute @cpi{} using a series
10632 approximation. This value will not need to be recomputed ever again
10633 unless you raise the precision still further. Many operations such as
10634 logarithms and sines make use of similarly cached values such as
10635 @cpiover{4} and
10636 @texline @math{\ln 2}.
10637 @infoline @expr{ln(2)}.
10638 The visible effect of caching is that
10639 high-precision computations may seem to do extra work the first time.
10640 Other things cached include powers of two (for the binary arithmetic
10641 functions), matrix inverses and determinants, symbolic integrals, and
10642 data points computed by the graphing commands.
10643
10644 @pindex calc-flush-caches
10645 If you suspect a Calculator cache has become corrupt, you can use the
10646 @code{calc-flush-caches} command to reset all caches to the empty state.
10647 (This should only be necessary in the event of bugs in the Calculator.)
10648 The @kbd{M-# 0} (with the zero key) command also resets caches along
10649 with all other aspects of the Calculator's state.
10650
10651 @node Debugging Calc, , Caches, Troubleshooting Commands
10652 @subsection Debugging Calc
10653
10654 @noindent
10655 A few commands exist to help in the debugging of Calc commands.
10656 @xref{Programming}, to see the various ways that you can write
10657 your own Calc commands.
10658
10659 @kindex Z T
10660 @pindex calc-timing
10661 The @kbd{Z T} (@code{calc-timing}) command turns on and off a mode
10662 in which the timing of slow commands is reported in the Trail.
10663 Any Calc command that takes two seconds or longer writes a line
10664 to the Trail showing how many seconds it took. This value is
10665 accurate only to within one second.
10666
10667 All steps of executing a command are included; in particular, time
10668 taken to format the result for display in the stack and trail is
10669 counted. Some prompts also count time taken waiting for them to
10670 be answered, while others do not; this depends on the exact
10671 implementation of the command. For best results, if you are timing
10672 a sequence that includes prompts or multiple commands, define a
10673 keyboard macro to run the whole sequence at once. Calc's @kbd{X}
10674 command (@pxref{Keyboard Macros}) will then report the time taken
10675 to execute the whole macro.
10676
10677 Another advantage of the @kbd{X} command is that while it is
10678 executing, the stack and trail are not updated from step to step.
10679 So if you expect the output of your test sequence to leave a result
10680 that may take a long time to format and you don't wish to count
10681 this formatting time, end your sequence with a @key{DEL} keystroke
10682 to clear the result from the stack. When you run the sequence with
10683 @kbd{X}, Calc will never bother to format the large result.
10684
10685 Another thing @kbd{Z T} does is to increase the Emacs variable
10686 @code{gc-cons-threshold} to a much higher value (two million; the
10687 usual default in Calc is 250,000) for the duration of each command.
10688 This generally prevents garbage collection during the timing of
10689 the command, though it may cause your Emacs process to grow
10690 abnormally large. (Garbage collection time is a major unpredictable
10691 factor in the timing of Emacs operations.)
10692
10693 Another command that is useful when debugging your own Lisp
10694 extensions to Calc is @kbd{M-x calc-pass-errors}, which disables
10695 the error handler that changes the ``@code{max-lisp-eval-depth}
10696 exceeded'' message to the much more friendly ``Computation got
10697 stuck or ran too long.'' This handler interferes with the Emacs
10698 Lisp debugger's @code{debug-on-error} mode. Errors are reported
10699 in the handler itself rather than at the true location of the
10700 error. After you have executed @code{calc-pass-errors}, Lisp
10701 errors will be reported correctly but the user-friendly message
10702 will be lost.
10703
10704 @node Data Types, Stack and Trail, Introduction, Top
10705 @chapter Data Types
10706
10707 @noindent
10708 This chapter discusses the various types of objects that can be placed
10709 on the Calculator stack, how they are displayed, and how they are
10710 entered. (@xref{Data Type Formats}, for information on how these data
10711 types are represented as underlying Lisp objects.)
10712
10713 Integers, fractions, and floats are various ways of describing real
10714 numbers. HMS forms also for many purposes act as real numbers. These
10715 types can be combined to form complex numbers, modulo forms, error forms,
10716 or interval forms. (But these last four types cannot be combined
10717 arbitrarily:@: error forms may not contain modulo forms, for example.)
10718 Finally, all these types of numbers may be combined into vectors,
10719 matrices, or algebraic formulas.
10720
10721 @menu
10722 * Integers:: The most basic data type.
10723 * Fractions:: This and above are called @dfn{rationals}.
10724 * Floats:: This and above are called @dfn{reals}.
10725 * Complex Numbers:: This and above are called @dfn{numbers}.
10726 * Infinities::
10727 * Vectors and Matrices::
10728 * Strings::
10729 * HMS Forms::
10730 * Date Forms::
10731 * Modulo Forms::
10732 * Error Forms::
10733 * Interval Forms::
10734 * Incomplete Objects::
10735 * Variables::
10736 * Formulas::
10737 @end menu
10738
10739 @node Integers, Fractions, Data Types, Data Types
10740 @section Integers
10741
10742 @noindent
10743 @cindex Integers
10744 The Calculator stores integers to arbitrary precision. Addition,
10745 subtraction, and multiplication of integers always yields an exact
10746 integer result. (If the result of a division or exponentiation of
10747 integers is not an integer, it is expressed in fractional or
10748 floating-point form according to the current Fraction mode.
10749 @xref{Fraction Mode}.)
10750
10751 A decimal integer is represented as an optional sign followed by a
10752 sequence of digits. Grouping (@pxref{Grouping Digits}) can be used to
10753 insert a comma at every third digit for display purposes, but you
10754 must not type commas during the entry of numbers.
10755
10756 @kindex #
10757 A non-decimal integer is represented as an optional sign, a radix
10758 between 2 and 36, a @samp{#} symbol, and one or more digits. For radix 11
10759 and above, the letters A through Z (upper- or lower-case) count as
10760 digits and do not terminate numeric entry mode. @xref{Radix Modes}, for how
10761 to set the default radix for display of integers. Numbers of any radix
10762 may be entered at any time. If you press @kbd{#} at the beginning of a
10763 number, the current display radix is used.
10764
10765 @node Fractions, Floats, Integers, Data Types
10766 @section Fractions
10767
10768 @noindent
10769 @cindex Fractions
10770 A @dfn{fraction} is a ratio of two integers. Fractions are traditionally
10771 written ``2/3'' but Calc uses the notation @samp{2:3}. (The @kbd{/} key
10772 performs RPN division; the following two sequences push the number
10773 @samp{2:3} on the stack: @kbd{2 :@: 3 @key{RET}}, or @kbd{2 @key{RET} 3 /}
10774 assuming Fraction mode has been enabled.)
10775 When the Calculator produces a fractional result it always reduces it to
10776 simplest form, which may in fact be an integer.
10777
10778 Fractions may also be entered in a three-part form, where @samp{2:3:4}
10779 represents two-and-three-quarters. @xref{Fraction Formats}, for fraction
10780 display formats.
10781
10782 Non-decimal fractions are entered and displayed as
10783 @samp{@var{radix}#@var{num}:@var{denom}} (or in the analogous three-part
10784 form). The numerator and denominator always use the same radix.
10785
10786 @node Floats, Complex Numbers, Fractions, Data Types
10787 @section Floats
10788
10789 @noindent
10790 @cindex Floating-point numbers
10791 A floating-point number or @dfn{float} is a number stored in scientific
10792 notation. The number of significant digits in the fractional part is
10793 governed by the current floating precision (@pxref{Precision}). The
10794 range of acceptable values is from
10795 @texline @math{10^{-3999999}}
10796 @infoline @expr{10^-3999999}
10797 (inclusive) to
10798 @texline @math{10^{4000000}}
10799 @infoline @expr{10^4000000}
10800 (exclusive), plus the corresponding negative values and zero.
10801
10802 Calculations that would exceed the allowable range of values (such
10803 as @samp{exp(exp(20))}) are left in symbolic form by Calc. The
10804 messages ``floating-point overflow'' or ``floating-point underflow''
10805 indicate that during the calculation a number would have been produced
10806 that was too large or too close to zero, respectively, to be represented
10807 by Calc. This does not necessarily mean the final result would have
10808 overflowed, just that an overflow occurred while computing the result.
10809 (In fact, it could report an underflow even though the final result
10810 would have overflowed!)
10811
10812 If a rational number and a float are mixed in a calculation, the result
10813 will in general be expressed as a float. Commands that require an integer
10814 value (such as @kbd{k g} [@code{gcd}]) will also accept integer-valued
10815 floats, i.e., floating-point numbers with nothing after the decimal point.
10816
10817 Floats are identified by the presence of a decimal point and/or an
10818 exponent. In general a float consists of an optional sign, digits
10819 including an optional decimal point, and an optional exponent consisting
10820 of an @samp{e}, an optional sign, and up to seven exponent digits.
10821 For example, @samp{23.5e-2} is 23.5 times ten to the minus-second power,
10822 or 0.235.
10823
10824 Floating-point numbers are normally displayed in decimal notation with
10825 all significant figures shown. Exceedingly large or small numbers are
10826 displayed in scientific notation. Various other display options are
10827 available. @xref{Float Formats}.
10828
10829 @cindex Accuracy of calculations
10830 Floating-point numbers are stored in decimal, not binary. The result
10831 of each operation is rounded to the nearest value representable in the
10832 number of significant digits specified by the current precision,
10833 rounding away from zero in the case of a tie. Thus (in the default
10834 display mode) what you see is exactly what you get. Some operations such
10835 as square roots and transcendental functions are performed with several
10836 digits of extra precision and then rounded down, in an effort to make the
10837 final result accurate to the full requested precision. However,
10838 accuracy is not rigorously guaranteed. If you suspect the validity of a
10839 result, try doing the same calculation in a higher precision. The
10840 Calculator's arithmetic is not intended to be IEEE-conformant in any
10841 way.
10842
10843 While floats are always @emph{stored} in decimal, they can be entered
10844 and displayed in any radix just like integers and fractions. The
10845 notation @samp{@var{radix}#@var{ddd}.@var{ddd}} is a floating-point
10846 number whose digits are in the specified radix. Note that the @samp{.}
10847 is more aptly referred to as a ``radix point'' than as a decimal
10848 point in this case. The number @samp{8#123.4567} is defined as
10849 @samp{8#1234567 * 8^-4}. If the radix is 14 or less, you can use
10850 @samp{e} notation to write a non-decimal number in scientific notation.
10851 The exponent is written in decimal, and is considered to be a power
10852 of the radix: @samp{8#1234567e-4}. If the radix is 15 or above, the
10853 letter @samp{e} is a digit, so scientific notation must be written
10854 out, e.g., @samp{16#123.4567*16^2}. The first two exercises of the
10855 Modes Tutorial explore some of the properties of non-decimal floats.
10856
10857 @node Complex Numbers, Infinities, Floats, Data Types
10858 @section Complex Numbers
10859
10860 @noindent
10861 @cindex Complex numbers
10862 There are two supported formats for complex numbers: rectangular and
10863 polar. The default format is rectangular, displayed in the form
10864 @samp{(@var{real},@var{imag})} where @var{real} is the real part and
10865 @var{imag} is the imaginary part, each of which may be any real number.
10866 Rectangular complex numbers can also be displayed in @samp{@var{a}+@var{b}i}
10867 notation; @pxref{Complex Formats}.
10868
10869 Polar complex numbers are displayed in the form
10870 @texline `@tfn{(}@var{r}@tfn{;}@math{\theta}@tfn{)}'
10871 @infoline `@tfn{(}@var{r}@tfn{;}@var{theta}@tfn{)}'
10872 where @var{r} is the nonnegative magnitude and
10873 @texline @math{\theta}
10874 @infoline @var{theta}
10875 is the argument or phase angle. The range of
10876 @texline @math{\theta}
10877 @infoline @var{theta}
10878 depends on the current angular mode (@pxref{Angular Modes}); it is
10879 generally between @mathit{-180} and @mathit{+180} degrees or the equivalent range
10880 in radians.
10881
10882 Complex numbers are entered in stages using incomplete objects.
10883 @xref{Incomplete Objects}.
10884
10885 Operations on rectangular complex numbers yield rectangular complex
10886 results, and similarly for polar complex numbers. Where the two types
10887 are mixed, or where new complex numbers arise (as for the square root of
10888 a negative real), the current @dfn{Polar mode} is used to determine the
10889 type. @xref{Polar Mode}.
10890
10891 A complex result in which the imaginary part is zero (or the phase angle
10892 is 0 or 180 degrees or @cpi{} radians) is automatically converted to a real
10893 number.
10894
10895 @node Infinities, Vectors and Matrices, Complex Numbers, Data Types
10896 @section Infinities
10897
10898 @noindent
10899 @cindex Infinity
10900 @cindex @code{inf} variable
10901 @cindex @code{uinf} variable
10902 @cindex @code{nan} variable
10903 @vindex inf
10904 @vindex uinf
10905 @vindex nan
10906 The word @code{inf} represents the mathematical concept of @dfn{infinity}.
10907 Calc actually has three slightly different infinity-like values:
10908 @code{inf}, @code{uinf}, and @code{nan}. These are just regular
10909 variable names (@pxref{Variables}); you should avoid using these
10910 names for your own variables because Calc gives them special
10911 treatment. Infinities, like all variable names, are normally
10912 entered using algebraic entry.
10913
10914 Mathematically speaking, it is not rigorously correct to treat
10915 ``infinity'' as if it were a number, but mathematicians often do
10916 so informally. When they say that @samp{1 / inf = 0}, what they
10917 really mean is that @expr{1 / x}, as @expr{x} becomes larger and
10918 larger, becomes arbitrarily close to zero. So you can imagine
10919 that if @expr{x} got ``all the way to infinity,'' then @expr{1 / x}
10920 would go all the way to zero. Similarly, when they say that
10921 @samp{exp(inf) = inf}, they mean that
10922 @texline @math{e^x}
10923 @infoline @expr{exp(x)}
10924 grows without bound as @expr{x} grows. The symbol @samp{-inf} likewise
10925 stands for an infinitely negative real value; for example, we say that
10926 @samp{exp(-inf) = 0}. You can have an infinity pointing in any
10927 direction on the complex plane: @samp{sqrt(-inf) = i inf}.
10928
10929 The same concept of limits can be used to define @expr{1 / 0}. We
10930 really want the value that @expr{1 / x} approaches as @expr{x}
10931 approaches zero. But if all we have is @expr{1 / 0}, we can't
10932 tell which direction @expr{x} was coming from. If @expr{x} was
10933 positive and decreasing toward zero, then we should say that
10934 @samp{1 / 0 = inf}. But if @expr{x} was negative and increasing
10935 toward zero, the answer is @samp{1 / 0 = -inf}. In fact, @expr{x}
10936 could be an imaginary number, giving the answer @samp{i inf} or
10937 @samp{-i inf}. Calc uses the special symbol @samp{uinf} to mean
10938 @dfn{undirected infinity}, i.e., a value which is infinitely
10939 large but with an unknown sign (or direction on the complex plane).
10940
10941 Calc actually has three modes that say how infinities are handled.
10942 Normally, infinities never arise from calculations that didn't
10943 already have them. Thus, @expr{1 / 0} is treated simply as an
10944 error and left unevaluated. The @kbd{m i} (@code{calc-infinite-mode})
10945 command (@pxref{Infinite Mode}) enables a mode in which
10946 @expr{1 / 0} evaluates to @code{uinf} instead. There is also
10947 an alternative type of infinite mode which says to treat zeros
10948 as if they were positive, so that @samp{1 / 0 = inf}. While this
10949 is less mathematically correct, it may be the answer you want in
10950 some cases.
10951
10952 Since all infinities are ``as large'' as all others, Calc simplifies,
10953 e.g., @samp{5 inf} to @samp{inf}. Another example is
10954 @samp{5 - inf = -inf}, where the @samp{-inf} is so large that
10955 adding a finite number like five to it does not affect it.
10956 Note that @samp{a - inf} also results in @samp{-inf}; Calc assumes
10957 that variables like @code{a} always stand for finite quantities.
10958 Just to show that infinities really are all the same size,
10959 note that @samp{sqrt(inf) = inf^2 = exp(inf) = inf} in Calc's
10960 notation.
10961
10962 It's not so easy to define certain formulas like @samp{0 * inf} and
10963 @samp{inf / inf}. Depending on where these zeros and infinities
10964 came from, the answer could be literally anything. The latter
10965 formula could be the limit of @expr{x / x} (giving a result of one),
10966 or @expr{2 x / x} (giving two), or @expr{x^2 / x} (giving @code{inf}),
10967 or @expr{x / x^2} (giving zero). Calc uses the symbol @code{nan}
10968 to represent such an @dfn{indeterminate} value. (The name ``nan''
10969 comes from analogy with the ``NAN'' concept of IEEE standard
10970 arithmetic; it stands for ``Not A Number.'' This is somewhat of a
10971 misnomer, since @code{nan} @emph{does} stand for some number or
10972 infinity, it's just that @emph{which} number it stands for
10973 cannot be determined.) In Calc's notation, @samp{0 * inf = nan}
10974 and @samp{inf / inf = nan}. A few other common indeterminate
10975 expressions are @samp{inf - inf} and @samp{inf ^ 0}. Also,
10976 @samp{0 / 0 = nan} if you have turned on Infinite mode
10977 (as described above).
10978
10979 Infinities are especially useful as parts of @dfn{intervals}.
10980 @xref{Interval Forms}.
10981
10982 @node Vectors and Matrices, Strings, Infinities, Data Types
10983 @section Vectors and Matrices
10984
10985 @noindent
10986 @cindex Vectors
10987 @cindex Plain vectors
10988 @cindex Matrices
10989 The @dfn{vector} data type is flexible and general. A vector is simply a
10990 list of zero or more data objects. When these objects are numbers, the
10991 whole is a vector in the mathematical sense. When these objects are
10992 themselves vectors of equal (nonzero) length, the whole is a @dfn{matrix}.
10993 A vector which is not a matrix is referred to here as a @dfn{plain vector}.
10994
10995 A vector is displayed as a list of values separated by commas and enclosed
10996 in square brackets: @samp{[1, 2, 3]}. Thus the following is a 2 row by
10997 3 column matrix: @samp{[[1, 2, 3], [4, 5, 6]]}. Vectors, like complex
10998 numbers, are entered as incomplete objects. @xref{Incomplete Objects}.
10999 During algebraic entry, vectors are entered all at once in the usual
11000 brackets-and-commas form. Matrices may be entered algebraically as nested
11001 vectors, or using the shortcut notation @w{@samp{[1, 2, 3; 4, 5, 6]}},
11002 with rows separated by semicolons. The commas may usually be omitted
11003 when entering vectors: @samp{[1 2 3]}. Curly braces may be used in
11004 place of brackets: @samp{@{1, 2, 3@}}, but the commas are required in
11005 this case.
11006
11007 Traditional vector and matrix arithmetic is also supported;
11008 @pxref{Basic Arithmetic} and @pxref{Matrix Functions}.
11009 Many other operations are applied to vectors element-wise. For example,
11010 the complex conjugate of a vector is a vector of the complex conjugates
11011 of its elements.
11012
11013 @ignore
11014 @starindex
11015 @end ignore
11016 @tindex vec
11017 Algebraic functions for building vectors include @samp{vec(a, b, c)}
11018 to build @samp{[a, b, c]}, @samp{cvec(a, n, m)} to build an
11019 @texline @math{n\times m}
11020 @infoline @var{n}x@var{m}
11021 matrix of @samp{a}s, and @samp{index(n)} to build a vector of integers
11022 from 1 to @samp{n}.
11023
11024 @node Strings, HMS Forms, Vectors and Matrices, Data Types
11025 @section Strings
11026
11027 @noindent
11028 @kindex "
11029 @cindex Strings
11030 @cindex Character strings
11031 Character strings are not a special data type in the Calculator.
11032 Rather, a string is represented simply as a vector all of whose
11033 elements are integers in the range 0 to 255 (ASCII codes). You can
11034 enter a string at any time by pressing the @kbd{"} key. Quotation
11035 marks and backslashes are written @samp{\"} and @samp{\\}, respectively,
11036 inside strings. Other notations introduced by backslashes are:
11037
11038 @example
11039 @group
11040 \a 7 \^@@ 0
11041 \b 8 \^a-z 1-26
11042 \e 27 \^[ 27
11043 \f 12 \^\\ 28
11044 \n 10 \^] 29
11045 \r 13 \^^ 30
11046 \t 9 \^_ 31
11047 \^? 127
11048 @end group
11049 @end example
11050
11051 @noindent
11052 Finally, a backslash followed by three octal digits produces any
11053 character from its ASCII code.
11054
11055 @kindex d "
11056 @pindex calc-display-strings
11057 Strings are normally displayed in vector-of-integers form. The
11058 @w{@kbd{d "}} (@code{calc-display-strings}) command toggles a mode in
11059 which any vectors of small integers are displayed as quoted strings
11060 instead.
11061
11062 The backslash notations shown above are also used for displaying
11063 strings. Characters 128 and above are not translated by Calc; unless
11064 you have an Emacs modified for 8-bit fonts, these will show up in
11065 backslash-octal-digits notation. For characters below 32, and
11066 for character 127, Calc uses the backslash-letter combination if
11067 there is one, or otherwise uses a @samp{\^} sequence.
11068
11069 The only Calc feature that uses strings is @dfn{compositions};
11070 @pxref{Compositions}. Strings also provide a convenient
11071 way to do conversions between ASCII characters and integers.
11072
11073 @ignore
11074 @starindex
11075 @end ignore
11076 @tindex string
11077 There is a @code{string} function which provides a different display
11078 format for strings. Basically, @samp{string(@var{s})}, where @var{s}
11079 is a vector of integers in the proper range, is displayed as the
11080 corresponding string of characters with no surrounding quotation
11081 marks or other modifications. Thus @samp{string("ABC")} (or
11082 @samp{string([65 66 67])}) will look like @samp{ABC} on the stack.
11083 This happens regardless of whether @w{@kbd{d "}} has been used. The
11084 only way to turn it off is to use @kbd{d U} (unformatted language
11085 mode) which will display @samp{string("ABC")} instead.
11086
11087 Control characters are displayed somewhat differently by @code{string}.
11088 Characters below 32, and character 127, are shown using @samp{^} notation
11089 (same as shown above, but without the backslash). The quote and
11090 backslash characters are left alone, as are characters 128 and above.
11091
11092 @ignore
11093 @starindex
11094 @end ignore
11095 @tindex bstring
11096 The @code{bstring} function is just like @code{string} except that
11097 the resulting string is breakable across multiple lines if it doesn't
11098 fit all on one line. Potential break points occur at every space
11099 character in the string.
11100
11101 @node HMS Forms, Date Forms, Strings, Data Types
11102 @section HMS Forms
11103
11104 @noindent
11105 @cindex Hours-minutes-seconds forms
11106 @cindex Degrees-minutes-seconds forms
11107 @dfn{HMS} stands for Hours-Minutes-Seconds; when used as an angular
11108 argument, the interpretation is Degrees-Minutes-Seconds. All functions
11109 that operate on angles accept HMS forms. These are interpreted as
11110 degrees regardless of the current angular mode. It is also possible to
11111 use HMS as the angular mode so that calculated angles are expressed in
11112 degrees, minutes, and seconds.
11113
11114 @kindex @@
11115 @ignore
11116 @mindex @null
11117 @end ignore
11118 @kindex ' (HMS forms)
11119 @ignore
11120 @mindex @null
11121 @end ignore
11122 @kindex " (HMS forms)
11123 @ignore
11124 @mindex @null
11125 @end ignore
11126 @kindex h (HMS forms)
11127 @ignore
11128 @mindex @null
11129 @end ignore
11130 @kindex o (HMS forms)
11131 @ignore
11132 @mindex @null
11133 @end ignore
11134 @kindex m (HMS forms)
11135 @ignore
11136 @mindex @null
11137 @end ignore
11138 @kindex s (HMS forms)
11139 The default format for HMS values is
11140 @samp{@var{hours}@@ @var{mins}' @var{secs}"}. During entry, the letters
11141 @samp{h} (for ``hours'') or
11142 @samp{o} (approximating the ``degrees'' symbol) are accepted as well as
11143 @samp{@@}, @samp{m} is accepted in place of @samp{'}, and @samp{s} is
11144 accepted in place of @samp{"}.
11145 The @var{hours} value is an integer (or integer-valued float).
11146 The @var{mins} value is an integer or integer-valued float between 0 and 59.
11147 The @var{secs} value is a real number between 0 (inclusive) and 60
11148 (exclusive). A positive HMS form is interpreted as @var{hours} +
11149 @var{mins}/60 + @var{secs}/3600. A negative HMS form is interpreted
11150 as @mathit{- @var{hours}} @mathit{-} @var{mins}/60 @mathit{-} @var{secs}/3600.
11151 Display format for HMS forms is quite flexible. @xref{HMS Formats}.
11152
11153 HMS forms can be added and subtracted. When they are added to numbers,
11154 the numbers are interpreted according to the current angular mode. HMS
11155 forms can also be multiplied and divided by real numbers. Dividing
11156 two HMS forms produces a real-valued ratio of the two angles.
11157
11158 @pindex calc-time
11159 @cindex Time of day
11160 Just for kicks, @kbd{M-x calc-time} pushes the current time of day on
11161 the stack as an HMS form.
11162
11163 @node Date Forms, Modulo Forms, HMS Forms, Data Types
11164 @section Date Forms
11165
11166 @noindent
11167 @cindex Date forms
11168 A @dfn{date form} represents a date and possibly an associated time.
11169 Simple date arithmetic is supported: Adding a number to a date
11170 produces a new date shifted by that many days; adding an HMS form to
11171 a date shifts it by that many hours. Subtracting two date forms
11172 computes the number of days between them (represented as a simple
11173 number). Many other operations, such as multiplying two date forms,
11174 are nonsensical and are not allowed by Calc.
11175
11176 Date forms are entered and displayed enclosed in @samp{< >} brackets.
11177 The default format is, e.g., @samp{<Wed Jan 9, 1991>} for dates,
11178 or @samp{<3:32:20pm Wed Jan 9, 1991>} for dates with times.
11179 Input is flexible; date forms can be entered in any of the usual
11180 notations for dates and times. @xref{Date Formats}.
11181
11182 Date forms are stored internally as numbers, specifically the number
11183 of days since midnight on the morning of January 1 of the year 1 AD.
11184 If the internal number is an integer, the form represents a date only;
11185 if the internal number is a fraction or float, the form represents
11186 a date and time. For example, @samp{<6:00am Wed Jan 9, 1991>}
11187 is represented by the number 726842.25. The standard precision of
11188 12 decimal digits is enough to ensure that a (reasonable) date and
11189 time can be stored without roundoff error.
11190
11191 If the current precision is greater than 12, date forms will keep
11192 additional digits in the seconds position. For example, if the
11193 precision is 15, the seconds will keep three digits after the
11194 decimal point. Decreasing the precision below 12 may cause the
11195 time part of a date form to become inaccurate. This can also happen
11196 if astronomically high years are used, though this will not be an
11197 issue in everyday (or even everymillennium) use. Note that date
11198 forms without times are stored as exact integers, so roundoff is
11199 never an issue for them.
11200
11201 You can use the @kbd{v p} (@code{calc-pack}) and @kbd{v u}
11202 (@code{calc-unpack}) commands to get at the numerical representation
11203 of a date form. @xref{Packing and Unpacking}.
11204
11205 Date forms can go arbitrarily far into the future or past. Negative
11206 year numbers represent years BC. Calc uses a combination of the
11207 Gregorian and Julian calendars, following the history of Great
11208 Britain and the British colonies. This is the same calendar that
11209 is used by the @code{cal} program in most Unix implementations.
11210
11211 @cindex Julian calendar
11212 @cindex Gregorian calendar
11213 Some historical background: The Julian calendar was created by
11214 Julius Caesar in the year 46 BC as an attempt to fix the gradual
11215 drift caused by the lack of leap years in the calendar used
11216 until that time. The Julian calendar introduced an extra day in
11217 all years divisible by four. After some initial confusion, the
11218 calendar was adopted around the year we call 8 AD. Some centuries
11219 later it became apparent that the Julian year of 365.25 days was
11220 itself not quite right. In 1582 Pope Gregory XIII introduced the
11221 Gregorian calendar, which added the new rule that years divisible
11222 by 100, but not by 400, were not to be considered leap years
11223 despite being divisible by four. Many countries delayed adoption
11224 of the Gregorian calendar because of religious differences;
11225 in Britain it was put off until the year 1752, by which time
11226 the Julian calendar had fallen eleven days behind the true
11227 seasons. So the switch to the Gregorian calendar in early
11228 September 1752 introduced a discontinuity: The day after
11229 Sep 2, 1752 is Sep 14, 1752. Calc follows this convention.
11230 To take another example, Russia waited until 1918 before
11231 adopting the new calendar, and thus needed to remove thirteen
11232 days (between Feb 1, 1918 and Feb 14, 1918). This means that
11233 Calc's reckoning will be inconsistent with Russian history between
11234 1752 and 1918, and similarly for various other countries.
11235
11236 Today's timekeepers introduce an occasional ``leap second'' as
11237 well, but Calc does not take these minor effects into account.
11238 (If it did, it would have to report a non-integer number of days
11239 between, say, @samp{<12:00am Mon Jan 1, 1900>} and
11240 @samp{<12:00am Sat Jan 1, 2000>}.)
11241
11242 Calc uses the Julian calendar for all dates before the year 1752,
11243 including dates BC when the Julian calendar technically had not
11244 yet been invented. Thus the claim that day number @mathit{-10000} is
11245 called ``August 16, 28 BC'' should be taken with a grain of salt.
11246
11247 Please note that there is no ``year 0''; the day before
11248 @samp{<Sat Jan 1, +1>} is @samp{<Fri Dec 31, -1>}. These are
11249 days 0 and @mathit{-1} respectively in Calc's internal numbering scheme.
11250
11251 @cindex Julian day counting
11252 Another day counting system in common use is, confusingly, also
11253 called ``Julian.'' It was invented in 1583 by Joseph Justus
11254 Scaliger, who named it in honor of his father Julius Caesar
11255 Scaliger. For obscure reasons he chose to start his day
11256 numbering on Jan 1, 4713 BC at noon, which in Calc's scheme
11257 is @mathit{-1721423.5} (recall that Calc starts at midnight instead
11258 of noon). Thus to convert a Calc date code obtained by
11259 unpacking a date form into a Julian day number, simply add
11260 1721423.5. The Julian code for @samp{6:00am Jan 9, 1991}
11261 is 2448265.75. The built-in @kbd{t J} command performs
11262 this conversion for you.
11263
11264 @cindex Unix time format
11265 The Unix operating system measures time as an integer number of
11266 seconds since midnight, Jan 1, 1970. To convert a Calc date
11267 value into a Unix time stamp, first subtract 719164 (the code
11268 for @samp{<Jan 1, 1970>}), then multiply by 86400 (the number of
11269 seconds in a day) and press @kbd{R} to round to the nearest
11270 integer. If you have a date form, you can simply subtract the
11271 day @samp{<Jan 1, 1970>} instead of unpacking and subtracting
11272 719164. Likewise, divide by 86400 and add @samp{<Jan 1, 1970>}
11273 to convert from Unix time to a Calc date form. (Note that
11274 Unix normally maintains the time in the GMT time zone; you may
11275 need to subtract five hours to get New York time, or eight hours
11276 for California time. The same is usually true of Julian day
11277 counts.) The built-in @kbd{t U} command performs these
11278 conversions.
11279
11280 @node Modulo Forms, Error Forms, Date Forms, Data Types
11281 @section Modulo Forms
11282
11283 @noindent
11284 @cindex Modulo forms
11285 A @dfn{modulo form} is a real number which is taken modulo (i.e., within
11286 an integer multiple of) some value @var{M}. Arithmetic modulo @var{M}
11287 often arises in number theory. Modulo forms are written
11288 `@var{a} @tfn{mod} @var{M}',
11289 where @var{a} and @var{M} are real numbers or HMS forms, and
11290 @texline @math{0 \le a < M}.
11291 @infoline @expr{0 <= a < @var{M}}.
11292 In many applications @expr{a} and @expr{M} will be
11293 integers but this is not required.
11294
11295 Modulo forms are not to be confused with the modulo operator @samp{%}.
11296 The expression @samp{27 % 10} means to compute 27 modulo 10 to produce
11297 the result 7. Further computations treat this 7 as just a regular integer.
11298 The expression @samp{27 mod 10} produces the result @samp{7 mod 10};
11299 further computations with this value are again reduced modulo 10 so that
11300 the result always lies in the desired range.
11301
11302 When two modulo forms with identical @expr{M}'s are added or multiplied,
11303 the Calculator simply adds or multiplies the values, then reduces modulo
11304 @expr{M}. If one argument is a modulo form and the other a plain number,
11305 the plain number is treated like a compatible modulo form. It is also
11306 possible to raise modulo forms to powers; the result is the value raised
11307 to the power, then reduced modulo @expr{M}. (When all values involved
11308 are integers, this calculation is done much more efficiently than
11309 actually computing the power and then reducing.)
11310
11311 @cindex Modulo division
11312 Two modulo forms `@var{a} @tfn{mod} @var{M}' and `@var{b} @tfn{mod} @var{M}'
11313 can be divided if @expr{a}, @expr{b}, and @expr{M} are all
11314 integers. The result is the modulo form which, when multiplied by
11315 `@var{b} @tfn{mod} @var{M}', produces `@var{a} @tfn{mod} @var{M}'. If
11316 there is no solution to this equation (which can happen only when
11317 @expr{M} is non-prime), or if any of the arguments are non-integers, the
11318 division is left in symbolic form. Other operations, such as square
11319 roots, are not yet supported for modulo forms. (Note that, although
11320 @w{`@tfn{(}@var{a} @tfn{mod} @var{M}@tfn{)^.5}'} will compute a ``modulo square root''
11321 in the sense of reducing
11322 @texline @math{\sqrt a}
11323 @infoline @expr{sqrt(a)}
11324 modulo @expr{M}, this is not a useful definition from the
11325 number-theoretical point of view.)
11326
11327 @ignore
11328 @mindex M
11329 @end ignore
11330 @kindex M (modulo forms)
11331 @ignore
11332 @mindex mod
11333 @end ignore
11334 @tindex mod (operator)
11335 To create a modulo form during numeric entry, press the shift-@kbd{M}
11336 key to enter the word @samp{mod}. As a special convenience, pressing
11337 shift-@kbd{M} a second time automatically enters the value of @expr{M}
11338 that was most recently used before. During algebraic entry, either
11339 type @samp{mod} by hand or press @kbd{M-m} (that's @kbd{@key{META}-m}).
11340 Once again, pressing this a second time enters the current modulo.
11341
11342 You can also use @kbd{v p} and @kbd{%} to modify modulo forms.
11343 @xref{Building Vectors}. @xref{Basic Arithmetic}.
11344
11345 It is possible to mix HMS forms and modulo forms. For example, an
11346 HMS form modulo 24 could be used to manipulate clock times; an HMS
11347 form modulo 360 would be suitable for angles. Making the modulo @expr{M}
11348 also be an HMS form eliminates troubles that would arise if the angular
11349 mode were inadvertently set to Radians, in which case
11350 @w{@samp{2@@ 0' 0" mod 24}} would be interpreted as two degrees modulo
11351 24 radians!
11352
11353 Modulo forms cannot have variables or formulas for components. If you
11354 enter the formula @samp{(x + 2) mod 5}, Calc propagates the modulus
11355 to each of the coefficients: @samp{(1 mod 5) x + (2 mod 5)}.
11356
11357 @ignore
11358 @starindex
11359 @end ignore
11360 @tindex makemod
11361 The algebraic function @samp{makemod(a, m)} builds the modulo form
11362 @w{@samp{a mod m}}.
11363
11364 @node Error Forms, Interval Forms, Modulo Forms, Data Types
11365 @section Error Forms
11366
11367 @noindent
11368 @cindex Error forms
11369 @cindex Standard deviations
11370 An @dfn{error form} is a number with an associated standard
11371 deviation, as in @samp{2.3 +/- 0.12}. The notation
11372 @texline `@var{x} @tfn{+/-} @math{\sigma}'
11373 @infoline `@var{x} @tfn{+/-} sigma'
11374 stands for an uncertain value which follows
11375 a normal or Gaussian distribution of mean @expr{x} and standard
11376 deviation or ``error''
11377 @texline @math{\sigma}.
11378 @infoline @expr{sigma}.
11379 Both the mean and the error can be either numbers or
11380 formulas. Generally these are real numbers but the mean may also be
11381 complex. If the error is negative or complex, it is changed to its
11382 absolute value. An error form with zero error is converted to a
11383 regular number by the Calculator.
11384
11385 All arithmetic and transcendental functions accept error forms as input.
11386 Operations on the mean-value part work just like operations on regular
11387 numbers. The error part for any function @expr{f(x)} (such as
11388 @texline @math{\sin x}
11389 @infoline @expr{sin(x)})
11390 is defined by the error of @expr{x} times the derivative of @expr{f}
11391 evaluated at the mean value of @expr{x}. For a two-argument function
11392 @expr{f(x,y)} (such as addition) the error is the square root of the sum
11393 of the squares of the errors due to @expr{x} and @expr{y}.
11394 @tex
11395 $$ \eqalign{
11396 f(x \hbox{\code{ +/- }} \sigma)
11397 &= f(x) \hbox{\code{ +/- }} \sigma \left| {df(x) \over dx} \right| \cr
11398 f(x \hbox{\code{ +/- }} \sigma_x, y \hbox{\code{ +/- }} \sigma_y)
11399 &= f(x,y) \hbox{\code{ +/- }}
11400 \sqrt{\left(\sigma_x \left| {\partial f(x,y) \over \partial x}
11401 \right| \right)^2
11402 +\left(\sigma_y \left| {\partial f(x,y) \over \partial y}
11403 \right| \right)^2 } \cr
11404 } $$
11405 @end tex
11406 Note that this
11407 definition assumes the errors in @expr{x} and @expr{y} are uncorrelated.
11408 A side effect of this definition is that @samp{(2 +/- 1) * (2 +/- 1)}
11409 is not the same as @samp{(2 +/- 1)^2}; the former represents the product
11410 of two independent values which happen to have the same probability
11411 distributions, and the latter is the product of one random value with itself.
11412 The former will produce an answer with less error, since on the average
11413 the two independent errors can be expected to cancel out.
11414
11415 Consult a good text on error analysis for a discussion of the proper use
11416 of standard deviations. Actual errors often are neither Gaussian-distributed
11417 nor uncorrelated, and the above formulas are valid only when errors
11418 are small. As an example, the error arising from
11419 @texline `@tfn{sin(}@var{x} @tfn{+/-} @math{\sigma}@tfn{)}'
11420 @infoline `@tfn{sin(}@var{x} @tfn{+/-} @var{sigma}@tfn{)}'
11421 is
11422 @texline `@math{\sigma} @tfn{abs(cos(}@var{x}@tfn{))}'.
11423 @infoline `@var{sigma} @tfn{abs(cos(}@var{x}@tfn{))}'.
11424 When @expr{x} is close to zero,
11425 @texline @math{\cos x}
11426 @infoline @expr{cos(x)}
11427 is close to one so the error in the sine is close to
11428 @texline @math{\sigma};
11429 @infoline @expr{sigma};
11430 this makes sense, since
11431 @texline @math{\sin x}
11432 @infoline @expr{sin(x)}
11433 is approximately @expr{x} near zero, so a given error in @expr{x} will
11434 produce about the same error in the sine. Likewise, near 90 degrees
11435 @texline @math{\cos x}
11436 @infoline @expr{cos(x)}
11437 is nearly zero and so the computed error is
11438 small: The sine curve is nearly flat in that region, so an error in @expr{x}
11439 has relatively little effect on the value of
11440 @texline @math{\sin x}.
11441 @infoline @expr{sin(x)}.
11442 However, consider @samp{sin(90 +/- 1000)}. The cosine of 90 is zero, so
11443 Calc will report zero error! We get an obviously wrong result because
11444 we have violated the small-error approximation underlying the error
11445 analysis. If the error in @expr{x} had been small, the error in
11446 @texline @math{\sin x}
11447 @infoline @expr{sin(x)}
11448 would indeed have been negligible.
11449
11450 @ignore
11451 @mindex p
11452 @end ignore
11453 @kindex p (error forms)
11454 @tindex +/-
11455 To enter an error form during regular numeric entry, use the @kbd{p}
11456 (``plus-or-minus'') key to type the @samp{+/-} symbol. (If you try actually
11457 typing @samp{+/-} the @kbd{+} key will be interpreted as the Calculator's
11458 @kbd{+} command!) Within an algebraic formula, you can press @kbd{M-p} to
11459 type the @samp{+/-} symbol, or type it out by hand.
11460
11461 Error forms and complex numbers can be mixed; the formulas shown above
11462 are used for complex numbers, too; note that if the error part evaluates
11463 to a complex number its absolute value (or the square root of the sum of
11464 the squares of the absolute values of the two error contributions) is
11465 used. Mathematically, this corresponds to a radially symmetric Gaussian
11466 distribution of numbers on the complex plane. However, note that Calc
11467 considers an error form with real components to represent a real number,
11468 not a complex distribution around a real mean.
11469
11470 Error forms may also be composed of HMS forms. For best results, both
11471 the mean and the error should be HMS forms if either one is.
11472
11473 @ignore
11474 @starindex
11475 @end ignore
11476 @tindex sdev
11477 The algebraic function @samp{sdev(a, b)} builds the error form @samp{a +/- b}.
11478
11479 @node Interval Forms, Incomplete Objects, Error Forms, Data Types
11480 @section Interval Forms
11481
11482 @noindent
11483 @cindex Interval forms
11484 An @dfn{interval} is a subset of consecutive real numbers. For example,
11485 the interval @samp{[2 ..@: 4]} represents all the numbers from 2 to 4,
11486 inclusive. If you multiply it by the interval @samp{[0.5 ..@: 2]} you
11487 obtain @samp{[1 ..@: 8]}. This calculation represents the fact that if
11488 you multiply some number in the range @samp{[2 ..@: 4]} by some other
11489 number in the range @samp{[0.5 ..@: 2]}, your result will lie in the range
11490 from 1 to 8. Interval arithmetic is used to get a worst-case estimate
11491 of the possible range of values a computation will produce, given the
11492 set of possible values of the input.
11493
11494 @ifinfo
11495 Calc supports several varieties of intervals, including @dfn{closed}
11496 intervals of the type shown above, @dfn{open} intervals such as
11497 @samp{(2 ..@: 4)}, which represents the range of numbers from 2 to 4
11498 @emph{exclusive}, and @dfn{semi-open} intervals in which one end
11499 uses a round parenthesis and the other a square bracket. In mathematical
11500 terms,
11501 @samp{[2 ..@: 4]} means @expr{2 <= x <= 4}, whereas
11502 @samp{[2 ..@: 4)} represents @expr{2 <= x < 4},
11503 @samp{(2 ..@: 4]} represents @expr{2 < x <= 4}, and
11504 @samp{(2 ..@: 4)} represents @expr{2 < x < 4}.
11505 @end ifinfo
11506 @tex
11507 Calc supports several varieties of intervals, including \dfn{closed}
11508 intervals of the type shown above, \dfn{open} intervals such as
11509 \samp{(2 ..\: 4)}, which represents the range of numbers from 2 to 4
11510 \emph{exclusive}, and \dfn{semi-open} intervals in which one end
11511 uses a round parenthesis and the other a square bracket. In mathematical
11512 terms,
11513 $$ \eqalign{
11514 [2 \hbox{\cite{..}} 4] &\quad\hbox{means}\quad 2 \le x \le 4 \cr
11515 [2 \hbox{\cite{..}} 4) &\quad\hbox{means}\quad 2 \le x < 4 \cr
11516 (2 \hbox{\cite{..}} 4] &\quad\hbox{means}\quad 2 < x \le 4 \cr
11517 (2 \hbox{\cite{..}} 4) &\quad\hbox{means}\quad 2 < x < 4 \cr
11518 } $$
11519 @end tex
11520
11521 The lower and upper limits of an interval must be either real numbers
11522 (or HMS or date forms), or symbolic expressions which are assumed to be
11523 real-valued, or @samp{-inf} and @samp{inf}. In general the lower limit
11524 must be less than the upper limit. A closed interval containing only
11525 one value, @samp{[3 ..@: 3]}, is converted to a plain number (3)
11526 automatically. An interval containing no values at all (such as
11527 @samp{[3 ..@: 2]} or @samp{[2 ..@: 2)}) can be represented but is not
11528 guaranteed to behave well when used in arithmetic. Note that the
11529 interval @samp{[3 .. inf)} represents all real numbers greater than
11530 or equal to 3, and @samp{(-inf .. inf)} represents all real numbers.
11531 In fact, @samp{[-inf .. inf]} represents all real numbers including
11532 the real infinities.
11533
11534 Intervals are entered in the notation shown here, either as algebraic
11535 formulas, or using incomplete forms. (@xref{Incomplete Objects}.)
11536 In algebraic formulas, multiple periods in a row are collected from
11537 left to right, so that @samp{1...1e2} is interpreted as @samp{1.0 ..@: 1e2}
11538 rather than @samp{1 ..@: 0.1e2}. Add spaces or zeros if you want to
11539 get the other interpretation. If you omit the lower or upper limit,
11540 a default of @samp{-inf} or @samp{inf} (respectively) is furnished.
11541
11542 Infinite mode also affects operations on intervals
11543 (@pxref{Infinities}). Calc will always introduce an open infinity,
11544 as in @samp{1 / (0 .. 2] = [0.5 .. inf)}. But closed infinities,
11545 @w{@samp{1 / [0 .. 2] = [0.5 .. inf]}}, arise only in Infinite mode;
11546 otherwise they are left unevaluated. Note that the ``direction'' of
11547 a zero is not an issue in this case since the zero is always assumed
11548 to be continuous with the rest of the interval. For intervals that
11549 contain zero inside them Calc is forced to give the result,
11550 @samp{1 / (-2 .. 2) = [-inf .. inf]}.
11551
11552 While it may seem that intervals and error forms are similar, they are
11553 based on entirely different concepts of inexact quantities. An error
11554 form
11555 @texline `@var{x} @tfn{+/-} @math{\sigma}'
11556 @infoline `@var{x} @tfn{+/-} @var{sigma}'
11557 means a variable is random, and its value could
11558 be anything but is ``probably'' within one
11559 @texline @math{\sigma}
11560 @infoline @var{sigma}
11561 of the mean value @expr{x}. An interval
11562 `@tfn{[}@var{a} @tfn{..@:} @var{b}@tfn{]}' means a
11563 variable's value is unknown, but guaranteed to lie in the specified
11564 range. Error forms are statistical or ``average case'' approximations;
11565 interval arithmetic tends to produce ``worst case'' bounds on an
11566 answer.
11567
11568 Intervals may not contain complex numbers, but they may contain
11569 HMS forms or date forms.
11570
11571 @xref{Set Operations}, for commands that interpret interval forms
11572 as subsets of the set of real numbers.
11573
11574 @ignore
11575 @starindex
11576 @end ignore
11577 @tindex intv
11578 The algebraic function @samp{intv(n, a, b)} builds an interval form
11579 from @samp{a} to @samp{b}; @samp{n} is an integer code which must
11580 be 0 for @samp{(..)}, 1 for @samp{(..]}, 2 for @samp{[..)}, or
11581 3 for @samp{[..]}.
11582
11583 Please note that in fully rigorous interval arithmetic, care would be
11584 taken to make sure that the computation of the lower bound rounds toward
11585 minus infinity, while upper bound computations round toward plus
11586 infinity. Calc's arithmetic always uses a round-to-nearest mode,
11587 which means that roundoff errors could creep into an interval
11588 calculation to produce intervals slightly smaller than they ought to
11589 be. For example, entering @samp{[1..2]} and pressing @kbd{Q 2 ^}
11590 should yield the interval @samp{[1..2]} again, but in fact it yields the
11591 (slightly too small) interval @samp{[1..1.9999999]} due to roundoff
11592 error.
11593
11594 @node Incomplete Objects, Variables, Interval Forms, Data Types
11595 @section Incomplete Objects
11596
11597 @noindent
11598 @ignore
11599 @mindex [ ]
11600 @end ignore
11601 @kindex [
11602 @ignore
11603 @mindex ( )
11604 @end ignore
11605 @kindex (
11606 @kindex ,
11607 @ignore
11608 @mindex @null
11609 @end ignore
11610 @kindex ]
11611 @ignore
11612 @mindex @null
11613 @end ignore
11614 @kindex )
11615 @cindex Incomplete vectors
11616 @cindex Incomplete complex numbers
11617 @cindex Incomplete interval forms
11618 When @kbd{(} or @kbd{[} is typed to begin entering a complex number or
11619 vector, respectively, the effect is to push an @dfn{incomplete} complex
11620 number or vector onto the stack. The @kbd{,} key adds the value(s) at
11621 the top of the stack onto the current incomplete object. The @kbd{)}
11622 and @kbd{]} keys ``close'' the incomplete object after adding any values
11623 on the top of the stack in front of the incomplete object.
11624
11625 As a result, the sequence of keystrokes @kbd{[ 2 , 3 @key{RET} 2 * , 9 ]}
11626 pushes the vector @samp{[2, 6, 9]} onto the stack. Likewise, @kbd{( 1 , 2 Q )}
11627 pushes the complex number @samp{(1, 1.414)} (approximately).
11628
11629 If several values lie on the stack in front of the incomplete object,
11630 all are collected and appended to the object. Thus the @kbd{,} key
11631 is redundant: @kbd{[ 2 @key{RET} 3 @key{RET} 2 * 9 ]}. Some people
11632 prefer the equivalent @key{SPC} key to @key{RET}.
11633
11634 As a special case, typing @kbd{,} immediately after @kbd{(}, @kbd{[}, or
11635 @kbd{,} adds a zero or duplicates the preceding value in the list being
11636 formed. Typing @key{DEL} during incomplete entry removes the last item
11637 from the list.
11638
11639 @kindex ;
11640 The @kbd{;} key is used in the same way as @kbd{,} to create polar complex
11641 numbers: @kbd{( 1 ; 2 )}. When entering a vector, @kbd{;} is useful for
11642 creating a matrix. In particular, @kbd{[ [ 1 , 2 ; 3 , 4 ; 5 , 6 ] ]} is
11643 equivalent to @kbd{[ [ 1 , 2 ] , [ 3 , 4 ] , [ 5 , 6 ] ]}.
11644
11645 @kindex ..
11646 @pindex calc-dots
11647 Incomplete entry is also used to enter intervals. For example,
11648 @kbd{[ 2 ..@: 4 )} enters a semi-open interval. Note that when you type
11649 the first period, it will be interpreted as a decimal point, but when
11650 you type a second period immediately afterward, it is re-interpreted as
11651 part of the interval symbol. Typing @kbd{..} corresponds to executing
11652 the @code{calc-dots} command.
11653
11654 If you find incomplete entry distracting, you may wish to enter vectors
11655 and complex numbers as algebraic formulas by pressing the apostrophe key.
11656
11657 @node Variables, Formulas, Incomplete Objects, Data Types
11658 @section Variables
11659
11660 @noindent
11661 @cindex Variables, in formulas
11662 A @dfn{variable} is somewhere between a storage register on a conventional
11663 calculator, and a variable in a programming language. (In fact, a Calc
11664 variable is really just an Emacs Lisp variable that contains a Calc number
11665 or formula.) A variable's name is normally composed of letters and digits.
11666 Calc also allows apostrophes and @code{#} signs in variable names.
11667 (The Calc variable @code{foo} corresponds to the Emacs Lisp variable
11668 @code{var-foo}, but unless you access the variable from within Emacs
11669 Lisp, you don't need to worry about it. Variable names in algebraic
11670 formulas implicitly have @samp{var-} prefixed to their names. The
11671 @samp{#} character in variable names used in algebraic formulas
11672 corresponds to a dash @samp{-} in the Lisp variable name. If the name
11673 contains any dashes, the prefix @samp{var-} is @emph{not} automatically
11674 added. Thus the two formulas @samp{foo + 1} and @samp{var#foo + 1} both
11675 refer to the same variable.)
11676
11677 In a command that takes a variable name, you can either type the full
11678 name of a variable, or type a single digit to use one of the special
11679 convenience variables @code{q0} through @code{q9}. For example,
11680 @kbd{3 s s 2} stores the number 3 in variable @code{q2}, and
11681 @w{@kbd{3 s s foo @key{RET}}} stores that number in variable
11682 @code{foo}.
11683
11684 To push a variable itself (as opposed to the variable's value) on the
11685 stack, enter its name as an algebraic expression using the apostrophe
11686 (@key{'}) key.
11687
11688 @kindex =
11689 @pindex calc-evaluate
11690 @cindex Evaluation of variables in a formula
11691 @cindex Variables, evaluation
11692 @cindex Formulas, evaluation
11693 The @kbd{=} (@code{calc-evaluate}) key ``evaluates'' a formula by
11694 replacing all variables in the formula which have been given values by a
11695 @code{calc-store} or @code{calc-let} command by their stored values.
11696 Other variables are left alone. Thus a variable that has not been
11697 stored acts like an abstract variable in algebra; a variable that has
11698 been stored acts more like a register in a traditional calculator.
11699 With a positive numeric prefix argument, @kbd{=} evaluates the top
11700 @var{n} stack entries; with a negative argument, @kbd{=} evaluates
11701 the @var{n}th stack entry.
11702
11703 @cindex @code{e} variable
11704 @cindex @code{pi} variable
11705 @cindex @code{i} variable
11706 @cindex @code{phi} variable
11707 @cindex @code{gamma} variable
11708 @vindex e
11709 @vindex pi
11710 @vindex i
11711 @vindex phi
11712 @vindex gamma
11713 A few variables are called @dfn{special constants}. Their names are
11714 @samp{e}, @samp{pi}, @samp{i}, @samp{phi}, and @samp{gamma}.
11715 (@xref{Scientific Functions}.) When they are evaluated with @kbd{=},
11716 their values are calculated if necessary according to the current precision
11717 or complex polar mode. If you wish to use these symbols for other purposes,
11718 simply undefine or redefine them using @code{calc-store}.
11719
11720 The variables @samp{inf}, @samp{uinf}, and @samp{nan} stand for
11721 infinite or indeterminate values. It's best not to use them as
11722 regular variables, since Calc uses special algebraic rules when
11723 it manipulates them. Calc displays a warning message if you store
11724 a value into any of these special variables.
11725
11726 @xref{Store and Recall}, for a discussion of commands dealing with variables.
11727
11728 @node Formulas, , Variables, Data Types
11729 @section Formulas
11730
11731 @noindent
11732 @cindex Formulas
11733 @cindex Expressions
11734 @cindex Operators in formulas
11735 @cindex Precedence of operators
11736 When you press the apostrophe key you may enter any expression or formula
11737 in algebraic form. (Calc uses the terms ``expression'' and ``formula''
11738 interchangeably.) An expression is built up of numbers, variable names,
11739 and function calls, combined with various arithmetic operators.
11740 Parentheses may
11741 be used to indicate grouping. Spaces are ignored within formulas, except
11742 that spaces are not permitted within variable names or numbers.
11743 Arithmetic operators, in order from highest to lowest precedence, and
11744 with their equivalent function names, are:
11745
11746 @samp{_} [@code{subscr}] (subscripts);
11747
11748 postfix @samp{%} [@code{percent}] (as in @samp{25% = 0.25});
11749
11750 prefix @samp{+} and @samp{-} [@code{neg}] (as in @samp{-x})
11751 and prefix @samp{!} [@code{lnot}] (logical ``not,'' as in @samp{!x});
11752
11753 @samp{+/-} [@code{sdev}] (the standard deviation symbol) and
11754 @samp{mod} [@code{makemod}] (the symbol for modulo forms);
11755
11756 postfix @samp{!} [@code{fact}] (factorial, as in @samp{n!})
11757 and postfix @samp{!!} [@code{dfact}] (double factorial);
11758
11759 @samp{^} [@code{pow}] (raised-to-the-power-of);
11760
11761 @samp{*} [@code{mul}];
11762
11763 @samp{/} [@code{div}], @samp{%} [@code{mod}] (modulo), and
11764 @samp{\} [@code{idiv}] (integer division);
11765
11766 infix @samp{+} [@code{add}] and @samp{-} [@code{sub}] (as in @samp{x-y});
11767
11768 @samp{|} [@code{vconcat}] (vector concatenation);
11769
11770 relations @samp{=} [@code{eq}], @samp{!=} [@code{neq}], @samp{<} [@code{lt}],
11771 @samp{>} [@code{gt}], @samp{<=} [@code{leq}], and @samp{>=} [@code{geq}];
11772
11773 @samp{&&} [@code{land}] (logical ``and'');
11774
11775 @samp{||} [@code{lor}] (logical ``or'');
11776
11777 the C-style ``if'' operator @samp{a?b:c} [@code{if}];
11778
11779 @samp{!!!} [@code{pnot}] (rewrite pattern ``not'');
11780
11781 @samp{&&&} [@code{pand}] (rewrite pattern ``and'');
11782
11783 @samp{|||} [@code{por}] (rewrite pattern ``or'');
11784
11785 @samp{:=} [@code{assign}] (for assignments and rewrite rules);
11786
11787 @samp{::} [@code{condition}] (rewrite pattern condition);
11788
11789 @samp{=>} [@code{evalto}].
11790
11791 Note that, unlike in usual computer notation, multiplication binds more
11792 strongly than division: @samp{a*b/c*d} is equivalent to
11793 @texline @math{a b \over c d}.
11794 @infoline @expr{(a*b)/(c*d)}.
11795
11796 @cindex Multiplication, implicit
11797 @cindex Implicit multiplication
11798 The multiplication sign @samp{*} may be omitted in many cases. In particular,
11799 if the righthand side is a number, variable name, or parenthesized
11800 expression, the @samp{*} may be omitted. Implicit multiplication has the
11801 same precedence as the explicit @samp{*} operator. The one exception to
11802 the rule is that a variable name followed by a parenthesized expression,
11803 as in @samp{f(x)},
11804 is interpreted as a function call, not an implicit @samp{*}. In many
11805 cases you must use a space if you omit the @samp{*}: @samp{2a} is the
11806 same as @samp{2*a}, and @samp{a b} is the same as @samp{a*b}, but @samp{ab}
11807 is a variable called @code{ab}, @emph{not} the product of @samp{a} and
11808 @samp{b}! Also note that @samp{f (x)} is still a function call.
11809
11810 @cindex Implicit comma in vectors
11811 The rules are slightly different for vectors written with square brackets.
11812 In vectors, the space character is interpreted (like the comma) as a
11813 separator of elements of the vector. Thus @w{@samp{[ 2a b+c d ]}} is
11814 equivalent to @samp{[2*a, b+c, d]}, whereas @samp{2a b+c d} is equivalent
11815 to @samp{2*a*b + c*d}.
11816 Note that spaces around the brackets, and around explicit commas, are
11817 ignored. To force spaces to be interpreted as multiplication you can
11818 enclose a formula in parentheses as in @samp{[(a b) 2(c d)]}, which is
11819 interpreted as @samp{[a*b, 2*c*d]}. An implicit comma is also inserted
11820 between @samp{][}, as in the matrix @samp{[[1 2][3 4]]}.
11821
11822 Vectors that contain commas (not embedded within nested parentheses or
11823 brackets) do not treat spaces specially: @samp{[a b, 2 c d]} is a vector
11824 of two elements. Also, if it would be an error to treat spaces as
11825 separators, but not otherwise, then Calc will ignore spaces:
11826 @w{@samp{[a - b]}} is a vector of one element, but @w{@samp{[a -b]}} is
11827 a vector of two elements. Finally, vectors entered with curly braces
11828 instead of square brackets do not give spaces any special treatment.
11829 When Calc displays a vector that does not contain any commas, it will
11830 insert parentheses if necessary to make the meaning clear:
11831 @w{@samp{[(a b)]}}.
11832
11833 The expression @samp{5%-2} is ambiguous; is this five-percent minus two,
11834 or five modulo minus-two? Calc always interprets the leftmost symbol as
11835 an infix operator preferentially (modulo, in this case), so you would
11836 need to write @samp{(5%)-2} to get the former interpretation.
11837
11838 @cindex Function call notation
11839 A function call is, e.g., @samp{sin(1+x)}. (The Calc algebraic function
11840 @code{foo} corresponds to the Emacs Lisp function @code{calcFunc-foo},
11841 but unless you access the function from within Emacs Lisp, you don't
11842 need to worry about it.) Most mathematical Calculator commands like
11843 @code{calc-sin} have function equivalents like @code{sin}.
11844 If no Lisp function is defined for a function called by a formula, the
11845 call is left as it is during algebraic manipulation: @samp{f(x+y)} is
11846 left alone. Beware that many innocent-looking short names like @code{in}
11847 and @code{re} have predefined meanings which could surprise you; however,
11848 single letters or single letters followed by digits are always safe to
11849 use for your own function names. @xref{Function Index}.
11850
11851 In the documentation for particular commands, the notation @kbd{H S}
11852 (@code{calc-sinh}) [@code{sinh}] means that the key sequence @kbd{H S}, the
11853 command @kbd{M-x calc-sinh}, and the algebraic function @code{sinh(x)} all
11854 represent the same operation.
11855
11856 Commands that interpret (``parse'') text as algebraic formulas include
11857 algebraic entry (@kbd{'}), editing commands like @kbd{`} which parse
11858 the contents of the editing buffer when you finish, the @kbd{M-# g}
11859 and @w{@kbd{M-# r}} commands, the @kbd{C-y} command, the X window system
11860 ``paste'' mouse operation, and Embedded mode. All of these operations
11861 use the same rules for parsing formulas; in particular, language modes
11862 (@pxref{Language Modes}) affect them all in the same way.
11863
11864 When you read a large amount of text into the Calculator (say a vector
11865 which represents a big set of rewrite rules; @pxref{Rewrite Rules}),
11866 you may wish to include comments in the text. Calc's formula parser
11867 ignores the symbol @samp{%%} and anything following it on a line:
11868
11869 @example
11870 [ a + b, %% the sum of "a" and "b"
11871 c + d,
11872 %% last line is coming up:
11873 e + f ]
11874 @end example
11875
11876 @noindent
11877 This is parsed exactly the same as @samp{[ a + b, c + d, e + f ]}.
11878
11879 @xref{Syntax Tables}, for a way to create your own operators and other
11880 input notations. @xref{Compositions}, for a way to create new display
11881 formats.
11882
11883 @xref{Algebra}, for commands for manipulating formulas symbolically.
11884
11885 @node Stack and Trail, Mode Settings, Data Types, Top
11886 @chapter Stack and Trail Commands
11887
11888 @noindent
11889 This chapter describes the Calc commands for manipulating objects on the
11890 stack and in the trail buffer. (These commands operate on objects of any
11891 type, such as numbers, vectors, formulas, and incomplete objects.)
11892
11893 @menu
11894 * Stack Manipulation::
11895 * Editing Stack Entries::
11896 * Trail Commands::
11897 * Keep Arguments::
11898 @end menu
11899
11900 @node Stack Manipulation, Editing Stack Entries, Stack and Trail, Stack and Trail
11901 @section Stack Manipulation Commands
11902
11903 @noindent
11904 @kindex @key{RET}
11905 @kindex @key{SPC}
11906 @pindex calc-enter
11907 @cindex Duplicating stack entries
11908 To duplicate the top object on the stack, press @key{RET} or @key{SPC}
11909 (two equivalent keys for the @code{calc-enter} command).
11910 Given a positive numeric prefix argument, these commands duplicate
11911 several elements at the top of the stack.
11912 Given a negative argument,
11913 these commands duplicate the specified element of the stack.
11914 Given an argument of zero, they duplicate the entire stack.
11915 For example, with @samp{10 20 30} on the stack,
11916 @key{RET} creates @samp{10 20 30 30},
11917 @kbd{C-u 2 @key{RET}} creates @samp{10 20 30 20 30},
11918 @kbd{C-u - 2 @key{RET}} creates @samp{10 20 30 20}, and
11919 @kbd{C-u 0 @key{RET}} creates @samp{10 20 30 10 20 30}.
11920
11921 @kindex @key{LFD}
11922 @pindex calc-over
11923 The @key{LFD} (@code{calc-over}) command (on a key marked Line-Feed if you
11924 have it, else on @kbd{C-j}) is like @code{calc-enter}
11925 except that the sign of the numeric prefix argument is interpreted
11926 oppositely. Also, with no prefix argument the default argument is 2.
11927 Thus with @samp{10 20 30} on the stack, @key{LFD} and @kbd{C-u 2 @key{LFD}}
11928 are both equivalent to @kbd{C-u - 2 @key{RET}}, producing
11929 @samp{10 20 30 20}.
11930
11931 @kindex @key{DEL}
11932 @kindex C-d
11933 @pindex calc-pop
11934 @cindex Removing stack entries
11935 @cindex Deleting stack entries
11936 To remove the top element from the stack, press @key{DEL} (@code{calc-pop}).
11937 The @kbd{C-d} key is a synonym for @key{DEL}.
11938 (If the top element is an incomplete object with at least one element, the
11939 last element is removed from it.) Given a positive numeric prefix argument,
11940 several elements are removed. Given a negative argument, the specified
11941 element of the stack is deleted. Given an argument of zero, the entire
11942 stack is emptied.
11943 For example, with @samp{10 20 30} on the stack,
11944 @key{DEL} leaves @samp{10 20},
11945 @kbd{C-u 2 @key{DEL}} leaves @samp{10},
11946 @kbd{C-u - 2 @key{DEL}} leaves @samp{10 30}, and
11947 @kbd{C-u 0 @key{DEL}} leaves an empty stack.
11948
11949 @kindex M-@key{DEL}
11950 @pindex calc-pop-above
11951 The @kbd{M-@key{DEL}} (@code{calc-pop-above}) command is to @key{DEL} what
11952 @key{LFD} is to @key{RET}: It interprets the sign of the numeric
11953 prefix argument in the opposite way, and the default argument is 2.
11954 Thus @kbd{M-@key{DEL}} by itself removes the second-from-top stack element,
11955 leaving the first, third, fourth, and so on; @kbd{M-3 M-@key{DEL}} deletes
11956 the third stack element.
11957
11958 @kindex @key{TAB}
11959 @pindex calc-roll-down
11960 To exchange the top two elements of the stack, press @key{TAB}
11961 (@code{calc-roll-down}). Given a positive numeric prefix argument, the
11962 specified number of elements at the top of the stack are rotated downward.
11963 Given a negative argument, the entire stack is rotated downward the specified
11964 number of times. Given an argument of zero, the entire stack is reversed
11965 top-for-bottom.
11966 For example, with @samp{10 20 30 40 50} on the stack,
11967 @key{TAB} creates @samp{10 20 30 50 40},
11968 @kbd{C-u 3 @key{TAB}} creates @samp{10 20 50 30 40},
11969 @kbd{C-u - 2 @key{TAB}} creates @samp{40 50 10 20 30}, and
11970 @kbd{C-u 0 @key{TAB}} creates @samp{50 40 30 20 10}.
11971
11972 @kindex M-@key{TAB}
11973 @pindex calc-roll-up
11974 The command @kbd{M-@key{TAB}} (@code{calc-roll-up}) is analogous to @key{TAB}
11975 except that it rotates upward instead of downward. Also, the default
11976 with no prefix argument is to rotate the top 3 elements.
11977 For example, with @samp{10 20 30 40 50} on the stack,
11978 @kbd{M-@key{TAB}} creates @samp{10 20 40 50 30},
11979 @kbd{C-u 4 M-@key{TAB}} creates @samp{10 30 40 50 20},
11980 @kbd{C-u - 2 M-@key{TAB}} creates @samp{30 40 50 10 20}, and
11981 @kbd{C-u 0 M-@key{TAB}} creates @samp{50 40 30 20 10}.
11982
11983 A good way to view the operation of @key{TAB} and @kbd{M-@key{TAB}} is in
11984 terms of moving a particular element to a new position in the stack.
11985 With a positive argument @var{n}, @key{TAB} moves the top stack
11986 element down to level @var{n}, making room for it by pulling all the
11987 intervening stack elements toward the top. @kbd{M-@key{TAB}} moves the
11988 element at level @var{n} up to the top. (Compare with @key{LFD},
11989 which copies instead of moving the element in level @var{n}.)
11990
11991 With a negative argument @mathit{-@var{n}}, @key{TAB} rotates the stack
11992 to move the object in level @var{n} to the deepest place in the
11993 stack, and the object in level @mathit{@var{n}+1} to the top. @kbd{M-@key{TAB}}
11994 rotates the deepest stack element to be in level @mathit{n}, also
11995 putting the top stack element in level @mathit{@var{n}+1}.
11996
11997 @xref{Selecting Subformulas}, for a way to apply these commands to
11998 any portion of a vector or formula on the stack.
11999
12000 @node Editing Stack Entries, Trail Commands, Stack Manipulation, Stack and Trail
12001 @section Editing Stack Entries
12002
12003 @noindent
12004 @kindex `
12005 @pindex calc-edit
12006 @pindex calc-edit-finish
12007 @cindex Editing the stack with Emacs
12008 The backquote, @kbd{`} (@code{calc-edit}) command creates a temporary
12009 buffer (@samp{*Calc Edit*}) for editing the top-of-stack value using
12010 regular Emacs commands. With a numeric prefix argument, it edits the
12011 specified number of stack entries at once. (An argument of zero edits
12012 the entire stack; a negative argument edits one specific stack entry.)
12013
12014 When you are done editing, press @kbd{C-c C-c} to finish and return
12015 to Calc. The @key{RET} and @key{LFD} keys also work to finish most
12016 sorts of editing, though in some cases Calc leaves @key{RET} with its
12017 usual meaning (``insert a newline'') if it's a situation where you
12018 might want to insert new lines into the editing buffer.
12019
12020 When you finish editing, the Calculator parses the lines of text in
12021 the @samp{*Calc Edit*} buffer as numbers or formulas, replaces the
12022 original stack elements in the original buffer with these new values,
12023 then kills the @samp{*Calc Edit*} buffer. The original Calculator buffer
12024 continues to exist during editing, but for best results you should be
12025 careful not to change it until you have finished the edit. You can
12026 also cancel the edit by killing the buffer with @kbd{C-x k}.
12027
12028 The formula is normally reevaluated as it is put onto the stack.
12029 For example, editing @samp{a + 2} to @samp{3 + 2} and pressing
12030 @kbd{C-c C-c} will push 5 on the stack. If you use @key{LFD} to
12031 finish, Calc will put the result on the stack without evaluating it.
12032
12033 If you give a prefix argument to @kbd{C-c C-c},
12034 Calc will not kill the @samp{*Calc Edit*} buffer. You can switch
12035 back to that buffer and continue editing if you wish. However, you
12036 should understand that if you initiated the edit with @kbd{`}, the
12037 @kbd{C-c C-c} operation will be programmed to replace the top of the
12038 stack with the new edited value, and it will do this even if you have
12039 rearranged the stack in the meanwhile. This is not so much of a problem
12040 with other editing commands, though, such as @kbd{s e}
12041 (@code{calc-edit-variable}; @pxref{Operations on Variables}).
12042
12043 If the @code{calc-edit} command involves more than one stack entry,
12044 each line of the @samp{*Calc Edit*} buffer is interpreted as a
12045 separate formula. Otherwise, the entire buffer is interpreted as
12046 one formula, with line breaks ignored. (You can use @kbd{C-o} or
12047 @kbd{C-q C-j} to insert a newline in the buffer without pressing @key{RET}.)
12048
12049 The @kbd{`} key also works during numeric or algebraic entry. The
12050 text entered so far is moved to the @code{*Calc Edit*} buffer for
12051 more extensive editing than is convenient in the minibuffer.
12052
12053 @node Trail Commands, Keep Arguments, Editing Stack Entries, Stack and Trail
12054 @section Trail Commands
12055
12056 @noindent
12057 @cindex Trail buffer
12058 The commands for manipulating the Calc Trail buffer are two-key sequences
12059 beginning with the @kbd{t} prefix.
12060
12061 @kindex t d
12062 @pindex calc-trail-display
12063 The @kbd{t d} (@code{calc-trail-display}) command turns display of the
12064 trail on and off. Normally the trail display is toggled on if it was off,
12065 off if it was on. With a numeric prefix of zero, this command always
12066 turns the trail off; with a prefix of one, it always turns the trail on.
12067 The other trail-manipulation commands described here automatically turn
12068 the trail on. Note that when the trail is off values are still recorded
12069 there; they are simply not displayed. To set Emacs to turn the trail
12070 off by default, type @kbd{t d} and then save the mode settings with
12071 @kbd{m m} (@code{calc-save-modes}).
12072
12073 @kindex t i
12074 @pindex calc-trail-in
12075 @kindex t o
12076 @pindex calc-trail-out
12077 The @kbd{t i} (@code{calc-trail-in}) and @kbd{t o}
12078 (@code{calc-trail-out}) commands switch the cursor into and out of the
12079 Calc Trail window. In practice they are rarely used, since the commands
12080 shown below are a more convenient way to move around in the
12081 trail, and they work ``by remote control'' when the cursor is still
12082 in the Calculator window.
12083
12084 @cindex Trail pointer
12085 There is a @dfn{trail pointer} which selects some entry of the trail at
12086 any given time. The trail pointer looks like a @samp{>} symbol right
12087 before the selected number. The following commands operate on the
12088 trail pointer in various ways.
12089
12090 @kindex t y
12091 @pindex calc-trail-yank
12092 @cindex Retrieving previous results
12093 The @kbd{t y} (@code{calc-trail-yank}) command reads the selected value in
12094 the trail and pushes it onto the Calculator stack. It allows you to
12095 re-use any previously computed value without retyping. With a numeric
12096 prefix argument @var{n}, it yanks the value @var{n} lines above the current
12097 trail pointer.
12098
12099 @kindex t <
12100 @pindex calc-trail-scroll-left
12101 @kindex t >
12102 @pindex calc-trail-scroll-right
12103 The @kbd{t <} (@code{calc-trail-scroll-left}) and @kbd{t >}
12104 (@code{calc-trail-scroll-right}) commands horizontally scroll the trail
12105 window left or right by one half of its width.
12106
12107 @kindex t n
12108 @pindex calc-trail-next
12109 @kindex t p
12110 @pindex calc-trail-previous
12111 @kindex t f
12112 @pindex calc-trail-forward
12113 @kindex t b
12114 @pindex calc-trail-backward
12115 The @kbd{t n} (@code{calc-trail-next}) and @kbd{t p}
12116 (@code{calc-trail-previous)} commands move the trail pointer down or up
12117 one line. The @kbd{t f} (@code{calc-trail-forward}) and @kbd{t b}
12118 (@code{calc-trail-backward}) commands move the trail pointer down or up
12119 one screenful at a time. All of these commands accept numeric prefix
12120 arguments to move several lines or screenfuls at a time.
12121
12122 @kindex t [
12123 @pindex calc-trail-first
12124 @kindex t ]
12125 @pindex calc-trail-last
12126 @kindex t h
12127 @pindex calc-trail-here
12128 The @kbd{t [} (@code{calc-trail-first}) and @kbd{t ]}
12129 (@code{calc-trail-last}) commands move the trail pointer to the first or
12130 last line of the trail. The @kbd{t h} (@code{calc-trail-here}) command
12131 moves the trail pointer to the cursor position; unlike the other trail
12132 commands, @kbd{t h} works only when Calc Trail is the selected window.
12133
12134 @kindex t s
12135 @pindex calc-trail-isearch-forward
12136 @kindex t r
12137 @pindex calc-trail-isearch-backward
12138 @ifinfo
12139 The @kbd{t s} (@code{calc-trail-isearch-forward}) and @kbd{t r}
12140 (@code{calc-trail-isearch-backward}) commands perform an incremental
12141 search forward or backward through the trail. You can press @key{RET}
12142 to terminate the search; the trail pointer moves to the current line.
12143 If you cancel the search with @kbd{C-g}, the trail pointer stays where
12144 it was when the search began.
12145 @end ifinfo
12146 @tex
12147 The @kbd{t s} (@code{calc-trail-isearch-forward}) and @kbd{t r}
12148 (@code{calc-trail-isearch-backward}) com\-mands perform an incremental
12149 search forward or backward through the trail. You can press @key{RET}
12150 to terminate the search; the trail pointer moves to the current line.
12151 If you cancel the search with @kbd{C-g}, the trail pointer stays where
12152 it was when the search began.
12153 @end tex
12154
12155 @kindex t m
12156 @pindex calc-trail-marker
12157 The @kbd{t m} (@code{calc-trail-marker}) command allows you to enter a
12158 line of text of your own choosing into the trail. The text is inserted
12159 after the line containing the trail pointer; this usually means it is
12160 added to the end of the trail. Trail markers are useful mainly as the
12161 targets for later incremental searches in the trail.
12162
12163 @kindex t k
12164 @pindex calc-trail-kill
12165 The @kbd{t k} (@code{calc-trail-kill}) command removes the selected line
12166 from the trail. The line is saved in the Emacs kill ring suitable for
12167 yanking into another buffer, but it is not easy to yank the text back
12168 into the trail buffer. With a numeric prefix argument, this command
12169 kills the @var{n} lines below or above the selected one.
12170
12171 The @kbd{t .} (@code{calc-full-trail-vectors}) command is described
12172 elsewhere; @pxref{Vector and Matrix Formats}.
12173
12174 @node Keep Arguments, , Trail Commands, Stack and Trail
12175 @section Keep Arguments
12176
12177 @noindent
12178 @kindex K
12179 @pindex calc-keep-args
12180 The @kbd{K} (@code{calc-keep-args}) command acts like a prefix for
12181 the following command. It prevents that command from removing its
12182 arguments from the stack. For example, after @kbd{2 @key{RET} 3 +},
12183 the stack contains the sole number 5, but after @kbd{2 @key{RET} 3 K +},
12184 the stack contains the arguments and the result: @samp{2 3 5}.
12185
12186 With the exception of keyboard macros, this works for all commands that
12187 take arguments off the stack. (To avoid potentially unpleasant behavior,
12188 a @kbd{K} prefix before a keyboard macro will be ignored. A @kbd{K}
12189 prefix called @emph{within} the keyboard macro will still take effect.)
12190 As another example, @kbd{K a s} simplifies a formula, pushing the
12191 simplified version of the formula onto the stack after the original
12192 formula (rather than replacing the original formula). Note that you
12193 could get the same effect by typing @kbd{@key{RET} a s}, copying the
12194 formula and then simplifying the copy. One difference is that for a very
12195 large formula the time taken to format the intermediate copy in
12196 @kbd{@key{RET} a s} could be noticeable; @kbd{K a s} would avoid this
12197 extra work.
12198
12199 Even stack manipulation commands are affected. @key{TAB} works by
12200 popping two values and pushing them back in the opposite order,
12201 so @kbd{2 @key{RET} 3 K @key{TAB}} produces @samp{2 3 3 2}.
12202
12203 A few Calc commands provide other ways of doing the same thing.
12204 For example, @kbd{' sin($)} replaces the number on the stack with
12205 its sine using algebraic entry; to push the sine and keep the
12206 original argument you could use either @kbd{' sin($1)} or
12207 @kbd{K ' sin($)}. @xref{Algebraic Entry}. Also, the @kbd{s s}
12208 command is effectively the same as @kbd{K s t}. @xref{Storing Variables}.
12209
12210 If you execute a command and then decide you really wanted to keep
12211 the argument, you can press @kbd{M-@key{RET}} (@code{calc-last-args}).
12212 This command pushes the last arguments that were popped by any command
12213 onto the stack. Note that the order of things on the stack will be
12214 different than with @kbd{K}: @kbd{2 @key{RET} 3 + M-@key{RET}} leaves
12215 @samp{5 2 3} on the stack instead of @samp{2 3 5}. @xref{Undo}.
12216
12217 @node Mode Settings, Arithmetic, Stack and Trail, Top
12218 @chapter Mode Settings
12219
12220 @noindent
12221 This chapter describes commands that set modes in the Calculator.
12222 They do not affect the contents of the stack, although they may change
12223 the @emph{appearance} or @emph{interpretation} of the stack's contents.
12224
12225 @menu
12226 * General Mode Commands::
12227 * Precision::
12228 * Inverse and Hyperbolic::
12229 * Calculation Modes::
12230 * Simplification Modes::
12231 * Declarations::
12232 * Display Modes::
12233 * Language Modes::
12234 * Modes Variable::
12235 * Calc Mode Line::
12236 @end menu
12237
12238 @node General Mode Commands, Precision, Mode Settings, Mode Settings
12239 @section General Mode Commands
12240
12241 @noindent
12242 @kindex m m
12243 @pindex calc-save-modes
12244 @cindex Continuous memory
12245 @cindex Saving mode settings
12246 @cindex Permanent mode settings
12247 @cindex Calc init file, mode settings
12248 You can save all of the current mode settings in your Calc init file
12249 (the file given by the variable @code{calc-settings-file}, typically
12250 @file{~/.calc.el}) with the @kbd{m m} (@code{calc-save-modes}) command.
12251 This will cause Emacs to reestablish these modes each time it starts up.
12252 The modes saved in the file include everything controlled by the @kbd{m}
12253 and @kbd{d} prefix keys, the current precision and binary word size,
12254 whether or not the trail is displayed, the current height of the Calc
12255 window, and more. The current interface (used when you type @kbd{M-#
12256 M-#}) is also saved. If there were already saved mode settings in the
12257 file, they are replaced. Otherwise, the new mode information is
12258 appended to the end of the file.
12259
12260 @kindex m R
12261 @pindex calc-mode-record-mode
12262 The @kbd{m R} (@code{calc-mode-record-mode}) command tells Calc to
12263 record all the mode settings (as if by pressing @kbd{m m}) every
12264 time a mode setting changes. If the modes are saved this way, then this
12265 ``automatic mode recording'' mode is also saved.
12266 Type @kbd{m R} again to disable this method of recording the mode
12267 settings. To turn it off permanently, the @kbd{m m} command will also be
12268 necessary. (If Embedded mode is enabled, other options for recording
12269 the modes are available; @pxref{Mode Settings in Embedded Mode}.)
12270
12271 @kindex m F
12272 @pindex calc-settings-file-name
12273 The @kbd{m F} (@code{calc-settings-file-name}) command allows you to
12274 choose a different file than the current value of @code{calc-settings-file}
12275 for @kbd{m m}, @kbd{Z P}, and similar commands to save permanent information.
12276 You are prompted for a file name. All Calc modes are then reset to
12277 their default values, then settings from the file you named are loaded
12278 if this file exists, and this file becomes the one that Calc will
12279 use in the future for commands like @kbd{m m}. The default settings
12280 file name is @file{~/.calc.el}. You can see the current file name by
12281 giving a blank response to the @kbd{m F} prompt. See also the
12282 discussion of the @code{calc-settings-file} variable; @pxref{Installation}.
12283
12284 If the file name you give is your user init file (typically
12285 @file{~/.emacs}), @kbd{m F} will not automatically load the new file. This
12286 is because your user init file may contain other things you don't want
12287 to reread. You can give
12288 a numeric prefix argument of 1 to @kbd{m F} to force it to read the
12289 file no matter what. Conversely, an argument of @mathit{-1} tells
12290 @kbd{m F} @emph{not} to read the new file. An argument of 2 or @mathit{-2}
12291 tells @kbd{m F} not to reset the modes to their defaults beforehand,
12292 which is useful if you intend your new file to have a variant of the
12293 modes present in the file you were using before.
12294
12295 @kindex m x
12296 @pindex calc-always-load-extensions
12297 The @kbd{m x} (@code{calc-always-load-extensions}) command enables a mode
12298 in which the first use of Calc loads the entire program, including all
12299 extensions modules. Otherwise, the extensions modules will not be loaded
12300 until the various advanced Calc features are used. Since this mode only
12301 has effect when Calc is first loaded, @kbd{m x} is usually followed by
12302 @kbd{m m} to make the mode-setting permanent. To load all of Calc just
12303 once, rather than always in the future, you can press @kbd{M-# L}.
12304
12305 @kindex m S
12306 @pindex calc-shift-prefix
12307 The @kbd{m S} (@code{calc-shift-prefix}) command enables a mode in which
12308 all of Calc's letter prefix keys may be typed shifted as well as unshifted.
12309 If you are typing, say, @kbd{a S} (@code{calc-solve-for}) quite often
12310 you might find it easier to turn this mode on so that you can type
12311 @kbd{A S} instead. When this mode is enabled, the commands that used to
12312 be on those single shifted letters (e.g., @kbd{A} (@code{calc-abs})) can
12313 now be invoked by pressing the shifted letter twice: @kbd{A A}. Note
12314 that the @kbd{v} prefix key always works both shifted and unshifted, and
12315 the @kbd{z} and @kbd{Z} prefix keys are always distinct. Also, the @kbd{h}
12316 prefix is not affected by this mode. Press @kbd{m S} again to disable
12317 shifted-prefix mode.
12318
12319 @node Precision, Inverse and Hyperbolic, General Mode Commands, Mode Settings
12320 @section Precision
12321
12322 @noindent
12323 @kindex p
12324 @pindex calc-precision
12325 @cindex Precision of calculations
12326 The @kbd{p} (@code{calc-precision}) command controls the precision to
12327 which floating-point calculations are carried. The precision must be
12328 at least 3 digits and may be arbitrarily high, within the limits of
12329 memory and time. This affects only floats: Integer and rational
12330 calculations are always carried out with as many digits as necessary.
12331
12332 The @kbd{p} key prompts for the current precision. If you wish you
12333 can instead give the precision as a numeric prefix argument.
12334
12335 Many internal calculations are carried to one or two digits higher
12336 precision than normal. Results are rounded down afterward to the
12337 current precision. Unless a special display mode has been selected,
12338 floats are always displayed with their full stored precision, i.e.,
12339 what you see is what you get. Reducing the current precision does not
12340 round values already on the stack, but those values will be rounded
12341 down before being used in any calculation. The @kbd{c 0} through
12342 @kbd{c 9} commands (@pxref{Conversions}) can be used to round an
12343 existing value to a new precision.
12344
12345 @cindex Accuracy of calculations
12346 It is important to distinguish the concepts of @dfn{precision} and
12347 @dfn{accuracy}. In the normal usage of these words, the number
12348 123.4567 has a precision of 7 digits but an accuracy of 4 digits.
12349 The precision is the total number of digits not counting leading
12350 or trailing zeros (regardless of the position of the decimal point).
12351 The accuracy is simply the number of digits after the decimal point
12352 (again not counting trailing zeros). In Calc you control the precision,
12353 not the accuracy of computations. If you were to set the accuracy
12354 instead, then calculations like @samp{exp(100)} would generate many
12355 more digits than you would typically need, while @samp{exp(-100)} would
12356 probably round to zero! In Calc, both these computations give you
12357 exactly 12 (or the requested number of) significant digits.
12358
12359 The only Calc features that deal with accuracy instead of precision
12360 are fixed-point display mode for floats (@kbd{d f}; @pxref{Float Formats}),
12361 and the rounding functions like @code{floor} and @code{round}
12362 (@pxref{Integer Truncation}). Also, @kbd{c 0} through @kbd{c 9}
12363 deal with both precision and accuracy depending on the magnitudes
12364 of the numbers involved.
12365
12366 If you need to work with a particular fixed accuracy (say, dollars and
12367 cents with two digits after the decimal point), one solution is to work
12368 with integers and an ``implied'' decimal point. For example, $8.99
12369 divided by 6 would be entered @kbd{899 @key{RET} 6 /}, yielding 149.833
12370 (actually $1.49833 with our implied decimal point); pressing @kbd{R}
12371 would round this to 150 cents, i.e., $1.50.
12372
12373 @xref{Floats}, for still more on floating-point precision and related
12374 issues.
12375
12376 @node Inverse and Hyperbolic, Calculation Modes, Precision, Mode Settings
12377 @section Inverse and Hyperbolic Flags
12378
12379 @noindent
12380 @kindex I
12381 @pindex calc-inverse
12382 There is no single-key equivalent to the @code{calc-arcsin} function.
12383 Instead, you must first press @kbd{I} (@code{calc-inverse}) to set
12384 the @dfn{Inverse Flag}, then press @kbd{S} (@code{calc-sin}).
12385 The @kbd{I} key actually toggles the Inverse Flag. When this flag
12386 is set, the word @samp{Inv} appears in the mode line.
12387
12388 @kindex H
12389 @pindex calc-hyperbolic
12390 Likewise, the @kbd{H} key (@code{calc-hyperbolic}) sets or clears the
12391 Hyperbolic Flag, which transforms @code{calc-sin} into @code{calc-sinh}.
12392 If both of these flags are set at once, the effect will be
12393 @code{calc-arcsinh}. (The Hyperbolic flag is also used by some
12394 non-trigonometric commands; for example @kbd{H L} computes a base-10,
12395 instead of base-@mathit{e}, logarithm.)
12396
12397 Command names like @code{calc-arcsin} are provided for completeness, and
12398 may be executed with @kbd{x} or @kbd{M-x}. Their effect is simply to
12399 toggle the Inverse and/or Hyperbolic flags and then execute the
12400 corresponding base command (@code{calc-sin} in this case).
12401
12402 The Inverse and Hyperbolic flags apply only to the next Calculator
12403 command, after which they are automatically cleared. (They are also
12404 cleared if the next keystroke is not a Calc command.) Digits you
12405 type after @kbd{I} or @kbd{H} (or @kbd{K}) are treated as prefix
12406 arguments for the next command, not as numeric entries. The same
12407 is true of @kbd{C-u}, but not of the minus sign (@kbd{K -} means to
12408 subtract and keep arguments).
12409
12410 The third Calc prefix flag, @kbd{K} (keep-arguments), is discussed
12411 elsewhere. @xref{Keep Arguments}.
12412
12413 @node Calculation Modes, Simplification Modes, Inverse and Hyperbolic, Mode Settings
12414 @section Calculation Modes
12415
12416 @noindent
12417 The commands in this section are two-key sequences beginning with
12418 the @kbd{m} prefix. (That's the letter @kbd{m}, not the @key{META} key.)
12419 The @samp{m a} (@code{calc-algebraic-mode}) command is described elsewhere
12420 (@pxref{Algebraic Entry}).
12421
12422 @menu
12423 * Angular Modes::
12424 * Polar Mode::
12425 * Fraction Mode::
12426 * Infinite Mode::
12427 * Symbolic Mode::
12428 * Matrix Mode::
12429 * Automatic Recomputation::
12430 * Working Message::
12431 @end menu
12432
12433 @node Angular Modes, Polar Mode, Calculation Modes, Calculation Modes
12434 @subsection Angular Modes
12435
12436 @noindent
12437 @cindex Angular mode
12438 The Calculator supports three notations for angles: radians, degrees,
12439 and degrees-minutes-seconds. When a number is presented to a function
12440 like @code{sin} that requires an angle, the current angular mode is
12441 used to interpret the number as either radians or degrees. If an HMS
12442 form is presented to @code{sin}, it is always interpreted as
12443 degrees-minutes-seconds.
12444
12445 Functions that compute angles produce a number in radians, a number in
12446 degrees, or an HMS form depending on the current angular mode. If the
12447 result is a complex number and the current mode is HMS, the number is
12448 instead expressed in degrees. (Complex-number calculations would
12449 normally be done in Radians mode, though. Complex numbers are converted
12450 to degrees by calculating the complex result in radians and then
12451 multiplying by 180 over @cpi{}.)
12452
12453 @kindex m r
12454 @pindex calc-radians-mode
12455 @kindex m d
12456 @pindex calc-degrees-mode
12457 @kindex m h
12458 @pindex calc-hms-mode
12459 The @kbd{m r} (@code{calc-radians-mode}), @kbd{m d} (@code{calc-degrees-mode}),
12460 and @kbd{m h} (@code{calc-hms-mode}) commands control the angular mode.
12461 The current angular mode is displayed on the Emacs mode line.
12462 The default angular mode is Degrees.
12463
12464 @node Polar Mode, Fraction Mode, Angular Modes, Calculation Modes
12465 @subsection Polar Mode
12466
12467 @noindent
12468 @cindex Polar mode
12469 The Calculator normally ``prefers'' rectangular complex numbers in the
12470 sense that rectangular form is used when the proper form can not be
12471 decided from the input. This might happen by multiplying a rectangular
12472 number by a polar one, by taking the square root of a negative real
12473 number, or by entering @kbd{( 2 @key{SPC} 3 )}.
12474
12475 @kindex m p
12476 @pindex calc-polar-mode
12477 The @kbd{m p} (@code{calc-polar-mode}) command toggles complex-number
12478 preference between rectangular and polar forms. In Polar mode, all
12479 of the above example situations would produce polar complex numbers.
12480
12481 @node Fraction Mode, Infinite Mode, Polar Mode, Calculation Modes
12482 @subsection Fraction Mode
12483
12484 @noindent
12485 @cindex Fraction mode
12486 @cindex Division of integers
12487 Division of two integers normally yields a floating-point number if the
12488 result cannot be expressed as an integer. In some cases you would
12489 rather get an exact fractional answer. One way to accomplish this is
12490 to multiply fractions instead: @kbd{6 @key{RET} 1:4 *} produces @expr{3:2}
12491 even though @kbd{6 @key{RET} 4 /} produces @expr{1.5}.
12492
12493 @kindex m f
12494 @pindex calc-frac-mode
12495 To set the Calculator to produce fractional results for normal integer
12496 divisions, use the @kbd{m f} (@code{calc-frac-mode}) command.
12497 For example, @expr{8/4} produces @expr{2} in either mode,
12498 but @expr{6/4} produces @expr{3:2} in Fraction mode, @expr{1.5} in
12499 Float mode.
12500
12501 At any time you can use @kbd{c f} (@code{calc-float}) to convert a
12502 fraction to a float, or @kbd{c F} (@code{calc-fraction}) to convert a
12503 float to a fraction. @xref{Conversions}.
12504
12505 @node Infinite Mode, Symbolic Mode, Fraction Mode, Calculation Modes
12506 @subsection Infinite Mode
12507
12508 @noindent
12509 @cindex Infinite mode
12510 The Calculator normally treats results like @expr{1 / 0} as errors;
12511 formulas like this are left in unsimplified form. But Calc can be
12512 put into a mode where such calculations instead produce ``infinite''
12513 results.
12514
12515 @kindex m i
12516 @pindex calc-infinite-mode
12517 The @kbd{m i} (@code{calc-infinite-mode}) command turns this mode
12518 on and off. When the mode is off, infinities do not arise except
12519 in calculations that already had infinities as inputs. (One exception
12520 is that infinite open intervals like @samp{[0 .. inf)} can be
12521 generated; however, intervals closed at infinity (@samp{[0 .. inf]})
12522 will not be generated when Infinite mode is off.)
12523
12524 With Infinite mode turned on, @samp{1 / 0} will generate @code{uinf},
12525 an undirected infinity. @xref{Infinities}, for a discussion of the
12526 difference between @code{inf} and @code{uinf}. Also, @expr{0 / 0}
12527 evaluates to @code{nan}, the ``indeterminate'' symbol. Various other
12528 functions can also return infinities in this mode; for example,
12529 @samp{ln(0) = -inf}, and @samp{gamma(-7) = uinf}. Once again,
12530 note that @samp{exp(inf) = inf} regardless of Infinite mode because
12531 this calculation has infinity as an input.
12532
12533 @cindex Positive Infinite mode
12534 The @kbd{m i} command with a numeric prefix argument of zero,
12535 i.e., @kbd{C-u 0 m i}, turns on a Positive Infinite mode in
12536 which zero is treated as positive instead of being directionless.
12537 Thus, @samp{1 / 0 = inf} and @samp{-1 / 0 = -inf} in this mode.
12538 Note that zero never actually has a sign in Calc; there are no
12539 separate representations for @mathit{+0} and @mathit{-0}. Positive
12540 Infinite mode merely changes the interpretation given to the
12541 single symbol, @samp{0}. One consequence of this is that, while
12542 you might expect @samp{1 / -0 = -inf}, actually @samp{1 / -0}
12543 is equivalent to @samp{1 / 0}, which is equal to positive @code{inf}.
12544
12545 @node Symbolic Mode, Matrix Mode, Infinite Mode, Calculation Modes
12546 @subsection Symbolic Mode
12547
12548 @noindent
12549 @cindex Symbolic mode
12550 @cindex Inexact results
12551 Calculations are normally performed numerically wherever possible.
12552 For example, the @code{calc-sqrt} command, or @code{sqrt} function in an
12553 algebraic expression, produces a numeric answer if the argument is a
12554 number or a symbolic expression if the argument is an expression:
12555 @kbd{2 Q} pushes 1.4142 but @kbd{@key{'} x+1 @key{RET} Q} pushes @samp{sqrt(x+1)}.
12556
12557 @kindex m s
12558 @pindex calc-symbolic-mode
12559 In @dfn{Symbolic mode}, controlled by the @kbd{m s} (@code{calc-symbolic-mode})
12560 command, functions which would produce inexact, irrational results are
12561 left in symbolic form. Thus @kbd{16 Q} pushes 4, but @kbd{2 Q} pushes
12562 @samp{sqrt(2)}.
12563
12564 @kindex N
12565 @pindex calc-eval-num
12566 The shift-@kbd{N} (@code{calc-eval-num}) command evaluates numerically
12567 the expression at the top of the stack, by temporarily disabling
12568 @code{calc-symbolic-mode} and executing @kbd{=} (@code{calc-evaluate}).
12569 Given a numeric prefix argument, it also
12570 sets the floating-point precision to the specified value for the duration
12571 of the command.
12572
12573 To evaluate a formula numerically without expanding the variables it
12574 contains, you can use the key sequence @kbd{m s a v m s} (this uses
12575 @code{calc-alg-evaluate}, which resimplifies but doesn't evaluate
12576 variables.)
12577
12578 @node Matrix Mode, Automatic Recomputation, Symbolic Mode, Calculation Modes
12579 @subsection Matrix and Scalar Modes
12580
12581 @noindent
12582 @cindex Matrix mode
12583 @cindex Scalar mode
12584 Calc sometimes makes assumptions during algebraic manipulation that
12585 are awkward or incorrect when vectors and matrices are involved.
12586 Calc has two modes, @dfn{Matrix mode} and @dfn{Scalar mode}, which
12587 modify its behavior around vectors in useful ways.
12588
12589 @kindex m v
12590 @pindex calc-matrix-mode
12591 Press @kbd{m v} (@code{calc-matrix-mode}) once to enter Matrix mode.
12592 In this mode, all objects are assumed to be matrices unless provably
12593 otherwise. One major effect is that Calc will no longer consider
12594 multiplication to be commutative. (Recall that in matrix arithmetic,
12595 @samp{A*B} is not the same as @samp{B*A}.) This assumption affects
12596 rewrite rules and algebraic simplification. Another effect of this
12597 mode is that calculations that would normally produce constants like
12598 0 and 1 (e.g., @expr{a - a} and @expr{a / a}, respectively) will now
12599 produce function calls that represent ``generic'' zero or identity
12600 matrices: @samp{idn(0)}, @samp{idn(1)}. The @code{idn} function
12601 @samp{idn(@var{a},@var{n})} returns @var{a} times an @var{n}x@var{n}
12602 identity matrix; if @var{n} is omitted, it doesn't know what
12603 dimension to use and so the @code{idn} call remains in symbolic
12604 form. However, if this generic identity matrix is later combined
12605 with a matrix whose size is known, it will be converted into
12606 a true identity matrix of the appropriate size. On the other hand,
12607 if it is combined with a scalar (as in @samp{idn(1) + 2}), Calc
12608 will assume it really was a scalar after all and produce, e.g., 3.
12609
12610 Press @kbd{m v} a second time to get Scalar mode. Here, objects are
12611 assumed @emph{not} to be vectors or matrices unless provably so.
12612 For example, normally adding a variable to a vector, as in
12613 @samp{[x, y, z] + a}, will leave the sum in symbolic form because
12614 as far as Calc knows, @samp{a} could represent either a number or
12615 another 3-vector. In Scalar mode, @samp{a} is assumed to be a
12616 non-vector, and the addition is evaluated to @samp{[x+a, y+a, z+a]}.
12617
12618 Press @kbd{m v} a third time to return to the normal mode of operation.
12619
12620 If you press @kbd{m v} with a numeric prefix argument @var{n}, you
12621 get a special ``dimensioned'' Matrix mode in which matrices of
12622 unknown size are assumed to be @var{n}x@var{n} square matrices.
12623 Then, the function call @samp{idn(1)} will expand into an actual
12624 matrix rather than representing a ``generic'' matrix.
12625
12626 @cindex Declaring scalar variables
12627 Of course these modes are approximations to the true state of
12628 affairs, which is probably that some quantities will be matrices
12629 and others will be scalars. One solution is to ``declare''
12630 certain variables or functions to be scalar-valued.
12631 @xref{Declarations}, to see how to make declarations in Calc.
12632
12633 There is nothing stopping you from declaring a variable to be
12634 scalar and then storing a matrix in it; however, if you do, the
12635 results you get from Calc may not be valid. Suppose you let Calc
12636 get the result @samp{[x+a, y+a, z+a]} shown above, and then stored
12637 @samp{[1, 2, 3]} in @samp{a}. The result would not be the same as
12638 for @samp{[x, y, z] + [1, 2, 3]}, but that's because you have broken
12639 your earlier promise to Calc that @samp{a} would be scalar.
12640
12641 Another way to mix scalars and matrices is to use selections
12642 (@pxref{Selecting Subformulas}). Use Matrix mode when operating on
12643 your formula normally; then, to apply Scalar mode to a certain part
12644 of the formula without affecting the rest just select that part,
12645 change into Scalar mode and press @kbd{=} to resimplify the part
12646 under this mode, then change back to Matrix mode before deselecting.
12647
12648 @node Automatic Recomputation, Working Message, Matrix Mode, Calculation Modes
12649 @subsection Automatic Recomputation
12650
12651 @noindent
12652 The @dfn{evaluates-to} operator, @samp{=>}, has the special
12653 property that any @samp{=>} formulas on the stack are recomputed
12654 whenever variable values or mode settings that might affect them
12655 are changed. @xref{Evaluates-To Operator}.
12656
12657 @kindex m C
12658 @pindex calc-auto-recompute
12659 The @kbd{m C} (@code{calc-auto-recompute}) command turns this
12660 automatic recomputation on and off. If you turn it off, Calc will
12661 not update @samp{=>} operators on the stack (nor those in the
12662 attached Embedded mode buffer, if there is one). They will not
12663 be updated unless you explicitly do so by pressing @kbd{=} or until
12664 you press @kbd{m C} to turn recomputation back on. (While automatic
12665 recomputation is off, you can think of @kbd{m C m C} as a command
12666 to update all @samp{=>} operators while leaving recomputation off.)
12667
12668 To update @samp{=>} operators in an Embedded buffer while
12669 automatic recomputation is off, use @w{@kbd{M-# u}}.
12670 @xref{Embedded Mode}.
12671
12672 @node Working Message, , Automatic Recomputation, Calculation Modes
12673 @subsection Working Messages
12674
12675 @noindent
12676 @cindex Performance
12677 @cindex Working messages
12678 Since the Calculator is written entirely in Emacs Lisp, which is not
12679 designed for heavy numerical work, many operations are quite slow.
12680 The Calculator normally displays the message @samp{Working...} in the
12681 echo area during any command that may be slow. In addition, iterative
12682 operations such as square roots and trigonometric functions display the
12683 intermediate result at each step. Both of these types of messages can
12684 be disabled if you find them distracting.
12685
12686 @kindex m w
12687 @pindex calc-working
12688 Type @kbd{m w} (@code{calc-working}) with a numeric prefix of 0 to
12689 disable all ``working'' messages. Use a numeric prefix of 1 to enable
12690 only the plain @samp{Working...} message. Use a numeric prefix of 2 to
12691 see intermediate results as well. With no numeric prefix this displays
12692 the current mode.
12693
12694 While it may seem that the ``working'' messages will slow Calc down
12695 considerably, experiments have shown that their impact is actually
12696 quite small. But if your terminal is slow you may find that it helps
12697 to turn the messages off.
12698
12699 @node Simplification Modes, Declarations, Calculation Modes, Mode Settings
12700 @section Simplification Modes
12701
12702 @noindent
12703 The current @dfn{simplification mode} controls how numbers and formulas
12704 are ``normalized'' when being taken from or pushed onto the stack.
12705 Some normalizations are unavoidable, such as rounding floating-point
12706 results to the current precision, and reducing fractions to simplest
12707 form. Others, such as simplifying a formula like @expr{a+a} (or @expr{2+3}),
12708 are done by default but can be turned off when necessary.
12709
12710 When you press a key like @kbd{+} when @expr{2} and @expr{3} are on the
12711 stack, Calc pops these numbers, normalizes them, creates the formula
12712 @expr{2+3}, normalizes it, and pushes the result. Of course the standard
12713 rules for normalizing @expr{2+3} will produce the result @expr{5}.
12714
12715 Simplification mode commands consist of the lower-case @kbd{m} prefix key
12716 followed by a shifted letter.
12717
12718 @kindex m O
12719 @pindex calc-no-simplify-mode
12720 The @kbd{m O} (@code{calc-no-simplify-mode}) command turns off all optional
12721 simplifications. These would leave a formula like @expr{2+3} alone. In
12722 fact, nothing except simple numbers are ever affected by normalization
12723 in this mode.
12724
12725 @kindex m N
12726 @pindex calc-num-simplify-mode
12727 The @kbd{m N} (@code{calc-num-simplify-mode}) command turns off simplification
12728 of any formulas except those for which all arguments are constants. For
12729 example, @expr{1+2} is simplified to @expr{3}, and @expr{a+(2-2)} is
12730 simplified to @expr{a+0} but no further, since one argument of the sum
12731 is not a constant. Unfortunately, @expr{(a+2)-2} is @emph{not} simplified
12732 because the top-level @samp{-} operator's arguments are not both
12733 constant numbers (one of them is the formula @expr{a+2}).
12734 A constant is a number or other numeric object (such as a constant
12735 error form or modulo form), or a vector all of whose
12736 elements are constant.
12737
12738 @kindex m D
12739 @pindex calc-default-simplify-mode
12740 The @kbd{m D} (@code{calc-default-simplify-mode}) command restores the
12741 default simplifications for all formulas. This includes many easy and
12742 fast algebraic simplifications such as @expr{a+0} to @expr{a}, and
12743 @expr{a + 2 a} to @expr{3 a}, as well as evaluating functions like
12744 @expr{@tfn{deriv}(x^2, x)} to @expr{2 x}.
12745
12746 @kindex m B
12747 @pindex calc-bin-simplify-mode
12748 The @kbd{m B} (@code{calc-bin-simplify-mode}) mode applies the default
12749 simplifications to a result and then, if the result is an integer,
12750 uses the @kbd{b c} (@code{calc-clip}) command to clip the integer according
12751 to the current binary word size. @xref{Binary Functions}. Real numbers
12752 are rounded to the nearest integer and then clipped; other kinds of
12753 results (after the default simplifications) are left alone.
12754
12755 @kindex m A
12756 @pindex calc-alg-simplify-mode
12757 The @kbd{m A} (@code{calc-alg-simplify-mode}) mode does algebraic
12758 simplification; it applies all the default simplifications, and also
12759 the more powerful (and slower) simplifications made by @kbd{a s}
12760 (@code{calc-simplify}). @xref{Algebraic Simplifications}.
12761
12762 @kindex m E
12763 @pindex calc-ext-simplify-mode
12764 The @kbd{m E} (@code{calc-ext-simplify-mode}) mode does ``extended''
12765 algebraic simplification, as by the @kbd{a e} (@code{calc-simplify-extended})
12766 command. @xref{Unsafe Simplifications}.
12767
12768 @kindex m U
12769 @pindex calc-units-simplify-mode
12770 The @kbd{m U} (@code{calc-units-simplify-mode}) mode does units
12771 simplification; it applies the command @kbd{u s}
12772 (@code{calc-simplify-units}), which in turn
12773 is a superset of @kbd{a s}. In this mode, variable names which
12774 are identifiable as unit names (like @samp{mm} for ``millimeters'')
12775 are simplified with their unit definitions in mind.
12776
12777 A common technique is to set the simplification mode down to the lowest
12778 amount of simplification you will allow to be applied automatically, then
12779 use manual commands like @kbd{a s} and @kbd{c c} (@code{calc-clean}) to
12780 perform higher types of simplifications on demand. @xref{Algebraic
12781 Definitions}, for another sample use of No-Simplification mode.
12782
12783 @node Declarations, Display Modes, Simplification Modes, Mode Settings
12784 @section Declarations
12785
12786 @noindent
12787 A @dfn{declaration} is a statement you make that promises you will
12788 use a certain variable or function in a restricted way. This may
12789 give Calc the freedom to do things that it couldn't do if it had to
12790 take the fully general situation into account.
12791
12792 @menu
12793 * Declaration Basics::
12794 * Kinds of Declarations::
12795 * Functions for Declarations::
12796 @end menu
12797
12798 @node Declaration Basics, Kinds of Declarations, Declarations, Declarations
12799 @subsection Declaration Basics
12800
12801 @noindent
12802 @kindex s d
12803 @pindex calc-declare-variable
12804 The @kbd{s d} (@code{calc-declare-variable}) command is the easiest
12805 way to make a declaration for a variable. This command prompts for
12806 the variable name, then prompts for the declaration. The default
12807 at the declaration prompt is the previous declaration, if any.
12808 You can edit this declaration, or press @kbd{C-k} to erase it and
12809 type a new declaration. (Or, erase it and press @key{RET} to clear
12810 the declaration, effectively ``undeclaring'' the variable.)
12811
12812 A declaration is in general a vector of @dfn{type symbols} and
12813 @dfn{range} values. If there is only one type symbol or range value,
12814 you can write it directly rather than enclosing it in a vector.
12815 For example, @kbd{s d foo @key{RET} real @key{RET}} declares @code{foo} to
12816 be a real number, and @kbd{s d bar @key{RET} [int, const, [1..6]] @key{RET}}
12817 declares @code{bar} to be a constant integer between 1 and 6.
12818 (Actually, you can omit the outermost brackets and Calc will
12819 provide them for you: @kbd{s d bar @key{RET} int, const, [1..6] @key{RET}}.)
12820
12821 @cindex @code{Decls} variable
12822 @vindex Decls
12823 Declarations in Calc are kept in a special variable called @code{Decls}.
12824 This variable encodes the set of all outstanding declarations in
12825 the form of a matrix. Each row has two elements: A variable or
12826 vector of variables declared by that row, and the declaration
12827 specifier as described above. You can use the @kbd{s D} command to
12828 edit this variable if you wish to see all the declarations at once.
12829 @xref{Operations on Variables}, for a description of this command
12830 and the @kbd{s p} command that allows you to save your declarations
12831 permanently if you wish.
12832
12833 Items being declared can also be function calls. The arguments in
12834 the call are ignored; the effect is to say that this function returns
12835 values of the declared type for any valid arguments. The @kbd{s d}
12836 command declares only variables, so if you wish to make a function
12837 declaration you will have to edit the @code{Decls} matrix yourself.
12838
12839 For example, the declaration matrix
12840
12841 @smallexample
12842 @group
12843 [ [ foo, real ]
12844 [ [j, k, n], int ]
12845 [ f(1,2,3), [0 .. inf) ] ]
12846 @end group
12847 @end smallexample
12848
12849 @noindent
12850 declares that @code{foo} represents a real number, @code{j}, @code{k}
12851 and @code{n} represent integers, and the function @code{f} always
12852 returns a real number in the interval shown.
12853
12854 @vindex All
12855 If there is a declaration for the variable @code{All}, then that
12856 declaration applies to all variables that are not otherwise declared.
12857 It does not apply to function names. For example, using the row
12858 @samp{[All, real]} says that all your variables are real unless they
12859 are explicitly declared without @code{real} in some other row.
12860 The @kbd{s d} command declares @code{All} if you give a blank
12861 response to the variable-name prompt.
12862
12863 @node Kinds of Declarations, Functions for Declarations, Declaration Basics, Declarations
12864 @subsection Kinds of Declarations
12865
12866 @noindent
12867 The type-specifier part of a declaration (that is, the second prompt
12868 in the @kbd{s d} command) can be a type symbol, an interval, or a
12869 vector consisting of zero or more type symbols followed by zero or
12870 more intervals or numbers that represent the set of possible values
12871 for the variable.
12872
12873 @smallexample
12874 @group
12875 [ [ a, [1, 2, 3, 4, 5] ]
12876 [ b, [1 .. 5] ]
12877 [ c, [int, 1 .. 5] ] ]
12878 @end group
12879 @end smallexample
12880
12881 Here @code{a} is declared to contain one of the five integers shown;
12882 @code{b} is any number in the interval from 1 to 5 (any real number
12883 since we haven't specified), and @code{c} is any integer in that
12884 interval. Thus the declarations for @code{a} and @code{c} are
12885 nearly equivalent (see below).
12886
12887 The type-specifier can be the empty vector @samp{[]} to say that
12888 nothing is known about a given variable's value. This is the same
12889 as not declaring the variable at all except that it overrides any
12890 @code{All} declaration which would otherwise apply.
12891
12892 The initial value of @code{Decls} is the empty vector @samp{[]}.
12893 If @code{Decls} has no stored value or if the value stored in it
12894 is not valid, it is ignored and there are no declarations as far
12895 as Calc is concerned. (The @kbd{s d} command will replace such a
12896 malformed value with a fresh empty matrix, @samp{[]}, before recording
12897 the new declaration.) Unrecognized type symbols are ignored.
12898
12899 The following type symbols describe what sorts of numbers will be
12900 stored in a variable:
12901
12902 @table @code
12903 @item int
12904 Integers.
12905 @item numint
12906 Numerical integers. (Integers or integer-valued floats.)
12907 @item frac
12908 Fractions. (Rational numbers which are not integers.)
12909 @item rat
12910 Rational numbers. (Either integers or fractions.)
12911 @item float
12912 Floating-point numbers.
12913 @item real
12914 Real numbers. (Integers, fractions, or floats. Actually,
12915 intervals and error forms with real components also count as
12916 reals here.)
12917 @item pos
12918 Positive real numbers. (Strictly greater than zero.)
12919 @item nonneg
12920 Nonnegative real numbers. (Greater than or equal to zero.)
12921 @item number
12922 Numbers. (Real or complex.)
12923 @end table
12924
12925 Calc uses this information to determine when certain simplifications
12926 of formulas are safe. For example, @samp{(x^y)^z} cannot be
12927 simplified to @samp{x^(y z)} in general; for example,
12928 @samp{((-3)^2)^1:2} is 3, but @samp{(-3)^(2*1:2) = (-3)^1} is @mathit{-3}.
12929 However, this simplification @emph{is} safe if @code{z} is known
12930 to be an integer, or if @code{x} is known to be a nonnegative
12931 real number. If you have given declarations that allow Calc to
12932 deduce either of these facts, Calc will perform this simplification
12933 of the formula.
12934
12935 Calc can apply a certain amount of logic when using declarations.
12936 For example, @samp{(x^y)^(2n+1)} will be simplified if @code{n}
12937 has been declared @code{int}; Calc knows that an integer times an
12938 integer, plus an integer, must always be an integer. (In fact,
12939 Calc would simplify @samp{(-x)^(2n+1)} to @samp{-(x^(2n+1))} since
12940 it is able to determine that @samp{2n+1} must be an odd integer.)
12941
12942 Similarly, @samp{(abs(x)^y)^z} will be simplified to @samp{abs(x)^(y z)}
12943 because Calc knows that the @code{abs} function always returns a
12944 nonnegative real. If you had a @code{myabs} function that also had
12945 this property, you could get Calc to recognize it by adding the row
12946 @samp{[myabs(), nonneg]} to the @code{Decls} matrix.
12947
12948 One instance of this simplification is @samp{sqrt(x^2)} (since the
12949 @code{sqrt} function is effectively a one-half power). Normally
12950 Calc leaves this formula alone. After the command
12951 @kbd{s d x @key{RET} real @key{RET}}, however, it can simplify the formula to
12952 @samp{abs(x)}. And after @kbd{s d x @key{RET} nonneg @key{RET}}, Calc can
12953 simplify this formula all the way to @samp{x}.
12954
12955 If there are any intervals or real numbers in the type specifier,
12956 they comprise the set of possible values that the variable or
12957 function being declared can have. In particular, the type symbol
12958 @code{real} is effectively the same as the range @samp{[-inf .. inf]}
12959 (note that infinity is included in the range of possible values);
12960 @code{pos} is the same as @samp{(0 .. inf]}, and @code{nonneg} is
12961 the same as @samp{[0 .. inf]}. Saying @samp{[real, [-5 .. 5]]} is
12962 redundant because the fact that the variable is real can be
12963 deduced just from the interval, but @samp{[int, [-5 .. 5]]} and
12964 @samp{[rat, [-5 .. 5]]} are useful combinations.
12965
12966 Note that the vector of intervals or numbers is in the same format
12967 used by Calc's set-manipulation commands. @xref{Set Operations}.
12968
12969 The type specifier @samp{[1, 2, 3]} is equivalent to
12970 @samp{[numint, 1, 2, 3]}, @emph{not} to @samp{[int, 1, 2, 3]}.
12971 In other words, the range of possible values means only that
12972 the variable's value must be numerically equal to a number in
12973 that range, but not that it must be equal in type as well.
12974 Calc's set operations act the same way; @samp{in(2, [1., 2., 3.])}
12975 and @samp{in(1.5, [1:2, 3:2, 5:2])} both report ``true.''
12976
12977 If you use a conflicting combination of type specifiers, the
12978 results are unpredictable. An example is @samp{[pos, [0 .. 5]]},
12979 where the interval does not lie in the range described by the
12980 type symbol.
12981
12982 ``Real'' declarations mostly affect simplifications involving powers
12983 like the one described above. Another case where they are used
12984 is in the @kbd{a P} command which returns a list of all roots of a
12985 polynomial; if the variable has been declared real, only the real
12986 roots (if any) will be included in the list.
12987
12988 ``Integer'' declarations are used for simplifications which are valid
12989 only when certain values are integers (such as @samp{(x^y)^z}
12990 shown above).
12991
12992 Another command that makes use of declarations is @kbd{a s}, when
12993 simplifying equations and inequalities. It will cancel @code{x}
12994 from both sides of @samp{a x = b x} only if it is sure @code{x}
12995 is non-zero, say, because it has a @code{pos} declaration.
12996 To declare specifically that @code{x} is real and non-zero,
12997 use @samp{[[-inf .. 0), (0 .. inf]]}. (There is no way in the
12998 current notation to say that @code{x} is nonzero but not necessarily
12999 real.) The @kbd{a e} command does ``unsafe'' simplifications,
13000 including cancelling @samp{x} from the equation when @samp{x} is
13001 not known to be nonzero.
13002
13003 Another set of type symbols distinguish between scalars and vectors.
13004
13005 @table @code
13006 @item scalar
13007 The value is not a vector.
13008 @item vector
13009 The value is a vector.
13010 @item matrix
13011 The value is a matrix (a rectangular vector of vectors).
13012 @end table
13013
13014 These type symbols can be combined with the other type symbols
13015 described above; @samp{[int, matrix]} describes an object which
13016 is a matrix of integers.
13017
13018 Scalar/vector declarations are used to determine whether certain
13019 algebraic operations are safe. For example, @samp{[a, b, c] + x}
13020 is normally not simplified to @samp{[a + x, b + x, c + x]}, but
13021 it will be if @code{x} has been declared @code{scalar}. On the
13022 other hand, multiplication is usually assumed to be commutative,
13023 but the terms in @samp{x y} will never be exchanged if both @code{x}
13024 and @code{y} are known to be vectors or matrices. (Calc currently
13025 never distinguishes between @code{vector} and @code{matrix}
13026 declarations.)
13027
13028 @xref{Matrix Mode}, for a discussion of Matrix mode and
13029 Scalar mode, which are similar to declaring @samp{[All, matrix]}
13030 or @samp{[All, scalar]} but much more convenient.
13031
13032 One more type symbol that is recognized is used with the @kbd{H a d}
13033 command for taking total derivatives of a formula. @xref{Calculus}.
13034
13035 @table @code
13036 @item const
13037 The value is a constant with respect to other variables.
13038 @end table
13039
13040 Calc does not check the declarations for a variable when you store
13041 a value in it. However, storing @mathit{-3.5} in a variable that has
13042 been declared @code{pos}, @code{int}, or @code{matrix} may have
13043 unexpected effects; Calc may evaluate @samp{sqrt(x^2)} to @expr{3.5}
13044 if it substitutes the value first, or to @expr{-3.5} if @code{x}
13045 was declared @code{pos} and the formula @samp{sqrt(x^2)} is
13046 simplified to @samp{x} before the value is substituted. Before
13047 using a variable for a new purpose, it is best to use @kbd{s d}
13048 or @kbd{s D} to check to make sure you don't still have an old
13049 declaration for the variable that will conflict with its new meaning.
13050
13051 @node Functions for Declarations, , Kinds of Declarations, Declarations
13052 @subsection Functions for Declarations
13053
13054 @noindent
13055 Calc has a set of functions for accessing the current declarations
13056 in a convenient manner. These functions return 1 if the argument
13057 can be shown to have the specified property, or 0 if the argument
13058 can be shown @emph{not} to have that property; otherwise they are
13059 left unevaluated. These functions are suitable for use with rewrite
13060 rules (@pxref{Conditional Rewrite Rules}) or programming constructs
13061 (@pxref{Conditionals in Macros}). They can be entered only using
13062 algebraic notation. @xref{Logical Operations}, for functions
13063 that perform other tests not related to declarations.
13064
13065 For example, @samp{dint(17)} returns 1 because 17 is an integer, as
13066 do @samp{dint(n)} and @samp{dint(2 n - 3)} if @code{n} has been declared
13067 @code{int}, but @samp{dint(2.5)} and @samp{dint(n + 0.5)} return 0.
13068 Calc consults knowledge of its own built-in functions as well as your
13069 own declarations: @samp{dint(floor(x))} returns 1.
13070
13071 @ignore
13072 @starindex
13073 @end ignore
13074 @tindex dint
13075 @ignore
13076 @starindex
13077 @end ignore
13078 @tindex dnumint
13079 @ignore
13080 @starindex
13081 @end ignore
13082 @tindex dnatnum
13083 The @code{dint} function checks if its argument is an integer.
13084 The @code{dnatnum} function checks if its argument is a natural
13085 number, i.e., a nonnegative integer. The @code{dnumint} function
13086 checks if its argument is numerically an integer, i.e., either an
13087 integer or an integer-valued float. Note that these and the other
13088 data type functions also accept vectors or matrices composed of
13089 suitable elements, and that real infinities @samp{inf} and @samp{-inf}
13090 are considered to be integers for the purposes of these functions.
13091
13092 @ignore
13093 @starindex
13094 @end ignore
13095 @tindex drat
13096 The @code{drat} function checks if its argument is rational, i.e.,
13097 an integer or fraction. Infinities count as rational, but intervals
13098 and error forms do not.
13099
13100 @ignore
13101 @starindex
13102 @end ignore
13103 @tindex dreal
13104 The @code{dreal} function checks if its argument is real. This
13105 includes integers, fractions, floats, real error forms, and intervals.
13106
13107 @ignore
13108 @starindex
13109 @end ignore
13110 @tindex dimag
13111 The @code{dimag} function checks if its argument is imaginary,
13112 i.e., is mathematically equal to a real number times @expr{i}.
13113
13114 @ignore
13115 @starindex
13116 @end ignore
13117 @tindex dpos
13118 @ignore
13119 @starindex
13120 @end ignore
13121 @tindex dneg
13122 @ignore
13123 @starindex
13124 @end ignore
13125 @tindex dnonneg
13126 The @code{dpos} function checks for positive (but nonzero) reals.
13127 The @code{dneg} function checks for negative reals. The @code{dnonneg}
13128 function checks for nonnegative reals, i.e., reals greater than or
13129 equal to zero. Note that the @kbd{a s} command can simplify an
13130 expression like @expr{x > 0} to 1 or 0 using @code{dpos}, and that
13131 @kbd{a s} is effectively applied to all conditions in rewrite rules,
13132 so the actual functions @code{dpos}, @code{dneg}, and @code{dnonneg}
13133 are rarely necessary.
13134
13135 @ignore
13136 @starindex
13137 @end ignore
13138 @tindex dnonzero
13139 The @code{dnonzero} function checks that its argument is nonzero.
13140 This includes all nonzero real or complex numbers, all intervals that
13141 do not include zero, all nonzero modulo forms, vectors all of whose
13142 elements are nonzero, and variables or formulas whose values can be
13143 deduced to be nonzero. It does not include error forms, since they
13144 represent values which could be anything including zero. (This is
13145 also the set of objects considered ``true'' in conditional contexts.)
13146
13147 @ignore
13148 @starindex
13149 @end ignore
13150 @tindex deven
13151 @ignore
13152 @starindex
13153 @end ignore
13154 @tindex dodd
13155 The @code{deven} function returns 1 if its argument is known to be
13156 an even integer (or integer-valued float); it returns 0 if its argument
13157 is known not to be even (because it is known to be odd or a non-integer).
13158 The @kbd{a s} command uses this to simplify a test of the form
13159 @samp{x % 2 = 0}. There is also an analogous @code{dodd} function.
13160
13161 @ignore
13162 @starindex
13163 @end ignore
13164 @tindex drange
13165 The @code{drange} function returns a set (an interval or a vector
13166 of intervals and/or numbers; @pxref{Set Operations}) that describes
13167 the set of possible values of its argument. If the argument is
13168 a variable or a function with a declaration, the range is copied
13169 from the declaration. Otherwise, the possible signs of the
13170 expression are determined using a method similar to @code{dpos},
13171 etc., and a suitable set like @samp{[0 .. inf]} is returned. If
13172 the expression is not provably real, the @code{drange} function
13173 remains unevaluated.
13174
13175 @ignore
13176 @starindex
13177 @end ignore
13178 @tindex dscalar
13179 The @code{dscalar} function returns 1 if its argument is provably
13180 scalar, or 0 if its argument is provably non-scalar. It is left
13181 unevaluated if this cannot be determined. (If Matrix mode or Scalar
13182 mode is in effect, this function returns 1 or 0, respectively,
13183 if it has no other information.) When Calc interprets a condition
13184 (say, in a rewrite rule) it considers an unevaluated formula to be
13185 ``false.'' Thus, @samp{dscalar(a)} is ``true'' only if @code{a} is
13186 provably scalar, and @samp{!dscalar(a)} is ``true'' only if @code{a}
13187 is provably non-scalar; both are ``false'' if there is insufficient
13188 information to tell.
13189
13190 @node Display Modes, Language Modes, Declarations, Mode Settings
13191 @section Display Modes
13192
13193 @noindent
13194 The commands in this section are two-key sequences beginning with the
13195 @kbd{d} prefix. The @kbd{d l} (@code{calc-line-numbering}) and @kbd{d b}
13196 (@code{calc-line-breaking}) commands are described elsewhere;
13197 @pxref{Stack Basics} and @pxref{Normal Language Modes}, respectively.
13198 Display formats for vectors and matrices are also covered elsewhere;
13199 @pxref{Vector and Matrix Formats}.
13200
13201 One thing all display modes have in common is their treatment of the
13202 @kbd{H} prefix. This prefix causes any mode command that would normally
13203 refresh the stack to leave the stack display alone. The word ``Dirty''
13204 will appear in the mode line when Calc thinks the stack display may not
13205 reflect the latest mode settings.
13206
13207 @kindex d @key{RET}
13208 @pindex calc-refresh-top
13209 The @kbd{d @key{RET}} (@code{calc-refresh-top}) command reformats the
13210 top stack entry according to all the current modes. Positive prefix
13211 arguments reformat the top @var{n} entries; negative prefix arguments
13212 reformat the specified entry, and a prefix of zero is equivalent to
13213 @kbd{d @key{SPC}} (@code{calc-refresh}), which reformats the entire stack.
13214 For example, @kbd{H d s M-2 d @key{RET}} changes to scientific notation
13215 but reformats only the top two stack entries in the new mode.
13216
13217 The @kbd{I} prefix has another effect on the display modes. The mode
13218 is set only temporarily; the top stack entry is reformatted according
13219 to that mode, then the original mode setting is restored. In other
13220 words, @kbd{I d s} is equivalent to @kbd{H d s d @key{RET} H d (@var{old mode})}.
13221
13222 @menu
13223 * Radix Modes::
13224 * Grouping Digits::
13225 * Float Formats::
13226 * Complex Formats::
13227 * Fraction Formats::
13228 * HMS Formats::
13229 * Date Formats::
13230 * Truncating the Stack::
13231 * Justification::
13232 * Labels::
13233 @end menu
13234
13235 @node Radix Modes, Grouping Digits, Display Modes, Display Modes
13236 @subsection Radix Modes
13237
13238 @noindent
13239 @cindex Radix display
13240 @cindex Non-decimal numbers
13241 @cindex Decimal and non-decimal numbers
13242 Calc normally displays numbers in decimal (@dfn{base-10} or @dfn{radix-10})
13243 notation. Calc can actually display in any radix from two (binary) to 36.
13244 When the radix is above 10, the letters @code{A} to @code{Z} are used as
13245 digits. When entering such a number, letter keys are interpreted as
13246 potential digits rather than terminating numeric entry mode.
13247
13248 @kindex d 2
13249 @kindex d 8
13250 @kindex d 6
13251 @kindex d 0
13252 @cindex Hexadecimal integers
13253 @cindex Octal integers
13254 The key sequences @kbd{d 2}, @kbd{d 8}, @kbd{d 6}, and @kbd{d 0} select
13255 binary, octal, hexadecimal, and decimal as the current display radix,
13256 respectively. Numbers can always be entered in any radix, though the
13257 current radix is used as a default if you press @kbd{#} without any initial
13258 digits. A number entered without a @kbd{#} is @emph{always} interpreted
13259 as decimal.
13260
13261 @kindex d r
13262 @pindex calc-radix
13263 To set the radix generally, use @kbd{d r} (@code{calc-radix}) and enter
13264 an integer from 2 to 36. You can specify the radix as a numeric prefix
13265 argument; otherwise you will be prompted for it.
13266
13267 @kindex d z
13268 @pindex calc-leading-zeros
13269 @cindex Leading zeros
13270 Integers normally are displayed with however many digits are necessary to
13271 represent the integer and no more. The @kbd{d z} (@code{calc-leading-zeros})
13272 command causes integers to be padded out with leading zeros according to the
13273 current binary word size. (@xref{Binary Functions}, for a discussion of
13274 word size.) If the absolute value of the word size is @expr{w}, all integers
13275 are displayed with at least enough digits to represent
13276 @texline @math{2^w-1}
13277 @infoline @expr{(2^w)-1}
13278 in the current radix. (Larger integers will still be displayed in their
13279 entirety.)
13280
13281 @node Grouping Digits, Float Formats, Radix Modes, Display Modes
13282 @subsection Grouping Digits
13283
13284 @noindent
13285 @kindex d g
13286 @pindex calc-group-digits
13287 @cindex Grouping digits
13288 @cindex Digit grouping
13289 Long numbers can be hard to read if they have too many digits. For
13290 example, the factorial of 30 is 33 digits long! Press @kbd{d g}
13291 (@code{calc-group-digits}) to enable @dfn{Grouping} mode, in which digits
13292 are displayed in clumps of 3 or 4 (depending on the current radix)
13293 separated by commas.
13294
13295 The @kbd{d g} command toggles grouping on and off.
13296 With a numerix prefix of 0, this command displays the current state of
13297 the grouping flag; with an argument of minus one it disables grouping;
13298 with a positive argument @expr{N} it enables grouping on every @expr{N}
13299 digits. For floating-point numbers, grouping normally occurs only
13300 before the decimal point. A negative prefix argument @expr{-N} enables
13301 grouping every @expr{N} digits both before and after the decimal point.
13302
13303 @kindex d ,
13304 @pindex calc-group-char
13305 The @kbd{d ,} (@code{calc-group-char}) command allows you to choose any
13306 character as the grouping separator. The default is the comma character.
13307 If you find it difficult to read vectors of large integers grouped with
13308 commas, you may wish to use spaces or some other character instead.
13309 This command takes the next character you type, whatever it is, and
13310 uses it as the digit separator. As a special case, @kbd{d , \} selects
13311 @samp{\,} (@TeX{}'s thin-space symbol) as the digit separator.
13312
13313 Please note that grouped numbers will not generally be parsed correctly
13314 if re-read in textual form, say by the use of @kbd{M-# y} and @kbd{M-# g}.
13315 (@xref{Kill and Yank}, for details on these commands.) One exception is
13316 the @samp{\,} separator, which doesn't interfere with parsing because it
13317 is ignored by @TeX{} language mode.
13318
13319 @node Float Formats, Complex Formats, Grouping Digits, Display Modes
13320 @subsection Float Formats
13321
13322 @noindent
13323 Floating-point quantities are normally displayed in standard decimal
13324 form, with scientific notation used if the exponent is especially high
13325 or low. All significant digits are normally displayed. The commands
13326 in this section allow you to choose among several alternative display
13327 formats for floats.
13328
13329 @kindex d n
13330 @pindex calc-normal-notation
13331 The @kbd{d n} (@code{calc-normal-notation}) command selects the normal
13332 display format. All significant figures in a number are displayed.
13333 With a positive numeric prefix, numbers are rounded if necessary to
13334 that number of significant digits. With a negative numerix prefix,
13335 the specified number of significant digits less than the current
13336 precision is used. (Thus @kbd{C-u -2 d n} displays 10 digits if the
13337 current precision is 12.)
13338
13339 @kindex d f
13340 @pindex calc-fix-notation
13341 The @kbd{d f} (@code{calc-fix-notation}) command selects fixed-point
13342 notation. The numeric argument is the number of digits after the
13343 decimal point, zero or more. This format will relax into scientific
13344 notation if a nonzero number would otherwise have been rounded all the
13345 way to zero. Specifying a negative number of digits is the same as
13346 for a positive number, except that small nonzero numbers will be rounded
13347 to zero rather than switching to scientific notation.
13348
13349 @kindex d s
13350 @pindex calc-sci-notation
13351 @cindex Scientific notation, display of
13352 The @kbd{d s} (@code{calc-sci-notation}) command selects scientific
13353 notation. A positive argument sets the number of significant figures
13354 displayed, of which one will be before and the rest after the decimal
13355 point. A negative argument works the same as for @kbd{d n} format.
13356 The default is to display all significant digits.
13357
13358 @kindex d e
13359 @pindex calc-eng-notation
13360 @cindex Engineering notation, display of
13361 The @kbd{d e} (@code{calc-eng-notation}) command selects engineering
13362 notation. This is similar to scientific notation except that the
13363 exponent is rounded down to a multiple of three, with from one to three
13364 digits before the decimal point. An optional numeric prefix sets the
13365 number of significant digits to display, as for @kbd{d s}.
13366
13367 It is important to distinguish between the current @emph{precision} and
13368 the current @emph{display format}. After the commands @kbd{C-u 10 p}
13369 and @kbd{C-u 6 d n} the Calculator computes all results to ten
13370 significant figures but displays only six. (In fact, intermediate
13371 calculations are often carried to one or two more significant figures,
13372 but values placed on the stack will be rounded down to ten figures.)
13373 Numbers are never actually rounded to the display precision for storage,
13374 except by commands like @kbd{C-k} and @kbd{M-# y} which operate on the
13375 actual displayed text in the Calculator buffer.
13376
13377 @kindex d .
13378 @pindex calc-point-char
13379 The @kbd{d .} (@code{calc-point-char}) command selects the character used
13380 as a decimal point. Normally this is a period; users in some countries
13381 may wish to change this to a comma. Note that this is only a display
13382 style; on entry, periods must always be used to denote floating-point
13383 numbers, and commas to separate elements in a list.
13384
13385 @node Complex Formats, Fraction Formats, Float Formats, Display Modes
13386 @subsection Complex Formats
13387
13388 @noindent
13389 @kindex d c
13390 @pindex calc-complex-notation
13391 There are three supported notations for complex numbers in rectangular
13392 form. The default is as a pair of real numbers enclosed in parentheses
13393 and separated by a comma: @samp{(a,b)}. The @kbd{d c}
13394 (@code{calc-complex-notation}) command selects this style.
13395
13396 @kindex d i
13397 @pindex calc-i-notation
13398 @kindex d j
13399 @pindex calc-j-notation
13400 The other notations are @kbd{d i} (@code{calc-i-notation}), in which
13401 numbers are displayed in @samp{a+bi} form, and @kbd{d j}
13402 (@code{calc-j-notation}) which displays the form @samp{a+bj} preferred
13403 in some disciplines.
13404
13405 @cindex @code{i} variable
13406 @vindex i
13407 Complex numbers are normally entered in @samp{(a,b)} format.
13408 If you enter @samp{2+3i} as an algebraic formula, it will be stored as
13409 the formula @samp{2 + 3 * i}. However, if you use @kbd{=} to evaluate
13410 this formula and you have not changed the variable @samp{i}, the @samp{i}
13411 will be interpreted as @samp{(0,1)} and the formula will be simplified
13412 to @samp{(2,3)}. Other commands (like @code{calc-sin}) will @emph{not}
13413 interpret the formula @samp{2 + 3 * i} as a complex number.
13414 @xref{Variables}, under ``special constants.''
13415
13416 @node Fraction Formats, HMS Formats, Complex Formats, Display Modes
13417 @subsection Fraction Formats
13418
13419 @noindent
13420 @kindex d o
13421 @pindex calc-over-notation
13422 Display of fractional numbers is controlled by the @kbd{d o}
13423 (@code{calc-over-notation}) command. By default, a number like
13424 eight thirds is displayed in the form @samp{8:3}. The @kbd{d o} command
13425 prompts for a one- or two-character format. If you give one character,
13426 that character is used as the fraction separator. Common separators are
13427 @samp{:} and @samp{/}. (During input of numbers, the @kbd{:} key must be
13428 used regardless of the display format; in particular, the @kbd{/} is used
13429 for RPN-style division, @emph{not} for entering fractions.)
13430
13431 If you give two characters, fractions use ``integer-plus-fractional-part''
13432 notation. For example, the format @samp{+/} would display eight thirds
13433 as @samp{2+2/3}. If two colons are present in a number being entered,
13434 the number is interpreted in this form (so that the entries @kbd{2:2:3}
13435 and @kbd{8:3} are equivalent).
13436
13437 It is also possible to follow the one- or two-character format with
13438 a number. For example: @samp{:10} or @samp{+/3}. In this case,
13439 Calc adjusts all fractions that are displayed to have the specified
13440 denominator, if possible. Otherwise it adjusts the denominator to
13441 be a multiple of the specified value. For example, in @samp{:6} mode
13442 the fraction @expr{1:6} will be unaffected, but @expr{2:3} will be
13443 displayed as @expr{4:6}, @expr{1:2} will be displayed as @expr{3:6},
13444 and @expr{1:8} will be displayed as @expr{3:24}. Integers are also
13445 affected by this mode: 3 is displayed as @expr{18:6}. Note that the
13446 format @samp{:1} writes fractions the same as @samp{:}, but it writes
13447 integers as @expr{n:1}.
13448
13449 The fraction format does not affect the way fractions or integers are
13450 stored, only the way they appear on the screen. The fraction format
13451 never affects floats.
13452
13453 @node HMS Formats, Date Formats, Fraction Formats, Display Modes
13454 @subsection HMS Formats
13455
13456 @noindent
13457 @kindex d h
13458 @pindex calc-hms-notation
13459 The @kbd{d h} (@code{calc-hms-notation}) command controls the display of
13460 HMS (hours-minutes-seconds) forms. It prompts for a string which
13461 consists basically of an ``hours'' marker, optional punctuation, a
13462 ``minutes'' marker, more optional punctuation, and a ``seconds'' marker.
13463 Punctuation is zero or more spaces, commas, or semicolons. The hours
13464 marker is one or more non-punctuation characters. The minutes and
13465 seconds markers must be single non-punctuation characters.
13466
13467 The default HMS format is @samp{@@ ' "}, producing HMS values of the form
13468 @samp{23@@ 30' 15.75"}. The format @samp{deg, ms} would display this same
13469 value as @samp{23deg, 30m15.75s}. During numeric entry, the @kbd{h} or @kbd{o}
13470 keys are recognized as synonyms for @kbd{@@} regardless of display format.
13471 The @kbd{m} and @kbd{s} keys are recognized as synonyms for @kbd{'} and
13472 @kbd{"}, respectively, but only if an @kbd{@@} (or @kbd{h} or @kbd{o}) has
13473 already been typed; otherwise, they have their usual meanings
13474 (@kbd{m-} prefix and @kbd{s-} prefix). Thus, @kbd{5 "}, @kbd{0 @@ 5 "}, and
13475 @kbd{0 h 5 s} are some of the ways to enter the quantity ``five seconds.''
13476 The @kbd{'} key is recognized as ``minutes'' only if @kbd{@@} (or @kbd{h} or
13477 @kbd{o}) has already been pressed; otherwise it means to switch to algebraic
13478 entry.
13479
13480 @node Date Formats, Truncating the Stack, HMS Formats, Display Modes
13481 @subsection Date Formats
13482
13483 @noindent
13484 @kindex d d
13485 @pindex calc-date-notation
13486 The @kbd{d d} (@code{calc-date-notation}) command controls the display
13487 of date forms (@pxref{Date Forms}). It prompts for a string which
13488 contains letters that represent the various parts of a date and time.
13489 To show which parts should be omitted when the form represents a pure
13490 date with no time, parts of the string can be enclosed in @samp{< >}
13491 marks. If you don't include @samp{< >} markers in the format, Calc
13492 guesses at which parts, if any, should be omitted when formatting
13493 pure dates.
13494
13495 The default format is: @samp{<H:mm:SSpp >Www Mmm D, YYYY}.
13496 An example string in this format is @samp{3:32pm Wed Jan 9, 1991}.
13497 If you enter a blank format string, this default format is
13498 reestablished.
13499
13500 Calc uses @samp{< >} notation for nameless functions as well as for
13501 dates. @xref{Specifying Operators}. To avoid confusion with nameless
13502 functions, your date formats should avoid using the @samp{#} character.
13503
13504 @menu
13505 * Date Formatting Codes::
13506 * Free-Form Dates::
13507 * Standard Date Formats::
13508 @end menu
13509
13510 @node Date Formatting Codes, Free-Form Dates, Date Formats, Date Formats
13511 @subsubsection Date Formatting Codes
13512
13513 @noindent
13514 When displaying a date, the current date format is used. All
13515 characters except for letters and @samp{<} and @samp{>} are
13516 copied literally when dates are formatted. The portion between
13517 @samp{< >} markers is omitted for pure dates, or included for
13518 date/time forms. Letters are interpreted according to the table
13519 below.
13520
13521 When dates are read in during algebraic entry, Calc first tries to
13522 match the input string to the current format either with or without
13523 the time part. The punctuation characters (including spaces) must
13524 match exactly; letter fields must correspond to suitable text in
13525 the input. If this doesn't work, Calc checks if the input is a
13526 simple number; if so, the number is interpreted as a number of days
13527 since Jan 1, 1 AD. Otherwise, Calc tries a much more relaxed and
13528 flexible algorithm which is described in the next section.
13529
13530 Weekday names are ignored during reading.
13531
13532 Two-digit year numbers are interpreted as lying in the range
13533 from 1941 to 2039. Years outside that range are always
13534 entered and displayed in full. Year numbers with a leading
13535 @samp{+} sign are always interpreted exactly, allowing the
13536 entry and display of the years 1 through 99 AD.
13537
13538 Here is a complete list of the formatting codes for dates:
13539
13540 @table @asis
13541 @item Y
13542 Year: ``91'' for 1991, ``7'' for 2007, ``+23'' for 23 AD.
13543 @item YY
13544 Year: ``91'' for 1991, ``07'' for 2007, ``+23'' for 23 AD.
13545 @item BY
13546 Year: ``91'' for 1991, `` 7'' for 2007, ``+23'' for 23 AD.
13547 @item YYY
13548 Year: ``1991'' for 1991, ``23'' for 23 AD.
13549 @item YYYY
13550 Year: ``1991'' for 1991, ``+23'' for 23 AD.
13551 @item aa
13552 Year: ``ad'' or blank.
13553 @item AA
13554 Year: ``AD'' or blank.
13555 @item aaa
13556 Year: ``ad '' or blank. (Note trailing space.)
13557 @item AAA
13558 Year: ``AD '' or blank.
13559 @item aaaa
13560 Year: ``a.d.'' or blank.
13561 @item AAAA
13562 Year: ``A.D.'' or blank.
13563 @item bb
13564 Year: ``bc'' or blank.
13565 @item BB
13566 Year: ``BC'' or blank.
13567 @item bbb
13568 Year: `` bc'' or blank. (Note leading space.)
13569 @item BBB
13570 Year: `` BC'' or blank.
13571 @item bbbb
13572 Year: ``b.c.'' or blank.
13573 @item BBBB
13574 Year: ``B.C.'' or blank.
13575 @item M
13576 Month: ``8'' for August.
13577 @item MM
13578 Month: ``08'' for August.
13579 @item BM
13580 Month: `` 8'' for August.
13581 @item MMM
13582 Month: ``AUG'' for August.
13583 @item Mmm
13584 Month: ``Aug'' for August.
13585 @item mmm
13586 Month: ``aug'' for August.
13587 @item MMMM
13588 Month: ``AUGUST'' for August.
13589 @item Mmmm
13590 Month: ``August'' for August.
13591 @item D
13592 Day: ``7'' for 7th day of month.
13593 @item DD
13594 Day: ``07'' for 7th day of month.
13595 @item BD
13596 Day: `` 7'' for 7th day of month.
13597 @item W
13598 Weekday: ``0'' for Sunday, ``6'' for Saturday.
13599 @item WWW
13600 Weekday: ``SUN'' for Sunday.
13601 @item Www
13602 Weekday: ``Sun'' for Sunday.
13603 @item www
13604 Weekday: ``sun'' for Sunday.
13605 @item WWWW
13606 Weekday: ``SUNDAY'' for Sunday.
13607 @item Wwww
13608 Weekday: ``Sunday'' for Sunday.
13609 @item d
13610 Day of year: ``34'' for Feb. 3.
13611 @item ddd
13612 Day of year: ``034'' for Feb. 3.
13613 @item bdd
13614 Day of year: `` 34'' for Feb. 3.
13615 @item h
13616 Hour: ``5'' for 5 AM; ``17'' for 5 PM.
13617 @item hh
13618 Hour: ``05'' for 5 AM; ``17'' for 5 PM.
13619 @item bh
13620 Hour: `` 5'' for 5 AM; ``17'' for 5 PM.
13621 @item H
13622 Hour: ``5'' for 5 AM and 5 PM.
13623 @item HH
13624 Hour: ``05'' for 5 AM and 5 PM.
13625 @item BH
13626 Hour: `` 5'' for 5 AM and 5 PM.
13627 @item p
13628 AM/PM: ``a'' or ``p''.
13629 @item P
13630 AM/PM: ``A'' or ``P''.
13631 @item pp
13632 AM/PM: ``am'' or ``pm''.
13633 @item PP
13634 AM/PM: ``AM'' or ``PM''.
13635 @item pppp
13636 AM/PM: ``a.m.'' or ``p.m.''.
13637 @item PPPP
13638 AM/PM: ``A.M.'' or ``P.M.''.
13639 @item m
13640 Minutes: ``7'' for 7.
13641 @item mm
13642 Minutes: ``07'' for 7.
13643 @item bm
13644 Minutes: `` 7'' for 7.
13645 @item s
13646 Seconds: ``7'' for 7; ``7.23'' for 7.23.
13647 @item ss
13648 Seconds: ``07'' for 7; ``07.23'' for 7.23.
13649 @item bs
13650 Seconds: `` 7'' for 7; `` 7.23'' for 7.23.
13651 @item SS
13652 Optional seconds: ``07'' for 7; blank for 0.
13653 @item BS
13654 Optional seconds: `` 7'' for 7; blank for 0.
13655 @item N
13656 Numeric date/time: ``726842.25'' for 6:00am Wed Jan 9, 1991.
13657 @item n
13658 Numeric date: ``726842'' for any time on Wed Jan 9, 1991.
13659 @item J
13660 Julian date/time: ``2448265.75'' for 6:00am Wed Jan 9, 1991.
13661 @item j
13662 Julian date: ``2448266'' for any time on Wed Jan 9, 1991.
13663 @item U
13664 Unix time: ``663400800'' for 6:00am Wed Jan 9, 1991.
13665 @item X
13666 Brackets suppression. An ``X'' at the front of the format
13667 causes the surrounding @w{@samp{< >}} delimiters to be omitted
13668 when formatting dates. Note that the brackets are still
13669 required for algebraic entry.
13670 @end table
13671
13672 If ``SS'' or ``BS'' (optional seconds) is preceded by a colon, the
13673 colon is also omitted if the seconds part is zero.
13674
13675 If ``bb,'' ``bbb'' or ``bbbb'' or their upper-case equivalents
13676 appear in the format, then negative year numbers are displayed
13677 without a minus sign. Note that ``aa'' and ``bb'' are mutually
13678 exclusive. Some typical usages would be @samp{YYYY AABB};
13679 @samp{AAAYYYYBBB}; @samp{YYYYBBB}.
13680
13681 The formats ``YY,'' ``YYYY,'' ``MM,'' ``DD,'' ``ddd,'' ``hh,'' ``HH,''
13682 ``mm,'' ``ss,'' and ``SS'' actually match any number of digits during
13683 reading unless several of these codes are strung together with no
13684 punctuation in between, in which case the input must have exactly as
13685 many digits as there are letters in the format.
13686
13687 The ``j,'' ``J,'' and ``U'' formats do not make any time zone
13688 adjustment. They effectively use @samp{julian(x,0)} and
13689 @samp{unixtime(x,0)} to make the conversion; @pxref{Date Arithmetic}.
13690
13691 @node Free-Form Dates, Standard Date Formats, Date Formatting Codes, Date Formats
13692 @subsubsection Free-Form Dates
13693
13694 @noindent
13695 When reading a date form during algebraic entry, Calc falls back
13696 on the algorithm described here if the input does not exactly
13697 match the current date format. This algorithm generally
13698 ``does the right thing'' and you don't have to worry about it,
13699 but it is described here in full detail for the curious.
13700
13701 Calc does not distinguish between upper- and lower-case letters
13702 while interpreting dates.
13703
13704 First, the time portion, if present, is located somewhere in the
13705 text and then removed. The remaining text is then interpreted as
13706 the date.
13707
13708 A time is of the form @samp{hh:mm:ss}, possibly with the seconds
13709 part omitted and possibly with an AM/PM indicator added to indicate
13710 12-hour time. If the AM/PM is present, the minutes may also be
13711 omitted. The AM/PM part may be any of the words @samp{am},
13712 @samp{pm}, @samp{noon}, or @samp{midnight}; each of these may be
13713 abbreviated to one letter, and the alternate forms @samp{a.m.},
13714 @samp{p.m.}, and @samp{mid} are also understood. Obviously
13715 @samp{noon} and @samp{midnight} are allowed only on 12:00:00.
13716 The words @samp{noon}, @samp{mid}, and @samp{midnight} are also
13717 recognized with no number attached.
13718
13719 If there is no AM/PM indicator, the time is interpreted in 24-hour
13720 format.
13721
13722 To read the date portion, all words and numbers are isolated
13723 from the string; other characters are ignored. All words must
13724 be either month names or day-of-week names (the latter of which
13725 are ignored). Names can be written in full or as three-letter
13726 abbreviations.
13727
13728 Large numbers, or numbers with @samp{+} or @samp{-} signs,
13729 are interpreted as years. If one of the other numbers is
13730 greater than 12, then that must be the day and the remaining
13731 number in the input is therefore the month. Otherwise, Calc
13732 assumes the month, day and year are in the same order that they
13733 appear in the current date format. If the year is omitted, the
13734 current year is taken from the system clock.
13735
13736 If there are too many or too few numbers, or any unrecognizable
13737 words, then the input is rejected.
13738
13739 If there are any large numbers (of five digits or more) other than
13740 the year, they are ignored on the assumption that they are something
13741 like Julian dates that were included along with the traditional
13742 date components when the date was formatted.
13743
13744 One of the words @samp{ad}, @samp{a.d.}, @samp{bc}, or @samp{b.c.}
13745 may optionally be used; the latter two are equivalent to a
13746 minus sign on the year value.
13747
13748 If you always enter a four-digit year, and use a name instead
13749 of a number for the month, there is no danger of ambiguity.
13750
13751 @node Standard Date Formats, , Free-Form Dates, Date Formats
13752 @subsubsection Standard Date Formats
13753
13754 @noindent
13755 There are actually ten standard date formats, numbered 0 through 9.
13756 Entering a blank line at the @kbd{d d} command's prompt gives
13757 you format number 1, Calc's usual format. You can enter any digit
13758 to select the other formats.
13759
13760 To create your own standard date formats, give a numeric prefix
13761 argument from 0 to 9 to the @w{@kbd{d d}} command. The format you
13762 enter will be recorded as the new standard format of that
13763 number, as well as becoming the new current date format.
13764 You can save your formats permanently with the @w{@kbd{m m}}
13765 command (@pxref{Mode Settings}).
13766
13767 @table @asis
13768 @item 0
13769 @samp{N} (Numerical format)
13770 @item 1
13771 @samp{<H:mm:SSpp >Www Mmm D, YYYY} (American format)
13772 @item 2
13773 @samp{D Mmm YYYY<, h:mm:SS>} (European format)
13774 @item 3
13775 @samp{Www Mmm BD< hh:mm:ss> YYYY} (Unix written date format)
13776 @item 4
13777 @samp{M/D/Y< H:mm:SSpp>} (American slashed format)
13778 @item 5
13779 @samp{D.M.Y< h:mm:SS>} (European dotted format)
13780 @item 6
13781 @samp{M-D-Y< H:mm:SSpp>} (American dashed format)
13782 @item 7
13783 @samp{D-M-Y< h:mm:SS>} (European dashed format)
13784 @item 8
13785 @samp{j<, h:mm:ss>} (Julian day plus time)
13786 @item 9
13787 @samp{YYddd< hh:mm:ss>} (Year-day format)
13788 @end table
13789
13790 @node Truncating the Stack, Justification, Date Formats, Display Modes
13791 @subsection Truncating the Stack
13792
13793 @noindent
13794 @kindex d t
13795 @pindex calc-truncate-stack
13796 @cindex Truncating the stack
13797 @cindex Narrowing the stack
13798 The @kbd{d t} (@code{calc-truncate-stack}) command moves the @samp{.}@:
13799 line that marks the top-of-stack up or down in the Calculator buffer.
13800 The number right above that line is considered to the be at the top of
13801 the stack. Any numbers below that line are ``hidden'' from all stack
13802 operations. This is similar to the Emacs ``narrowing'' feature, except
13803 that the values below the @samp{.} are @emph{visible}, just temporarily
13804 frozen. This feature allows you to keep several independent calculations
13805 running at once in different parts of the stack, or to apply a certain
13806 command to an element buried deep in the stack.
13807
13808 Pressing @kbd{d t} by itself moves the @samp{.} to the line the cursor
13809 is on. Thus, this line and all those below it become hidden. To un-hide
13810 these lines, move down to the end of the buffer and press @w{@kbd{d t}}.
13811 With a positive numeric prefix argument @expr{n}, @kbd{d t} hides the
13812 bottom @expr{n} values in the buffer. With a negative argument, it hides
13813 all but the top @expr{n} values. With an argument of zero, it hides zero
13814 values, i.e., moves the @samp{.} all the way down to the bottom.
13815
13816 @kindex d [
13817 @pindex calc-truncate-up
13818 @kindex d ]
13819 @pindex calc-truncate-down
13820 The @kbd{d [} (@code{calc-truncate-up}) and @kbd{d ]}
13821 (@code{calc-truncate-down}) commands move the @samp{.} up or down one
13822 line at a time (or several lines with a prefix argument).
13823
13824 @node Justification, Labels, Truncating the Stack, Display Modes
13825 @subsection Justification
13826
13827 @noindent
13828 @kindex d <
13829 @pindex calc-left-justify
13830 @kindex d =
13831 @pindex calc-center-justify
13832 @kindex d >
13833 @pindex calc-right-justify
13834 Values on the stack are normally left-justified in the window. You can
13835 control this arrangement by typing @kbd{d <} (@code{calc-left-justify}),
13836 @kbd{d >} (@code{calc-right-justify}), or @kbd{d =}
13837 (@code{calc-center-justify}). For example, in Right-Justification mode,
13838 stack entries are displayed flush-right against the right edge of the
13839 window.
13840
13841 If you change the width of the Calculator window you may have to type
13842 @kbd{d @key{SPC}} (@code{calc-refresh}) to re-align right-justified or centered
13843 text.
13844
13845 Right-justification is especially useful together with fixed-point
13846 notation (see @code{d f}; @code{calc-fix-notation}). With these modes
13847 together, the decimal points on numbers will always line up.
13848
13849 With a numeric prefix argument, the justification commands give you
13850 a little extra control over the display. The argument specifies the
13851 horizontal ``origin'' of a display line. It is also possible to
13852 specify a maximum line width using the @kbd{d b} command (@pxref{Normal
13853 Language Modes}). For reference, the precise rules for formatting and
13854 breaking lines are given below. Notice that the interaction between
13855 origin and line width is slightly different in each justification
13856 mode.
13857
13858 In Left-Justified mode, the line is indented by a number of spaces
13859 given by the origin (default zero). If the result is longer than the
13860 maximum line width, if given, or too wide to fit in the Calc window
13861 otherwise, then it is broken into lines which will fit; each broken
13862 line is indented to the origin.
13863
13864 In Right-Justified mode, lines are shifted right so that the rightmost
13865 character is just before the origin, or just before the current
13866 window width if no origin was specified. If the line is too long
13867 for this, then it is broken; the current line width is used, if
13868 specified, or else the origin is used as a width if that is
13869 specified, or else the line is broken to fit in the window.
13870
13871 In Centering mode, the origin is the column number of the center of
13872 each stack entry. If a line width is specified, lines will not be
13873 allowed to go past that width; Calc will either indent less or
13874 break the lines if necessary. If no origin is specified, half the
13875 line width or Calc window width is used.
13876
13877 Note that, in each case, if line numbering is enabled the display
13878 is indented an additional four spaces to make room for the line
13879 number. The width of the line number is taken into account when
13880 positioning according to the current Calc window width, but not
13881 when positioning by explicit origins and widths. In the latter
13882 case, the display is formatted as specified, and then uniformly
13883 shifted over four spaces to fit the line numbers.
13884
13885 @node Labels, , Justification, Display Modes
13886 @subsection Labels
13887
13888 @noindent
13889 @kindex d @{
13890 @pindex calc-left-label
13891 The @kbd{d @{} (@code{calc-left-label}) command prompts for a string,
13892 then displays that string to the left of every stack entry. If the
13893 entries are left-justified (@pxref{Justification}), then they will
13894 appear immediately after the label (unless you specified an origin
13895 greater than the length of the label). If the entries are centered
13896 or right-justified, the label appears on the far left and does not
13897 affect the horizontal position of the stack entry.
13898
13899 Give a blank string (with @kbd{d @{ @key{RET}}) to turn the label off.
13900
13901 @kindex d @}
13902 @pindex calc-right-label
13903 The @kbd{d @}} (@code{calc-right-label}) command similarly adds a
13904 label on the righthand side. It does not affect positioning of
13905 the stack entries unless they are right-justified. Also, if both
13906 a line width and an origin are given in Right-Justified mode, the
13907 stack entry is justified to the origin and the righthand label is
13908 justified to the line width.
13909
13910 One application of labels would be to add equation numbers to
13911 formulas you are manipulating in Calc and then copying into a
13912 document (possibly using Embedded mode). The equations would
13913 typically be centered, and the equation numbers would be on the
13914 left or right as you prefer.
13915
13916 @node Language Modes, Modes Variable, Display Modes, Mode Settings
13917 @section Language Modes
13918
13919 @noindent
13920 The commands in this section change Calc to use a different notation for
13921 entry and display of formulas, corresponding to the conventions of some
13922 other common language such as Pascal or La@TeX{}. Objects displayed on the
13923 stack or yanked from the Calculator to an editing buffer will be formatted
13924 in the current language; objects entered in algebraic entry or yanked from
13925 another buffer will be interpreted according to the current language.
13926
13927 The current language has no effect on things written to or read from the
13928 trail buffer, nor does it affect numeric entry. Only algebraic entry is
13929 affected. You can make even algebraic entry ignore the current language
13930 and use the standard notation by giving a numeric prefix, e.g., @kbd{C-u '}.
13931
13932 For example, suppose the formula @samp{2*a[1] + atan(a[2])} occurs in a C
13933 program; elsewhere in the program you need the derivatives of this formula
13934 with respect to @samp{a[1]} and @samp{a[2]}. First, type @kbd{d C}
13935 to switch to C notation. Now use @code{C-u M-# g} to grab the formula
13936 into the Calculator, @kbd{a d a[1] @key{RET}} to differentiate with respect
13937 to the first variable, and @kbd{M-# y} to yank the formula for the derivative
13938 back into your C program. Press @kbd{U} to undo the differentiation and
13939 repeat with @kbd{a d a[2] @key{RET}} for the other derivative.
13940
13941 Without being switched into C mode first, Calc would have misinterpreted
13942 the brackets in @samp{a[1]} and @samp{a[2]}, would not have known that
13943 @code{atan} was equivalent to Calc's built-in @code{arctan} function,
13944 and would have written the formula back with notations (like implicit
13945 multiplication) which would not have been valid for a C program.
13946
13947 As another example, suppose you are maintaining a C program and a La@TeX{}
13948 document, each of which needs a copy of the same formula. You can grab the
13949 formula from the program in C mode, switch to La@TeX{} mode, and yank the
13950 formula into the document in La@TeX{} math-mode format.
13951
13952 Language modes are selected by typing the letter @kbd{d} followed by a
13953 shifted letter key.
13954
13955 @menu
13956 * Normal Language Modes::
13957 * C FORTRAN Pascal::
13958 * TeX and LaTeX Language Modes::
13959 * Eqn Language Mode::
13960 * Mathematica Language Mode::
13961 * Maple Language Mode::
13962 * Compositions::
13963 * Syntax Tables::
13964 @end menu
13965
13966 @node Normal Language Modes, C FORTRAN Pascal, Language Modes, Language Modes
13967 @subsection Normal Language Modes
13968
13969 @noindent
13970 @kindex d N
13971 @pindex calc-normal-language
13972 The @kbd{d N} (@code{calc-normal-language}) command selects the usual
13973 notation for Calc formulas, as described in the rest of this manual.
13974 Matrices are displayed in a multi-line tabular format, but all other
13975 objects are written in linear form, as they would be typed from the
13976 keyboard.
13977
13978 @kindex d O
13979 @pindex calc-flat-language
13980 @cindex Matrix display
13981 The @kbd{d O} (@code{calc-flat-language}) command selects a language
13982 identical with the normal one, except that matrices are written in
13983 one-line form along with everything else. In some applications this
13984 form may be more suitable for yanking data into other buffers.
13985
13986 @kindex d b
13987 @pindex calc-line-breaking
13988 @cindex Line breaking
13989 @cindex Breaking up long lines
13990 Even in one-line mode, long formulas or vectors will still be split
13991 across multiple lines if they exceed the width of the Calculator window.
13992 The @kbd{d b} (@code{calc-line-breaking}) command turns this line-breaking
13993 feature on and off. (It works independently of the current language.)
13994 If you give a numeric prefix argument of five or greater to the @kbd{d b}
13995 command, that argument will specify the line width used when breaking
13996 long lines.
13997
13998 @kindex d B
13999 @pindex calc-big-language
14000 The @kbd{d B} (@code{calc-big-language}) command selects a language
14001 which uses textual approximations to various mathematical notations,
14002 such as powers, quotients, and square roots:
14003
14004 @example
14005 ____________
14006 | a + 1 2
14007 | ----- + c
14008 \| b
14009 @end example
14010
14011 @noindent
14012 in place of @samp{sqrt((a+1)/b + c^2)}.
14013
14014 Subscripts like @samp{a_i} are displayed as actual subscripts in Big
14015 mode. Double subscripts, @samp{a_i_j} (@samp{subscr(subscr(a, i), j)})
14016 are displayed as @samp{a} with subscripts separated by commas:
14017 @samp{i, j}. They must still be entered in the usual underscore
14018 notation.
14019
14020 One slight ambiguity of Big notation is that
14021
14022 @example
14023 3
14024 - -
14025 4
14026 @end example
14027
14028 @noindent
14029 can represent either the negative rational number @expr{-3:4}, or the
14030 actual expression @samp{-(3/4)}; but the latter formula would normally
14031 never be displayed because it would immediately be evaluated to
14032 @expr{-3:4} or @expr{-0.75}, so this ambiguity is not a problem in
14033 typical use.
14034
14035 Non-decimal numbers are displayed with subscripts. Thus there is no
14036 way to tell the difference between @samp{16#C2} and @samp{C2_16},
14037 though generally you will know which interpretation is correct.
14038 Logarithms @samp{log(x,b)} and @samp{log10(x)} also use subscripts
14039 in Big mode.
14040
14041 In Big mode, stack entries often take up several lines. To aid
14042 readability, stack entries are separated by a blank line in this mode.
14043 You may find it useful to expand the Calc window's height using
14044 @kbd{C-x ^} (@code{enlarge-window}) or to make the Calc window the only
14045 one on the screen with @kbd{C-x 1} (@code{delete-other-windows}).
14046
14047 Long lines are currently not rearranged to fit the window width in
14048 Big mode, so you may need to use the @kbd{<} and @kbd{>} keys
14049 to scroll across a wide formula. For really big formulas, you may
14050 even need to use @kbd{@{} and @kbd{@}} to scroll up and down.
14051
14052 @kindex d U
14053 @pindex calc-unformatted-language
14054 The @kbd{d U} (@code{calc-unformatted-language}) command altogether disables
14055 the use of operator notation in formulas. In this mode, the formula
14056 shown above would be displayed:
14057
14058 @example
14059 sqrt(add(div(add(a, 1), b), pow(c, 2)))
14060 @end example
14061
14062 These four modes differ only in display format, not in the format
14063 expected for algebraic entry. The standard Calc operators work in
14064 all four modes, and unformatted notation works in any language mode
14065 (except that Mathematica mode expects square brackets instead of
14066 parentheses).
14067
14068 @node C FORTRAN Pascal, TeX and LaTeX Language Modes, Normal Language Modes, Language Modes
14069 @subsection C, FORTRAN, and Pascal Modes
14070
14071 @noindent
14072 @kindex d C
14073 @pindex calc-c-language
14074 @cindex C language
14075 The @kbd{d C} (@code{calc-c-language}) command selects the conventions
14076 of the C language for display and entry of formulas. This differs from
14077 the normal language mode in a variety of (mostly minor) ways. In
14078 particular, C language operators and operator precedences are used in
14079 place of Calc's usual ones. For example, @samp{a^b} means @samp{xor(a,b)}
14080 in C mode; a value raised to a power is written as a function call,
14081 @samp{pow(a,b)}.
14082
14083 In C mode, vectors and matrices use curly braces instead of brackets.
14084 Octal and hexadecimal values are written with leading @samp{0} or @samp{0x}
14085 rather than using the @samp{#} symbol. Array subscripting is
14086 translated into @code{subscr} calls, so that @samp{a[i]} in C
14087 mode is the same as @samp{a_i} in Normal mode. Assignments
14088 turn into the @code{assign} function, which Calc normally displays
14089 using the @samp{:=} symbol.
14090
14091 The variables @code{pi} and @code{e} would be displayed @samp{pi}
14092 and @samp{e} in Normal mode, but in C mode they are displayed as
14093 @samp{M_PI} and @samp{M_E}, corresponding to the names of constants
14094 typically provided in the @file{<math.h>} header. Functions whose
14095 names are different in C are translated automatically for entry and
14096 display purposes. For example, entering @samp{asin(x)} will push the
14097 formula @samp{arcsin(x)} onto the stack; this formula will be displayed
14098 as @samp{asin(x)} as long as C mode is in effect.
14099
14100 @kindex d P
14101 @pindex calc-pascal-language
14102 @cindex Pascal language
14103 The @kbd{d P} (@code{calc-pascal-language}) command selects Pascal
14104 conventions. Like C mode, Pascal mode interprets array brackets and uses
14105 a different table of operators. Hexadecimal numbers are entered and
14106 displayed with a preceding dollar sign. (Thus the regular meaning of
14107 @kbd{$2} during algebraic entry does not work in Pascal mode, though
14108 @kbd{$} (and @kbd{$$}, etc.) not followed by digits works the same as
14109 always.) No special provisions are made for other non-decimal numbers,
14110 vectors, and so on, since there is no universally accepted standard way
14111 of handling these in Pascal.
14112
14113 @kindex d F
14114 @pindex calc-fortran-language
14115 @cindex FORTRAN language
14116 The @kbd{d F} (@code{calc-fortran-language}) command selects FORTRAN
14117 conventions. Various function names are transformed into FORTRAN
14118 equivalents. Vectors are written as @samp{/1, 2, 3/}, and may be
14119 entered this way or using square brackets. Since FORTRAN uses round
14120 parentheses for both function calls and array subscripts, Calc displays
14121 both in the same way; @samp{a(i)} is interpreted as a function call
14122 upon reading, and subscripts must be entered as @samp{subscr(a, i)}.
14123 Also, if the variable @code{a} has been declared to have type
14124 @code{vector} or @code{matrix} then @samp{a(i)} will be parsed as a
14125 subscript. (@xref{Declarations}.) Usually it doesn't matter, though;
14126 if you enter the subscript expression @samp{a(i)} and Calc interprets
14127 it as a function call, you'll never know the difference unless you
14128 switch to another language mode or replace @code{a} with an actual
14129 vector (or unless @code{a} happens to be the name of a built-in
14130 function!).
14131
14132 Underscores are allowed in variable and function names in all of these
14133 language modes. The underscore here is equivalent to the @samp{#} in
14134 Normal mode, or to hyphens in the underlying Emacs Lisp variable names.
14135
14136 FORTRAN and Pascal modes normally do not adjust the case of letters in
14137 formulas. Most built-in Calc names use lower-case letters. If you use a
14138 positive numeric prefix argument with @kbd{d P} or @kbd{d F}, these
14139 modes will use upper-case letters exclusively for display, and will
14140 convert to lower-case on input. With a negative prefix, these modes
14141 convert to lower-case for display and input.
14142
14143 @node TeX and LaTeX Language Modes, Eqn Language Mode, C FORTRAN Pascal, Language Modes
14144 @subsection @TeX{} and La@TeX{} Language Modes
14145
14146 @noindent
14147 @kindex d T
14148 @pindex calc-tex-language
14149 @cindex TeX language
14150 @kindex d L
14151 @pindex calc-latex-language
14152 @cindex LaTeX language
14153 The @kbd{d T} (@code{calc-tex-language}) command selects the conventions
14154 of ``math mode'' in Donald Knuth's @TeX{} typesetting language,
14155 and the @kbd{d L} (@code{calc-latex-language}) command selects the
14156 conventions of ``math mode'' in La@TeX{}, a typesetting language that
14157 uses @TeX{} as its formatting engine. Calc's La@TeX{} language mode can
14158 read any formula that the @TeX{} language mode can, although La@TeX{}
14159 mode may display it differently.
14160
14161 Formulas are entered and displayed in the appropriate notation;
14162 @texline @math{\sin(a/b)}
14163 @infoline @expr{sin(a/b)}
14164 will appear as @samp{\sin\left( a \over b \right)} in @TeX{} mode and
14165 @samp{\sin\left(\frac@{a@}@{b@}\right)} in La@TeX{} mode.
14166 Math formulas are often enclosed by @samp{$ $} signs in @TeX{} and
14167 La@TeX{}; these should be omitted when interfacing with Calc. To Calc,
14168 the @samp{$} sign has the same meaning it always does in algebraic
14169 formulas (a reference to an existing entry on the stack).
14170
14171 Complex numbers are displayed as in @samp{3 + 4i}. Fractions and
14172 quotients are written using @code{\over} in @TeX{} mode (as in
14173 @code{@{a \over b@}}) and @code{\frac} in La@TeX{} mode (as in
14174 @code{\frac@{a@}@{b@}}); binomial coefficients are written with
14175 @code{\choose} in @TeX{} mode (as in @code{@{a \choose b@}}) and
14176 @code{\binom} in La@TeX{} mode (as in @code{\binom@{a@}@{b@}}).
14177 Interval forms are written with @code{\ldots}, and error forms are
14178 written with @code{\pm}. Absolute values are written as in
14179 @samp{|x + 1|}, and the floor and ceiling functions are written with
14180 @code{\lfloor}, @code{\rfloor}, etc. The words @code{\left} and
14181 @code{\right} are ignored when reading formulas in @TeX{} and La@TeX{}
14182 modes. Both @code{inf} and @code{uinf} are written as @code{\infty};
14183 when read, @code{\infty} always translates to @code{inf}.
14184
14185 Function calls are written the usual way, with the function name followed
14186 by the arguments in parentheses. However, functions for which @TeX{}
14187 and La@TeX{} have special names (like @code{\sin}) will use curly braces
14188 instead of parentheses for very simple arguments. During input, curly
14189 braces and parentheses work equally well for grouping, but when the
14190 document is formatted the curly braces will be invisible. Thus the
14191 printed result is
14192 @texline @math{\sin{2 x}}
14193 @infoline @expr{sin 2x}
14194 but
14195 @texline @math{\sin(2 + x)}.
14196 @infoline @expr{sin(2 + x)}.
14197
14198 Function and variable names not treated specially by @TeX{} and La@TeX{}
14199 are simply written out as-is, which will cause them to come out in
14200 italic letters in the printed document. If you invoke @kbd{d T} or
14201 @kbd{d L} with a positive numeric prefix argument, names of more than
14202 one character will instead be enclosed in a protective commands that
14203 will prevent them from being typeset in the math italics; they will be
14204 written @samp{\hbox@{@var{name}@}} in @TeX{} mode and
14205 @samp{\text@{@var{name}@}} in La@TeX{} mode. The
14206 @samp{\hbox@{ @}} and @samp{\text@{ @}} notations are ignored during
14207 reading. If you use a negative prefix argument, such function names are
14208 written @samp{\@var{name}}, and function names that begin with @code{\} during
14209 reading have the @code{\} removed. (Note that in this mode, long
14210 variable names are still written with @code{\hbox} or @code{\text}.
14211 However, you can always make an actual variable name like @code{\bar} in
14212 any @TeX{} mode.)
14213
14214 During reading, text of the form @samp{\matrix@{ ...@: @}} is replaced
14215 by @samp{[ ...@: ]}. The same also applies to @code{\pmatrix} and
14216 @code{\bmatrix}. In La@TeX{} mode this also applies to
14217 @samp{\begin@{matrix@} ... \end@{matrix@}},
14218 @samp{\begin@{bmatrix@} ... \end@{bmatrix@}},
14219 @samp{\begin@{pmatrix@} ... \end@{pmatrix@}}, as well as
14220 @samp{\begin@{smallmatrix@} ... \end@{smallmatrix@}}.
14221 The symbol @samp{&} is interpreted as a comma,
14222 and the symbols @samp{\cr} and @samp{\\} are interpreted as semicolons.
14223 During output, matrices are displayed in @samp{\matrix@{ a & b \\ c & d@}}
14224 format in @TeX{} mode and in
14225 @samp{\begin@{pmatrix@} a & b \\ c & d \end@{pmatrix@}} format in
14226 La@TeX{} mode; you may need to edit this afterwards to change to your
14227 preferred matrix form. If you invoke @kbd{d T} or @kbd{d L} with an
14228 argument of 2 or -2, then matrices will be displayed in two-dimensional
14229 form, such as
14230
14231 @example
14232 \begin@{pmatrix@}
14233 a & b \\
14234 c & d
14235 \end@{pmatrix@}
14236 @end example
14237
14238 @noindent
14239 This may be convenient for isolated matrices, but could lead to
14240 expressions being displayed like
14241
14242 @example
14243 \begin@{pmatrix@} \times x
14244 a & b \\
14245 c & d
14246 \end@{pmatrix@}
14247 @end example
14248
14249 @noindent
14250 While this wouldn't bother Calc, it is incorrect La@TeX{}.
14251 (Similarly for @TeX{}.)
14252
14253 Accents like @code{\tilde} and @code{\bar} translate into function
14254 calls internally (@samp{tilde(x)}, @samp{bar(x)}). The @code{\underline}
14255 sequence is treated as an accent. The @code{\vec} accent corresponds
14256 to the function name @code{Vec}, because @code{vec} is the name of
14257 a built-in Calc function. The following table shows the accents
14258 in Calc, @TeX{}, La@TeX{} and @dfn{eqn} (described in the next section):
14259
14260 @iftex
14261 @begingroup
14262 @let@calcindexershow=@calcindexernoshow @c Suppress marginal notes
14263 @let@calcindexersh=@calcindexernoshow
14264 @end iftex
14265 @ignore
14266 @starindex
14267 @end ignore
14268 @tindex acute
14269 @ignore
14270 @starindex
14271 @end ignore
14272 @tindex Acute
14273 @ignore
14274 @starindex
14275 @end ignore
14276 @tindex bar
14277 @ignore
14278 @starindex
14279 @end ignore
14280 @tindex Bar
14281 @ignore
14282 @starindex
14283 @end ignore
14284 @tindex breve
14285 @ignore
14286 @starindex
14287 @end ignore
14288 @tindex Breve
14289 @ignore
14290 @starindex
14291 @end ignore
14292 @tindex check
14293 @ignore
14294 @starindex
14295 @end ignore
14296 @tindex Check
14297 @ignore
14298 @starindex
14299 @end ignore
14300 @tindex dddot
14301 @ignore
14302 @starindex
14303 @end ignore
14304 @tindex ddddot
14305 @ignore
14306 @starindex
14307 @end ignore
14308 @tindex dot
14309 @ignore
14310 @starindex
14311 @end ignore
14312 @tindex Dot
14313 @ignore
14314 @starindex
14315 @end ignore
14316 @tindex dotdot
14317 @ignore
14318 @starindex
14319 @end ignore
14320 @tindex DotDot
14321 @ignore
14322 @starindex
14323 @end ignore
14324 @tindex dyad
14325 @ignore
14326 @starindex
14327 @end ignore
14328 @tindex grave
14329 @ignore
14330 @starindex
14331 @end ignore
14332 @tindex Grave
14333 @ignore
14334 @starindex
14335 @end ignore
14336 @tindex hat
14337 @ignore
14338 @starindex
14339 @end ignore
14340 @tindex Hat
14341 @ignore
14342 @starindex
14343 @end ignore
14344 @tindex Prime
14345 @ignore
14346 @starindex
14347 @end ignore
14348 @tindex tilde
14349 @ignore
14350 @starindex
14351 @end ignore
14352 @tindex Tilde
14353 @ignore
14354 @starindex
14355 @end ignore
14356 @tindex under
14357 @ignore
14358 @starindex
14359 @end ignore
14360 @tindex Vec
14361 @ignore
14362 @starindex
14363 @end ignore
14364 @tindex VEC
14365 @iftex
14366 @endgroup
14367 @end iftex
14368 @example
14369 Calc TeX LaTeX eqn
14370 ---- --- ----- ---
14371 acute \acute \acute
14372 Acute \Acute
14373 bar \bar \bar bar
14374 Bar \Bar
14375 breve \breve \breve
14376 Breve \Breve
14377 check \check \check
14378 Check \Check
14379 dddot \dddot
14380 ddddot \ddddot
14381 dot \dot \dot dot
14382 Dot \Dot
14383 dotdot \ddot \ddot dotdot
14384 DotDot \Ddot
14385 dyad dyad
14386 grave \grave \grave
14387 Grave \Grave
14388 hat \hat \hat hat
14389 Hat \Hat
14390 Prime prime
14391 tilde \tilde \tilde tilde
14392 Tilde \Tilde
14393 under \underline \underline under
14394 Vec \vec \vec vec
14395 VEC \Vec
14396 @end example
14397
14398 The @samp{=>} (evaluates-to) operator appears as a @code{\to} symbol:
14399 @samp{@{@var{a} \to @var{b}@}}. @TeX{} defines @code{\to} as an
14400 alias for @code{\rightarrow}. However, if the @samp{=>} is the
14401 top-level expression being formatted, a slightly different notation
14402 is used: @samp{\evalto @var{a} \to @var{b}}. The @code{\evalto}
14403 word is ignored by Calc's input routines, and is undefined in @TeX{}.
14404 You will typically want to include one of the following definitions
14405 at the top of a @TeX{} file that uses @code{\evalto}:
14406
14407 @example
14408 \def\evalto@{@}
14409 \def\evalto#1\to@{@}
14410 @end example
14411
14412 The first definition formats evaluates-to operators in the usual
14413 way. The second causes only the @var{b} part to appear in the
14414 printed document; the @var{a} part and the arrow are hidden.
14415 Another definition you may wish to use is @samp{\let\to=\Rightarrow}
14416 which causes @code{\to} to appear more like Calc's @samp{=>} symbol.
14417 @xref{Evaluates-To Operator}, for a discussion of @code{evalto}.
14418
14419 The complete set of @TeX{} control sequences that are ignored during
14420 reading is:
14421
14422 @example
14423 \hbox \mbox \text \left \right
14424 \, \> \: \; \! \quad \qquad \hfil \hfill
14425 \displaystyle \textstyle \dsize \tsize
14426 \scriptstyle \scriptscriptstyle \ssize \ssize
14427 \rm \bf \it \sl \roman \bold \italic \slanted
14428 \cal \mit \Cal \Bbb \frak \goth
14429 \evalto
14430 @end example
14431
14432 Note that, because these symbols are ignored, reading a @TeX{} or
14433 La@TeX{} formula into Calc and writing it back out may lose spacing and
14434 font information.
14435
14436 Also, the ``discretionary multiplication sign'' @samp{\*} is read
14437 the same as @samp{*}.
14438
14439 @ifinfo
14440 The @TeX{} version of this manual includes some printed examples at the
14441 end of this section.
14442 @end ifinfo
14443 @iftex
14444 Here are some examples of how various Calc formulas are formatted in @TeX{}:
14445
14446 @example
14447 @group
14448 sin(a^2 / b_i)
14449 \sin\left( {a^2 \over b_i} \right)
14450 @end group
14451 @end example
14452 @tex
14453 $$ \sin\left( a^2 \over b_i \right) $$
14454 @end tex
14455 @sp 1
14456
14457 @example
14458 @group
14459 [(3, 4), 3:4, 3 +/- 4, [3 .. inf)]
14460 [3 + 4i, @{3 \over 4@}, 3 \pm 4, [3 \ldots \infty)]
14461 @end group
14462 @end example
14463 @tex
14464 \turnoffactive
14465 $$ [3 + 4i, {3 \over 4}, 3 \pm 4, [ 3 \ldots \infty)] $$
14466 @end tex
14467 @sp 1
14468
14469 @example
14470 @group
14471 [abs(a), abs(a / b), floor(a), ceil(a / b)]
14472 [|a|, \left| a \over b \right|,
14473 \lfloor a \rfloor, \left\lceil a \over b \right\rceil]
14474 @end group
14475 @end example
14476 @tex
14477 $$ [|a|, \left| a \over b \right|,
14478 \lfloor a \rfloor, \left\lceil a \over b \right\rceil] $$
14479 @end tex
14480 @sp 1
14481
14482 @example
14483 @group
14484 [sin(a), sin(2 a), sin(2 + a), sin(a / b)]
14485 [\sin@{a@}, \sin@{2 a@}, \sin(2 + a),
14486 \sin\left( @{a \over b@} \right)]
14487 @end group
14488 @end example
14489 @tex
14490 \turnoffactive
14491 $$ [\sin{a}, \sin{2 a}, \sin(2 + a), \sin\left( {a \over b} \right)] $$
14492 @end tex
14493 @sp 2
14494
14495 First with plain @kbd{d T}, then with @kbd{C-u d T}, then finally with
14496 @kbd{C-u - d T} (using the example definition
14497 @samp{\def\foo#1@{\tilde F(#1)@}}:
14498
14499 @example
14500 @group
14501 [f(a), foo(bar), sin(pi)]
14502 [f(a), foo(bar), \sin{\pi}]
14503 [f(a), \hbox@{foo@}(\hbox@{bar@}), \sin@{\pi@}]
14504 [f(a), \foo@{\hbox@{bar@}@}, \sin@{\pi@}]
14505 @end group
14506 @end example
14507 @tex
14508 $$ [f(a), foo(bar), \sin{\pi}] $$
14509 $$ [f(a), \hbox{foo}(\hbox{bar}), \sin{\pi}] $$
14510 $$ [f(a), \tilde F(\hbox{bar}), \sin{\pi}] $$
14511 @end tex
14512 @sp 2
14513
14514 First with @samp{\def\evalto@{@}}, then with @samp{\def\evalto#1\to@{@}}:
14515
14516 @example
14517 @group
14518 2 + 3 => 5
14519 \evalto 2 + 3 \to 5
14520 @end group
14521 @end example
14522 @tex
14523 \turnoffactive
14524 $$ 2 + 3 \to 5 $$
14525 $$ 5 $$
14526 @end tex
14527 @sp 2
14528
14529 First with standard @code{\to}, then with @samp{\let\to\Rightarrow}:
14530
14531 @example
14532 @group
14533 [2 + 3 => 5, a / 2 => (b + c) / 2]
14534 [@{2 + 3 \to 5@}, @{@{a \over 2@} \to @{b + c \over 2@}@}]
14535 @end group
14536 @end example
14537 @tex
14538 \turnoffactive
14539 $$ [{2 + 3 \to 5}, {{a \over 2} \to {b + c \over 2}}] $$
14540 {\let\to\Rightarrow
14541 $$ [{2 + 3 \to 5}, {{a \over 2} \to {b + c \over 2}}] $$}
14542 @end tex
14543 @sp 2
14544
14545 Matrices normally, then changing @code{\matrix} to @code{\pmatrix}:
14546
14547 @example
14548 @group
14549 [ [ a / b, 0 ], [ 0, 2^(x + 1) ] ]
14550 \matrix@{ @{a \over b@} & 0 \\ 0 & 2^@{(x + 1)@} @}
14551 \pmatrix@{ @{a \over b@} & 0 \\ 0 & 2^@{(x + 1)@} @}
14552 @end group
14553 @end example
14554 @tex
14555 \turnoffactive
14556 $$ \matrix{ {a \over b} & 0 \cr 0 & 2^{(x + 1)} } $$
14557 $$ \pmatrix{ {a \over b} & 0 \cr 0 & 2^{(x + 1)} } $$
14558 @end tex
14559 @sp 2
14560 @end iftex
14561
14562 @node Eqn Language Mode, Mathematica Language Mode, TeX and LaTeX Language Modes, Language Modes
14563 @subsection Eqn Language Mode
14564
14565 @noindent
14566 @kindex d E
14567 @pindex calc-eqn-language
14568 @dfn{Eqn} is another popular formatter for math formulas. It is
14569 designed for use with the TROFF text formatter, and comes standard
14570 with many versions of Unix. The @kbd{d E} (@code{calc-eqn-language})
14571 command selects @dfn{eqn} notation.
14572
14573 The @dfn{eqn} language's main idiosyncrasy is that whitespace plays
14574 a significant part in the parsing of the language. For example,
14575 @samp{sqrt x+1 + y} treats @samp{x+1} as the argument of the
14576 @code{sqrt} operator. @dfn{Eqn} also understands more conventional
14577 grouping using curly braces: @samp{sqrt@{x+1@} + y}. Braces are
14578 required only when the argument contains spaces.
14579
14580 In Calc's @dfn{eqn} mode, however, curly braces are required to
14581 delimit arguments of operators like @code{sqrt}. The first of the
14582 above examples would treat only the @samp{x} as the argument of
14583 @code{sqrt}, and in fact @samp{sin x+1} would be interpreted as
14584 @samp{sin * x + 1}, because @code{sin} is not a special operator
14585 in the @dfn{eqn} language. If you always surround the argument
14586 with curly braces, Calc will never misunderstand.
14587
14588 Calc also understands parentheses as grouping characters. Another
14589 peculiarity of @dfn{eqn}'s syntax makes it advisable to separate
14590 words with spaces from any surrounding characters that aren't curly
14591 braces, so Calc writes @samp{sin ( x + y )} in @dfn{eqn} mode.
14592 (The spaces around @code{sin} are important to make @dfn{eqn}
14593 recognize that @code{sin} should be typeset in a roman font, and
14594 the spaces around @code{x} and @code{y} are a good idea just in
14595 case the @dfn{eqn} document has defined special meanings for these
14596 names, too.)
14597
14598 Powers and subscripts are written with the @code{sub} and @code{sup}
14599 operators, respectively. Note that the caret symbol @samp{^} is
14600 treated the same as a space in @dfn{eqn} mode, as is the @samp{~}
14601 symbol (these are used to introduce spaces of various widths into
14602 the typeset output of @dfn{eqn}).
14603
14604 As in La@TeX{} mode, Calc's formatter omits parentheses around the
14605 arguments of functions like @code{ln} and @code{sin} if they are
14606 ``simple-looking''; in this case Calc surrounds the argument with
14607 braces, separated by a @samp{~} from the function name: @samp{sin~@{x@}}.
14608
14609 Font change codes (like @samp{roman @var{x}}) and positioning codes
14610 (like @samp{~} and @samp{down @var{n} @var{x}}) are ignored by the
14611 @dfn{eqn} reader. Also ignored are the words @code{left}, @code{right},
14612 @code{mark}, and @code{lineup}. Quotation marks in @dfn{eqn} mode input
14613 are treated the same as curly braces: @samp{sqrt "1+x"} is equivalent to
14614 @samp{sqrt @{1+x@}}; this is only an approximation to the true meaning
14615 of quotes in @dfn{eqn}, but it is good enough for most uses.
14616
14617 Accent codes (@samp{@var{x} dot}) are handled by treating them as
14618 function calls (@samp{dot(@var{x})}) internally.
14619 @xref{TeX and LaTeX Language Modes}, for a table of these accent
14620 functions. The @code{prime} accent is treated specially if it occurs on
14621 a variable or function name: @samp{f prime prime @w{( x prime )}} is
14622 stored internally as @samp{f'@w{'}(x')}. For example, taking the
14623 derivative of @samp{f(2 x)} with @kbd{a d x} will produce @samp{2 f'(2
14624 x)}, which @dfn{eqn} mode will display as @samp{2 f prime ( 2 x )}.
14625
14626 Assignments are written with the @samp{<-} (left-arrow) symbol,
14627 and @code{evalto} operators are written with @samp{->} or
14628 @samp{evalto ... ->} (@pxref{TeX and LaTeX Language Modes}, for a discussion
14629 of this). The regular Calc symbols @samp{:=} and @samp{=>} are also
14630 recognized for these operators during reading.
14631
14632 Vectors in @dfn{eqn} mode use regular Calc square brackets, but
14633 matrices are formatted as @samp{matrix @{ ccol @{ a above b @} ... @}}.
14634 The words @code{lcol} and @code{rcol} are recognized as synonyms
14635 for @code{ccol} during input, and are generated instead of @code{ccol}
14636 if the matrix justification mode so specifies.
14637
14638 @node Mathematica Language Mode, Maple Language Mode, Eqn Language Mode, Language Modes
14639 @subsection Mathematica Language Mode
14640
14641 @noindent
14642 @kindex d M
14643 @pindex calc-mathematica-language
14644 @cindex Mathematica language
14645 The @kbd{d M} (@code{calc-mathematica-language}) command selects the
14646 conventions of Mathematica. Notable differences in Mathematica mode
14647 are that the names of built-in functions are capitalized, and function
14648 calls use square brackets instead of parentheses. Thus the Calc
14649 formula @samp{sin(2 x)} is entered and displayed @w{@samp{Sin[2 x]}} in
14650 Mathematica mode.
14651
14652 Vectors and matrices use curly braces in Mathematica. Complex numbers
14653 are written @samp{3 + 4 I}. The standard special constants in Calc are
14654 written @code{Pi}, @code{E}, @code{I}, @code{GoldenRatio}, @code{EulerGamma},
14655 @code{Infinity}, @code{ComplexInfinity}, and @code{Indeterminate} in
14656 Mathematica mode.
14657 Non-decimal numbers are written, e.g., @samp{16^^7fff}. Floating-point
14658 numbers in scientific notation are written @samp{1.23*10.^3}.
14659 Subscripts use double square brackets: @samp{a[[i]]}.
14660
14661 @node Maple Language Mode, Compositions, Mathematica Language Mode, Language Modes
14662 @subsection Maple Language Mode
14663
14664 @noindent
14665 @kindex d W
14666 @pindex calc-maple-language
14667 @cindex Maple language
14668 The @kbd{d W} (@code{calc-maple-language}) command selects the
14669 conventions of Maple.
14670
14671 Maple's language is much like C. Underscores are allowed in symbol
14672 names; square brackets are used for subscripts; explicit @samp{*}s for
14673 multiplications are required. Use either @samp{^} or @samp{**} to
14674 denote powers.
14675
14676 Maple uses square brackets for lists and curly braces for sets. Calc
14677 interprets both notations as vectors, and displays vectors with square
14678 brackets. This means Maple sets will be converted to lists when they
14679 pass through Calc. As a special case, matrices are written as calls
14680 to the function @code{matrix}, given a list of lists as the argument,
14681 and can be read in this form or with all-capitals @code{MATRIX}.
14682
14683 The Maple interval notation @samp{2 .. 3} has no surrounding brackets;
14684 Calc reads @samp{2 .. 3} as the closed interval @samp{[2 .. 3]}, and
14685 writes any kind of interval as @samp{2 .. 3}. This means you cannot
14686 see the difference between an open and a closed interval while in
14687 Maple display mode.
14688
14689 Maple writes complex numbers as @samp{3 + 4*I}. Its special constants
14690 are @code{Pi}, @code{E}, @code{I}, and @code{infinity} (all three of
14691 @code{inf}, @code{uinf}, and @code{nan} display as @code{infinity}).
14692 Floating-point numbers are written @samp{1.23*10.^3}.
14693
14694 Among things not currently handled by Calc's Maple mode are the
14695 various quote symbols, procedures and functional operators, and
14696 inert (@samp{&}) operators.
14697
14698 @node Compositions, Syntax Tables, Maple Language Mode, Language Modes
14699 @subsection Compositions
14700
14701 @noindent
14702 @cindex Compositions
14703 There are several @dfn{composition functions} which allow you to get
14704 displays in a variety of formats similar to those in Big language
14705 mode. Most of these functions do not evaluate to anything; they are
14706 placeholders which are left in symbolic form by Calc's evaluator but
14707 are recognized by Calc's display formatting routines.
14708
14709 Two of these, @code{string} and @code{bstring}, are described elsewhere.
14710 @xref{Strings}. For example, @samp{string("ABC")} is displayed as
14711 @samp{ABC}. When viewed on the stack it will be indistinguishable from
14712 the variable @code{ABC}, but internally it will be stored as
14713 @samp{string([65, 66, 67])} and can still be manipulated this way; for
14714 example, the selection and vector commands @kbd{j 1 v v j u} would
14715 select the vector portion of this object and reverse the elements, then
14716 deselect to reveal a string whose characters had been reversed.
14717
14718 The composition functions do the same thing in all language modes
14719 (although their components will of course be formatted in the current
14720 language mode). The one exception is Unformatted mode (@kbd{d U}),
14721 which does not give the composition functions any special treatment.
14722 The functions are discussed here because of their relationship to
14723 the language modes.
14724
14725 @menu
14726 * Composition Basics::
14727 * Horizontal Compositions::
14728 * Vertical Compositions::
14729 * Other Compositions::
14730 * Information about Compositions::
14731 * User-Defined Compositions::
14732 @end menu
14733
14734 @node Composition Basics, Horizontal Compositions, Compositions, Compositions
14735 @subsubsection Composition Basics
14736
14737 @noindent
14738 Compositions are generally formed by stacking formulas together
14739 horizontally or vertically in various ways. Those formulas are
14740 themselves compositions. @TeX{} users will find this analogous
14741 to @TeX{}'s ``boxes.'' Each multi-line composition has a
14742 @dfn{baseline}; horizontal compositions use the baselines to
14743 decide how formulas should be positioned relative to one another.
14744 For example, in the Big mode formula
14745
14746 @example
14747 @group
14748 2
14749 a + b
14750 17 + ------
14751 c
14752 @end group
14753 @end example
14754
14755 @noindent
14756 the second term of the sum is four lines tall and has line three as
14757 its baseline. Thus when the term is combined with 17, line three
14758 is placed on the same level as the baseline of 17.
14759
14760 @tex
14761 \bigskip
14762 @end tex
14763
14764 Another important composition concept is @dfn{precedence}. This is
14765 an integer that represents the binding strength of various operators.
14766 For example, @samp{*} has higher precedence (195) than @samp{+} (180),
14767 which means that @samp{(a * b) + c} will be formatted without the
14768 parentheses, but @samp{a * (b + c)} will keep the parentheses.
14769
14770 The operator table used by normal and Big language modes has the
14771 following precedences:
14772
14773 @example
14774 _ 1200 @r{(subscripts)}
14775 % 1100 @r{(as in n}%@r{)}
14776 - 1000 @r{(as in }-@r{n)}
14777 ! 1000 @r{(as in }!@r{n)}
14778 mod 400
14779 +/- 300
14780 !! 210 @r{(as in n}!!@r{)}
14781 ! 210 @r{(as in n}!@r{)}
14782 ^ 200
14783 * 195 @r{(or implicit multiplication)}
14784 / % \ 190
14785 + - 180 @r{(as in a}+@r{b)}
14786 | 170
14787 < = 160 @r{(and other relations)}
14788 && 110
14789 || 100
14790 ? : 90
14791 !!! 85
14792 &&& 80
14793 ||| 75
14794 := 50
14795 :: 45
14796 => 40
14797 @end example
14798
14799 The general rule is that if an operator with precedence @expr{n}
14800 occurs as an argument to an operator with precedence @expr{m}, then
14801 the argument is enclosed in parentheses if @expr{n < m}. Top-level
14802 expressions and expressions which are function arguments, vector
14803 components, etc., are formatted with precedence zero (so that they
14804 normally never get additional parentheses).
14805
14806 For binary left-associative operators like @samp{+}, the righthand
14807 argument is actually formatted with one-higher precedence than shown
14808 in the table. This makes sure @samp{(a + b) + c} omits the parentheses,
14809 but the unnatural form @samp{a + (b + c)} keeps its parentheses.
14810 Right-associative operators like @samp{^} format the lefthand argument
14811 with one-higher precedence.
14812
14813 @ignore
14814 @starindex
14815 @end ignore
14816 @tindex cprec
14817 The @code{cprec} function formats an expression with an arbitrary
14818 precedence. For example, @samp{cprec(abc, 185)} will combine into
14819 sums and products as follows: @samp{7 + abc}, @samp{7 (abc)} (because
14820 this @code{cprec} form has higher precedence than addition, but lower
14821 precedence than multiplication).
14822
14823 @tex
14824 \bigskip
14825 @end tex
14826
14827 A final composition issue is @dfn{line breaking}. Calc uses two
14828 different strategies for ``flat'' and ``non-flat'' compositions.
14829 A non-flat composition is anything that appears on multiple lines
14830 (not counting line breaking). Examples would be matrices and Big
14831 mode powers and quotients. Non-flat compositions are displayed
14832 exactly as specified. If they come out wider than the current
14833 window, you must use horizontal scrolling (@kbd{<} and @kbd{>}) to
14834 view them.
14835
14836 Flat compositions, on the other hand, will be broken across several
14837 lines if they are too wide to fit the window. Certain points in a
14838 composition are noted internally as @dfn{break points}. Calc's
14839 general strategy is to fill each line as much as possible, then to
14840 move down to the next line starting at the first break point that
14841 didn't fit. However, the line breaker understands the hierarchical
14842 structure of formulas. It will not break an ``inner'' formula if
14843 it can use an earlier break point from an ``outer'' formula instead.
14844 For example, a vector of sums might be formatted as:
14845
14846 @example
14847 @group
14848 [ a + b + c, d + e + f,
14849 g + h + i, j + k + l, m ]
14850 @end group
14851 @end example
14852
14853 @noindent
14854 If the @samp{m} can fit, then so, it seems, could the @samp{g}.
14855 But Calc prefers to break at the comma since the comma is part
14856 of a ``more outer'' formula. Calc would break at a plus sign
14857 only if it had to, say, if the very first sum in the vector had
14858 itself been too large to fit.
14859
14860 Of the composition functions described below, only @code{choriz}
14861 generates break points. The @code{bstring} function (@pxref{Strings})
14862 also generates breakable items: A break point is added after every
14863 space (or group of spaces) except for spaces at the very beginning or
14864 end of the string.
14865
14866 Composition functions themselves count as levels in the formula
14867 hierarchy, so a @code{choriz} that is a component of a larger
14868 @code{choriz} will be less likely to be broken. As a special case,
14869 if a @code{bstring} occurs as a component of a @code{choriz} or
14870 @code{choriz}-like object (such as a vector or a list of arguments
14871 in a function call), then the break points in that @code{bstring}
14872 will be on the same level as the break points of the surrounding
14873 object.
14874
14875 @node Horizontal Compositions, Vertical Compositions, Composition Basics, Compositions
14876 @subsubsection Horizontal Compositions
14877
14878 @noindent
14879 @ignore
14880 @starindex
14881 @end ignore
14882 @tindex choriz
14883 The @code{choriz} function takes a vector of objects and composes
14884 them horizontally. For example, @samp{choriz([17, a b/c, d])} formats
14885 as @w{@samp{17a b / cd}} in Normal language mode, or as
14886
14887 @example
14888 @group
14889 a b
14890 17---d
14891 c
14892 @end group
14893 @end example
14894
14895 @noindent
14896 in Big language mode. This is actually one case of the general
14897 function @samp{choriz(@var{vec}, @var{sep}, @var{prec})}, where
14898 either or both of @var{sep} and @var{prec} may be omitted.
14899 @var{Prec} gives the @dfn{precedence} to use when formatting
14900 each of the components of @var{vec}. The default precedence is
14901 the precedence from the surrounding environment.
14902
14903 @var{Sep} is a string (i.e., a vector of character codes as might
14904 be entered with @code{" "} notation) which should separate components
14905 of the composition. Also, if @var{sep} is given, the line breaker
14906 will allow lines to be broken after each occurrence of @var{sep}.
14907 If @var{sep} is omitted, the composition will not be breakable
14908 (unless any of its component compositions are breakable).
14909
14910 For example, @samp{2 choriz([a, b c, d = e], " + ", 180)} is
14911 formatted as @samp{2 a + b c + (d = e)}. To get the @code{choriz}
14912 to have precedence 180 ``outwards'' as well as ``inwards,''
14913 enclose it in a @code{cprec} form: @samp{2 cprec(choriz(...), 180)}
14914 formats as @samp{2 (a + b c + (d = e))}.
14915
14916 The baseline of a horizontal composition is the same as the
14917 baselines of the component compositions, which are all aligned.
14918
14919 @node Vertical Compositions, Other Compositions, Horizontal Compositions, Compositions
14920 @subsubsection Vertical Compositions
14921
14922 @noindent
14923 @ignore
14924 @starindex
14925 @end ignore
14926 @tindex cvert
14927 The @code{cvert} function makes a vertical composition. Each
14928 component of the vector is centered in a column. The baseline of
14929 the result is by default the top line of the resulting composition.
14930 For example, @samp{f(cvert([a, bb, ccc]), cvert([a^2 + 1, b^2]))}
14931 formats in Big mode as
14932
14933 @example
14934 @group
14935 f( a , 2 )
14936 bb a + 1
14937 ccc 2
14938 b
14939 @end group
14940 @end example
14941
14942 @ignore
14943 @starindex
14944 @end ignore
14945 @tindex cbase
14946 There are several special composition functions that work only as
14947 components of a vertical composition. The @code{cbase} function
14948 controls the baseline of the vertical composition; the baseline
14949 will be the same as the baseline of whatever component is enclosed
14950 in @code{cbase}. Thus @samp{f(cvert([a, cbase(bb), ccc]),
14951 cvert([a^2 + 1, cbase(b^2)]))} displays as
14952
14953 @example
14954 @group
14955 2
14956 a + 1
14957 a 2
14958 f(bb , b )
14959 ccc
14960 @end group
14961 @end example
14962
14963 @ignore
14964 @starindex
14965 @end ignore
14966 @tindex ctbase
14967 @ignore
14968 @starindex
14969 @end ignore
14970 @tindex cbbase
14971 There are also @code{ctbase} and @code{cbbase} functions which
14972 make the baseline of the vertical composition equal to the top
14973 or bottom line (rather than the baseline) of that component.
14974 Thus @samp{cvert([cbase(a / b)]) + cvert([ctbase(a / b)]) +
14975 cvert([cbbase(a / b)])} gives
14976
14977 @example
14978 @group
14979 a
14980 a -
14981 - + a + b
14982 b -
14983 b
14984 @end group
14985 @end example
14986
14987 There should be only one @code{cbase}, @code{ctbase}, or @code{cbbase}
14988 function in a given vertical composition. These functions can also
14989 be written with no arguments: @samp{ctbase()} is a zero-height object
14990 which means the baseline is the top line of the following item, and
14991 @samp{cbbase()} means the baseline is the bottom line of the preceding
14992 item.
14993
14994 @ignore
14995 @starindex
14996 @end ignore
14997 @tindex crule
14998 The @code{crule} function builds a ``rule,'' or horizontal line,
14999 across a vertical composition. By itself @samp{crule()} uses @samp{-}
15000 characters to build the rule. You can specify any other character,
15001 e.g., @samp{crule("=")}. The argument must be a character code or
15002 vector of exactly one character code. It is repeated to match the
15003 width of the widest item in the stack. For example, a quotient
15004 with a thick line is @samp{cvert([a + 1, cbase(crule("=")), b^2])}:
15005
15006 @example
15007 @group
15008 a + 1
15009 =====
15010 2
15011 b
15012 @end group
15013 @end example
15014
15015 @ignore
15016 @starindex
15017 @end ignore
15018 @tindex clvert
15019 @ignore
15020 @starindex
15021 @end ignore
15022 @tindex crvert
15023 Finally, the functions @code{clvert} and @code{crvert} act exactly
15024 like @code{cvert} except that the items are left- or right-justified
15025 in the stack. Thus @samp{clvert([a, bb, ccc]) + crvert([a, bb, ccc])}
15026 gives:
15027
15028 @example
15029 @group
15030 a + a
15031 bb bb
15032 ccc ccc
15033 @end group
15034 @end example
15035
15036 Like @code{choriz}, the vertical compositions accept a second argument
15037 which gives the precedence to use when formatting the components.
15038 Vertical compositions do not support separator strings.
15039
15040 @node Other Compositions, Information about Compositions, Vertical Compositions, Compositions
15041 @subsubsection Other Compositions
15042
15043 @noindent
15044 @ignore
15045 @starindex
15046 @end ignore
15047 @tindex csup
15048 The @code{csup} function builds a superscripted expression. For
15049 example, @samp{csup(a, b)} looks the same as @samp{a^b} does in Big
15050 language mode. This is essentially a horizontal composition of
15051 @samp{a} and @samp{b}, where @samp{b} is shifted up so that its
15052 bottom line is one above the baseline.
15053
15054 @ignore
15055 @starindex
15056 @end ignore
15057 @tindex csub
15058 Likewise, the @code{csub} function builds a subscripted expression.
15059 This shifts @samp{b} down so that its top line is one below the
15060 bottom line of @samp{a} (note that this is not quite analogous to
15061 @code{csup}). Other arrangements can be obtained by using
15062 @code{choriz} and @code{cvert} directly.
15063
15064 @ignore
15065 @starindex
15066 @end ignore
15067 @tindex cflat
15068 The @code{cflat} function formats its argument in ``flat'' mode,
15069 as obtained by @samp{d O}, if the current language mode is normal
15070 or Big. It has no effect in other language modes. For example,
15071 @samp{a^(b/c)} is formatted by Big mode like @samp{csup(a, cflat(b/c))}
15072 to improve its readability.
15073
15074 @ignore
15075 @starindex
15076 @end ignore
15077 @tindex cspace
15078 The @code{cspace} function creates horizontal space. For example,
15079 @samp{cspace(4)} is effectively the same as @samp{string(" ")}.
15080 A second string (i.e., vector of characters) argument is repeated
15081 instead of the space character. For example, @samp{cspace(4, "ab")}
15082 looks like @samp{abababab}. If the second argument is not a string,
15083 it is formatted in the normal way and then several copies of that
15084 are composed together: @samp{cspace(4, a^2)} yields
15085
15086 @example
15087 @group
15088 2 2 2 2
15089 a a a a
15090 @end group
15091 @end example
15092
15093 @noindent
15094 If the number argument is zero, this is a zero-width object.
15095
15096 @ignore
15097 @starindex
15098 @end ignore
15099 @tindex cvspace
15100 The @code{cvspace} function creates vertical space, or a vertical
15101 stack of copies of a certain string or formatted object. The
15102 baseline is the center line of the resulting stack. A numerical
15103 argument of zero will produce an object which contributes zero
15104 height if used in a vertical composition.
15105
15106 @ignore
15107 @starindex
15108 @end ignore
15109 @tindex ctspace
15110 @ignore
15111 @starindex
15112 @end ignore
15113 @tindex cbspace
15114 There are also @code{ctspace} and @code{cbspace} functions which
15115 create vertical space with the baseline the same as the baseline
15116 of the top or bottom copy, respectively, of the second argument.
15117 Thus @samp{cvspace(2, a/b) + ctspace(2, a/b) + cbspace(2, a/b)}
15118 displays as:
15119
15120 @example
15121 @group
15122 a
15123 -
15124 a b
15125 - a a
15126 b + - + -
15127 a b b
15128 - a
15129 b -
15130 b
15131 @end group
15132 @end example
15133
15134 @node Information about Compositions, User-Defined Compositions, Other Compositions, Compositions
15135 @subsubsection Information about Compositions
15136
15137 @noindent
15138 The functions in this section are actual functions; they compose their
15139 arguments according to the current language and other display modes,
15140 then return a certain measurement of the composition as an integer.
15141
15142 @ignore
15143 @starindex
15144 @end ignore
15145 @tindex cwidth
15146 The @code{cwidth} function measures the width, in characters, of a
15147 composition. For example, @samp{cwidth(a + b)} is 5, and
15148 @samp{cwidth(a / b)} is 5 in Normal mode, 1 in Big mode, and 11 in
15149 @TeX{} mode (for @samp{@{a \over b@}}). The argument may involve
15150 the composition functions described in this section.
15151
15152 @ignore
15153 @starindex
15154 @end ignore
15155 @tindex cheight
15156 The @code{cheight} function measures the height of a composition.
15157 This is the total number of lines in the argument's printed form.
15158
15159 @ignore
15160 @starindex
15161 @end ignore
15162 @tindex cascent
15163 @ignore
15164 @starindex
15165 @end ignore
15166 @tindex cdescent
15167 The functions @code{cascent} and @code{cdescent} measure the amount
15168 of the height that is above (and including) the baseline, or below
15169 the baseline, respectively. Thus @samp{cascent(@var{x}) + cdescent(@var{x})}
15170 always equals @samp{cheight(@var{x})}. For a one-line formula like
15171 @samp{a + b}, @code{cascent} returns 1 and @code{cdescent} returns 0.
15172 For @samp{a / b} in Big mode, @code{cascent} returns 2 and @code{cdescent}
15173 returns 1. The only formula for which @code{cascent} will return zero
15174 is @samp{cvspace(0)} or equivalents.
15175
15176 @node User-Defined Compositions, , Information about Compositions, Compositions
15177 @subsubsection User-Defined Compositions
15178
15179 @noindent
15180 @kindex Z C
15181 @pindex calc-user-define-composition
15182 The @kbd{Z C} (@code{calc-user-define-composition}) command lets you
15183 define the display format for any algebraic function. You provide a
15184 formula containing a certain number of argument variables on the stack.
15185 Any time Calc formats a call to the specified function in the current
15186 language mode and with that number of arguments, Calc effectively
15187 replaces the function call with that formula with the arguments
15188 replaced.
15189
15190 Calc builds the default argument list by sorting all the variable names
15191 that appear in the formula into alphabetical order. You can edit this
15192 argument list before pressing @key{RET} if you wish. Any variables in
15193 the formula that do not appear in the argument list will be displayed
15194 literally; any arguments that do not appear in the formula will not
15195 affect the display at all.
15196
15197 You can define formats for built-in functions, for functions you have
15198 defined with @kbd{Z F} (@pxref{Algebraic Definitions}), or for functions
15199 which have no definitions but are being used as purely syntactic objects.
15200 You can define different formats for each language mode, and for each
15201 number of arguments, using a succession of @kbd{Z C} commands. When
15202 Calc formats a function call, it first searches for a format defined
15203 for the current language mode (and number of arguments); if there is
15204 none, it uses the format defined for the Normal language mode. If
15205 neither format exists, Calc uses its built-in standard format for that
15206 function (usually just @samp{@var{func}(@var{args})}).
15207
15208 If you execute @kbd{Z C} with the number 0 on the stack instead of a
15209 formula, any defined formats for the function in the current language
15210 mode will be removed. The function will revert to its standard format.
15211
15212 For example, the default format for the binomial coefficient function
15213 @samp{choose(n, m)} in the Big language mode is
15214
15215 @example
15216 @group
15217 n
15218 ( )
15219 m
15220 @end group
15221 @end example
15222
15223 @noindent
15224 You might prefer the notation,
15225
15226 @example
15227 @group
15228 C
15229 n m
15230 @end group
15231 @end example
15232
15233 @noindent
15234 To define this notation, first make sure you are in Big mode,
15235 then put the formula
15236
15237 @smallexample
15238 choriz([cvert([cvspace(1), n]), C, cvert([cvspace(1), m])])
15239 @end smallexample
15240
15241 @noindent
15242 on the stack and type @kbd{Z C}. Answer the first prompt with
15243 @code{choose}. The second prompt will be the default argument list
15244 of @samp{(C m n)}. Edit this list to be @samp{(n m)} and press
15245 @key{RET}. Now, try it out: For example, turn simplification
15246 off with @kbd{m O} and enter @samp{choose(a,b) + choose(7,3)}
15247 as an algebraic entry.
15248
15249 @example
15250 @group
15251 C + C
15252 a b 7 3
15253 @end group
15254 @end example
15255
15256 As another example, let's define the usual notation for Stirling
15257 numbers of the first kind, @samp{stir1(n, m)}. This is just like
15258 the regular format for binomial coefficients but with square brackets
15259 instead of parentheses.
15260
15261 @smallexample
15262 choriz([string("["), cvert([n, cbase(cvspace(1)), m]), string("]")])
15263 @end smallexample
15264
15265 Now type @kbd{Z C stir1 @key{RET}}, edit the argument list to
15266 @samp{(n m)}, and type @key{RET}.
15267
15268 The formula provided to @kbd{Z C} usually will involve composition
15269 functions, but it doesn't have to. Putting the formula @samp{a + b + c}
15270 onto the stack and typing @kbd{Z C foo @key{RET} @key{RET}} would define
15271 the function @samp{foo(x,y,z)} to display like @samp{x + y + z}.
15272 This ``sum'' will act exactly like a real sum for all formatting
15273 purposes (it will be parenthesized the same, and so on). However
15274 it will be computationally unrelated to a sum. For example, the
15275 formula @samp{2 * foo(1, 2, 3)} will display as @samp{2 (1 + 2 + 3)}.
15276 Operator precedences have caused the ``sum'' to be written in
15277 parentheses, but the arguments have not actually been summed.
15278 (Generally a display format like this would be undesirable, since
15279 it can easily be confused with a real sum.)
15280
15281 The special function @code{eval} can be used inside a @kbd{Z C}
15282 composition formula to cause all or part of the formula to be
15283 evaluated at display time. For example, if the formula is
15284 @samp{a + eval(b + c)}, then @samp{foo(1, 2, 3)} will be displayed
15285 as @samp{1 + 5}. Evaluation will use the default simplifications,
15286 regardless of the current simplification mode. There are also
15287 @code{evalsimp} and @code{evalextsimp} which simplify as if by
15288 @kbd{a s} and @kbd{a e} (respectively). Note that these ``functions''
15289 operate only in the context of composition formulas (and also in
15290 rewrite rules, where they serve a similar purpose; @pxref{Rewrite
15291 Rules}). On the stack, a call to @code{eval} will be left in
15292 symbolic form.
15293
15294 It is not a good idea to use @code{eval} except as a last resort.
15295 It can cause the display of formulas to be extremely slow. For
15296 example, while @samp{eval(a + b)} might seem quite fast and simple,
15297 there are several situations where it could be slow. For example,
15298 @samp{a} and/or @samp{b} could be polar complex numbers, in which
15299 case doing the sum requires trigonometry. Or, @samp{a} could be
15300 the factorial @samp{fact(100)} which is unevaluated because you
15301 have typed @kbd{m O}; @code{eval} will evaluate it anyway to
15302 produce a large, unwieldy integer.
15303
15304 You can save your display formats permanently using the @kbd{Z P}
15305 command (@pxref{Creating User Keys}).
15306
15307 @node Syntax Tables, , Compositions, Language Modes
15308 @subsection Syntax Tables
15309
15310 @noindent
15311 @cindex Syntax tables
15312 @cindex Parsing formulas, customized
15313 Syntax tables do for input what compositions do for output: They
15314 allow you to teach custom notations to Calc's formula parser.
15315 Calc keeps a separate syntax table for each language mode.
15316
15317 (Note that the Calc ``syntax tables'' discussed here are completely
15318 unrelated to the syntax tables described in the Emacs manual.)
15319
15320 @kindex Z S
15321 @pindex calc-edit-user-syntax
15322 The @kbd{Z S} (@code{calc-edit-user-syntax}) command edits the
15323 syntax table for the current language mode. If you want your
15324 syntax to work in any language, define it in the Normal language
15325 mode. Type @kbd{C-c C-c} to finish editing the syntax table, or
15326 @kbd{C-x k} to cancel the edit. The @kbd{m m} command saves all
15327 the syntax tables along with the other mode settings;
15328 @pxref{General Mode Commands}.
15329
15330 @menu
15331 * Syntax Table Basics::
15332 * Precedence in Syntax Tables::
15333 * Advanced Syntax Patterns::
15334 * Conditional Syntax Rules::
15335 @end menu
15336
15337 @node Syntax Table Basics, Precedence in Syntax Tables, Syntax Tables, Syntax Tables
15338 @subsubsection Syntax Table Basics
15339
15340 @noindent
15341 @dfn{Parsing} is the process of converting a raw string of characters,
15342 such as you would type in during algebraic entry, into a Calc formula.
15343 Calc's parser works in two stages. First, the input is broken down
15344 into @dfn{tokens}, such as words, numbers, and punctuation symbols
15345 like @samp{+}, @samp{:=}, and @samp{+/-}. Space between tokens is
15346 ignored (except when it serves to separate adjacent words). Next,
15347 the parser matches this string of tokens against various built-in
15348 syntactic patterns, such as ``an expression followed by @samp{+}
15349 followed by another expression'' or ``a name followed by @samp{(},
15350 zero or more expressions separated by commas, and @samp{)}.''
15351
15352 A @dfn{syntax table} is a list of user-defined @dfn{syntax rules},
15353 which allow you to specify new patterns to define your own
15354 favorite input notations. Calc's parser always checks the syntax
15355 table for the current language mode, then the table for the Normal
15356 language mode, before it uses its built-in rules to parse an
15357 algebraic formula you have entered. Each syntax rule should go on
15358 its own line; it consists of a @dfn{pattern}, a @samp{:=} symbol,
15359 and a Calc formula with an optional @dfn{condition}. (Syntax rules
15360 resemble algebraic rewrite rules, but the notation for patterns is
15361 completely different.)
15362
15363 A syntax pattern is a list of tokens, separated by spaces.
15364 Except for a few special symbols, tokens in syntax patterns are
15365 matched literally, from left to right. For example, the rule,
15366
15367 @example
15368 foo ( ) := 2+3
15369 @end example
15370
15371 @noindent
15372 would cause Calc to parse the formula @samp{4+foo()*5} as if it
15373 were @samp{4+(2+3)*5}. Notice that the parentheses were written
15374 as two separate tokens in the rule. As a result, the rule works
15375 for both @samp{foo()} and @w{@samp{foo ( )}}. If we had written
15376 the rule as @samp{foo () := 2+3}, then Calc would treat @samp{()}
15377 as a single, indivisible token, so that @w{@samp{foo( )}} would
15378 not be recognized by the rule. (It would be parsed as a regular
15379 zero-argument function call instead.) In fact, this rule would
15380 also make trouble for the rest of Calc's parser: An unrelated
15381 formula like @samp{bar()} would now be tokenized into @samp{bar ()}
15382 instead of @samp{bar ( )}, so that the standard parser for function
15383 calls would no longer recognize it!
15384
15385 While it is possible to make a token with a mixture of letters
15386 and punctuation symbols, this is not recommended. It is better to
15387 break it into several tokens, as we did with @samp{foo()} above.
15388
15389 The symbol @samp{#} in a syntax pattern matches any Calc expression.
15390 On the righthand side, the things that matched the @samp{#}s can
15391 be referred to as @samp{#1}, @samp{#2}, and so on (where @samp{#1}
15392 matches the leftmost @samp{#} in the pattern). For example, these
15393 rules match a user-defined function, prefix operator, infix operator,
15394 and postfix operator, respectively:
15395
15396 @example
15397 foo ( # ) := myfunc(#1)
15398 foo # := myprefix(#1)
15399 # foo # := myinfix(#1,#2)
15400 # foo := mypostfix(#1)
15401 @end example
15402
15403 Thus @samp{foo(3)} will parse as @samp{myfunc(3)}, and @samp{2+3 foo}
15404 will parse as @samp{mypostfix(2+3)}.
15405
15406 It is important to write the first two rules in the order shown,
15407 because Calc tries rules in order from first to last. If the
15408 pattern @samp{foo #} came first, it would match anything that could
15409 match the @samp{foo ( # )} rule, since an expression in parentheses
15410 is itself a valid expression. Thus the @w{@samp{foo ( # )}} rule would
15411 never get to match anything. Likewise, the last two rules must be
15412 written in the order shown or else @samp{3 foo 4} will be parsed as
15413 @samp{mypostfix(3) * 4}. (Of course, the best way to avoid these
15414 ambiguities is not to use the same symbol in more than one way at
15415 the same time! In case you're not convinced, try the following
15416 exercise: How will the above rules parse the input @samp{foo(3,4)},
15417 if at all? Work it out for yourself, then try it in Calc and see.)
15418
15419 Calc is quite flexible about what sorts of patterns are allowed.
15420 The only rule is that every pattern must begin with a literal
15421 token (like @samp{foo} in the first two patterns above), or with
15422 a @samp{#} followed by a literal token (as in the last two
15423 patterns). After that, any mixture is allowed, although putting
15424 two @samp{#}s in a row will not be very useful since two
15425 expressions with nothing between them will be parsed as one
15426 expression that uses implicit multiplication.
15427
15428 As a more practical example, Maple uses the notation
15429 @samp{sum(a(i), i=1..10)} for sums, which Calc's Maple mode doesn't
15430 recognize at present. To handle this syntax, we simply add the
15431 rule,
15432
15433 @example
15434 sum ( # , # = # .. # ) := sum(#1,#2,#3,#4)
15435 @end example
15436
15437 @noindent
15438 to the Maple mode syntax table. As another example, C mode can't
15439 read assignment operators like @samp{++} and @samp{*=}. We can
15440 define these operators quite easily:
15441
15442 @example
15443 # *= # := muleq(#1,#2)
15444 # ++ := postinc(#1)
15445 ++ # := preinc(#1)
15446 @end example
15447
15448 @noindent
15449 To complete the job, we would use corresponding composition functions
15450 and @kbd{Z C} to cause these functions to display in their respective
15451 Maple and C notations. (Note that the C example ignores issues of
15452 operator precedence, which are discussed in the next section.)
15453
15454 You can enclose any token in quotes to prevent its usual
15455 interpretation in syntax patterns:
15456
15457 @example
15458 # ":=" # := becomes(#1,#2)
15459 @end example
15460
15461 Quotes also allow you to include spaces in a token, although once
15462 again it is generally better to use two tokens than one token with
15463 an embedded space. To include an actual quotation mark in a quoted
15464 token, precede it with a backslash. (This also works to include
15465 backslashes in tokens.)
15466
15467 @example
15468 # "bad token" # "/\"\\" # := silly(#1,#2,#3)
15469 @end example
15470
15471 @noindent
15472 This will parse @samp{3 bad token 4 /"\ 5} to @samp{silly(3,4,5)}.
15473
15474 The token @kbd{#} has a predefined meaning in Calc's formula parser;
15475 it is not valid to use @samp{"#"} in a syntax rule. However, longer
15476 tokens that include the @samp{#} character are allowed. Also, while
15477 @samp{"$"} and @samp{"\""} are allowed as tokens, their presence in
15478 the syntax table will prevent those characters from working in their
15479 usual ways (referring to stack entries and quoting strings,
15480 respectively).
15481
15482 Finally, the notation @samp{%%} anywhere in a syntax table causes
15483 the rest of the line to be ignored as a comment.
15484
15485 @node Precedence in Syntax Tables, Advanced Syntax Patterns, Syntax Table Basics, Syntax Tables
15486 @subsubsection Precedence
15487
15488 @noindent
15489 Different operators are generally assigned different @dfn{precedences}.
15490 By default, an operator defined by a rule like
15491
15492 @example
15493 # foo # := foo(#1,#2)
15494 @end example
15495
15496 @noindent
15497 will have an extremely low precedence, so that @samp{2*3+4 foo 5 == 6}
15498 will be parsed as @samp{(2*3+4) foo (5 == 6)}. To change the
15499 precedence of an operator, use the notation @samp{#/@var{p}} in
15500 place of @samp{#}, where @var{p} is an integer precedence level.
15501 For example, 185 lies between the precedences for @samp{+} and
15502 @samp{*}, so if we change this rule to
15503
15504 @example
15505 #/185 foo #/186 := foo(#1,#2)
15506 @end example
15507
15508 @noindent
15509 then @samp{2+3 foo 4*5} will be parsed as @samp{2+(3 foo (4*5))}.
15510 Also, because we've given the righthand expression slightly higher
15511 precedence, our new operator will be left-associative:
15512 @samp{1 foo 2 foo 3} will be parsed as @samp{(1 foo 2) foo 3}.
15513 By raising the precedence of the lefthand expression instead, we
15514 can create a right-associative operator.
15515
15516 @xref{Composition Basics}, for a table of precedences of the
15517 standard Calc operators. For the precedences of operators in other
15518 language modes, look in the Calc source file @file{calc-lang.el}.
15519
15520 @node Advanced Syntax Patterns, Conditional Syntax Rules, Precedence in Syntax Tables, Syntax Tables
15521 @subsubsection Advanced Syntax Patterns
15522
15523 @noindent
15524 To match a function with a variable number of arguments, you could
15525 write
15526
15527 @example
15528 foo ( # ) := myfunc(#1)
15529 foo ( # , # ) := myfunc(#1,#2)
15530 foo ( # , # , # ) := myfunc(#1,#2,#3)
15531 @end example
15532
15533 @noindent
15534 but this isn't very elegant. To match variable numbers of items,
15535 Calc uses some notations inspired regular expressions and the
15536 ``extended BNF'' style used by some language designers.
15537
15538 @example
15539 foo ( @{ # @}*, ) := apply(myfunc,#1)
15540 @end example
15541
15542 The token @samp{@{} introduces a repeated or optional portion.
15543 One of the three tokens @samp{@}*}, @samp{@}+}, or @samp{@}?}
15544 ends the portion. These will match zero or more, one or more,
15545 or zero or one copies of the enclosed pattern, respectively.
15546 In addition, @samp{@}*} and @samp{@}+} can be followed by a
15547 separator token (with no space in between, as shown above).
15548 Thus @samp{@{ # @}*,} matches nothing, or one expression, or
15549 several expressions separated by commas.
15550
15551 A complete @samp{@{ ... @}} item matches as a vector of the
15552 items that matched inside it. For example, the above rule will
15553 match @samp{foo(1,2,3)} to get @samp{apply(myfunc,[1,2,3])}.
15554 The Calc @code{apply} function takes a function name and a vector
15555 of arguments and builds a call to the function with those
15556 arguments, so the net result is the formula @samp{myfunc(1,2,3)}.
15557
15558 If the body of a @samp{@{ ... @}} contains several @samp{#}s
15559 (or nested @samp{@{ ... @}} constructs), then the items will be
15560 strung together into the resulting vector. If the body
15561 does not contain anything but literal tokens, the result will
15562 always be an empty vector.
15563
15564 @example
15565 foo ( @{ # , # @}+, ) := bar(#1)
15566 foo ( @{ @{ # @}*, @}*; ) := matrix(#1)
15567 @end example
15568
15569 @noindent
15570 will parse @samp{foo(1, 2, 3, 4)} as @samp{bar([1, 2, 3, 4])}, and
15571 @samp{foo(1, 2; 3, 4)} as @samp{matrix([[1, 2], [3, 4]])}. Also, after
15572 some thought it's easy to see how this pair of rules will parse
15573 @samp{foo(1, 2, 3)} as @samp{matrix([[1, 2, 3]])}, since the first
15574 rule will only match an even number of arguments. The rule
15575
15576 @example
15577 foo ( # @{ , # , # @}? ) := bar(#1,#2)
15578 @end example
15579
15580 @noindent
15581 will parse @samp{foo(2,3,4)} as @samp{bar(2,[3,4])}, and
15582 @samp{foo(2)} as @samp{bar(2,[])}.
15583
15584 The notation @samp{@{ ... @}?.} (note the trailing period) works
15585 just the same as regular @samp{@{ ... @}?}, except that it does not
15586 count as an argument; the following two rules are equivalent:
15587
15588 @example
15589 foo ( # , @{ also @}? # ) := bar(#1,#3)
15590 foo ( # , @{ also @}?. # ) := bar(#1,#2)
15591 @end example
15592
15593 @noindent
15594 Note that in the first case the optional text counts as @samp{#2},
15595 which will always be an empty vector, but in the second case no
15596 empty vector is produced.
15597
15598 Another variant is @samp{@{ ... @}?$}, which means the body is
15599 optional only at the end of the input formula. All built-in syntax
15600 rules in Calc use this for closing delimiters, so that during
15601 algebraic entry you can type @kbd{[sqrt(2), sqrt(3 @key{RET}}, omitting
15602 the closing parenthesis and bracket. Calc does this automatically
15603 for trailing @samp{)}, @samp{]}, and @samp{>} tokens in syntax
15604 rules, but you can use @samp{@{ ... @}?$} explicitly to get
15605 this effect with any token (such as @samp{"@}"} or @samp{end}).
15606 Like @samp{@{ ... @}?.}, this notation does not count as an
15607 argument. Conversely, you can use quotes, as in @samp{")"}, to
15608 prevent a closing-delimiter token from being automatically treated
15609 as optional.
15610
15611 Calc's parser does not have full backtracking, which means some
15612 patterns will not work as you might expect:
15613
15614 @example
15615 foo ( @{ # , @}? # , # ) := bar(#1,#2,#3)
15616 @end example
15617
15618 @noindent
15619 Here we are trying to make the first argument optional, so that
15620 @samp{foo(2,3)} parses as @samp{bar([],2,3)}. Unfortunately, Calc
15621 first tries to match @samp{2,} against the optional part of the
15622 pattern, finds a match, and so goes ahead to match the rest of the
15623 pattern. Later on it will fail to match the second comma, but it
15624 doesn't know how to go back and try the other alternative at that
15625 point. One way to get around this would be to use two rules:
15626
15627 @example
15628 foo ( # , # , # ) := bar([#1],#2,#3)
15629 foo ( # , # ) := bar([],#1,#2)
15630 @end example
15631
15632 More precisely, when Calc wants to match an optional or repeated
15633 part of a pattern, it scans forward attempting to match that part.
15634 If it reaches the end of the optional part without failing, it
15635 ``finalizes'' its choice and proceeds. If it fails, though, it
15636 backs up and tries the other alternative. Thus Calc has ``partial''
15637 backtracking. A fully backtracking parser would go on to make sure
15638 the rest of the pattern matched before finalizing the choice.
15639
15640 @node Conditional Syntax Rules, , Advanced Syntax Patterns, Syntax Tables
15641 @subsubsection Conditional Syntax Rules
15642
15643 @noindent
15644 It is possible to attach a @dfn{condition} to a syntax rule. For
15645 example, the rules
15646
15647 @example
15648 foo ( # ) := ifoo(#1) :: integer(#1)
15649 foo ( # ) := gfoo(#1)
15650 @end example
15651
15652 @noindent
15653 will parse @samp{foo(3)} as @samp{ifoo(3)}, but will parse
15654 @samp{foo(3.5)} and @samp{foo(x)} as calls to @code{gfoo}. Any
15655 number of conditions may be attached; all must be true for the
15656 rule to succeed. A condition is ``true'' if it evaluates to a
15657 nonzero number. @xref{Logical Operations}, for a list of Calc
15658 functions like @code{integer} that perform logical tests.
15659
15660 The exact sequence of events is as follows: When Calc tries a
15661 rule, it first matches the pattern as usual. It then substitutes
15662 @samp{#1}, @samp{#2}, etc., in the conditions, if any. Next, the
15663 conditions are simplified and evaluated in order from left to right,
15664 as if by the @w{@kbd{a s}} algebra command (@pxref{Simplifying Formulas}).
15665 Each result is true if it is a nonzero number, or an expression
15666 that can be proven to be nonzero (@pxref{Declarations}). If the
15667 results of all conditions are true, the expression (such as
15668 @samp{ifoo(#1)}) has its @samp{#}s substituted, and that is the
15669 result of the parse. If the result of any condition is false, Calc
15670 goes on to try the next rule in the syntax table.
15671
15672 Syntax rules also support @code{let} conditions, which operate in
15673 exactly the same way as they do in algebraic rewrite rules.
15674 @xref{Other Features of Rewrite Rules}, for details. A @code{let}
15675 condition is always true, but as a side effect it defines a
15676 variable which can be used in later conditions, and also in the
15677 expression after the @samp{:=} sign:
15678
15679 @example
15680 foo ( # ) := hifoo(x) :: let(x := #1 + 0.5) :: dnumint(x)
15681 @end example
15682
15683 @noindent
15684 The @code{dnumint} function tests if a value is numerically an
15685 integer, i.e., either a true integer or an integer-valued float.
15686 This rule will parse @code{foo} with a half-integer argument,
15687 like @samp{foo(3.5)}, to a call like @samp{hifoo(4.)}.
15688
15689 The lefthand side of a syntax rule @code{let} must be a simple
15690 variable, not the arbitrary pattern that is allowed in rewrite
15691 rules.
15692
15693 The @code{matches} function is also treated specially in syntax
15694 rule conditions (again, in the same way as in rewrite rules).
15695 @xref{Matching Commands}. If the matching pattern contains
15696 meta-variables, then those meta-variables may be used in later
15697 conditions and in the result expression. The arguments to
15698 @code{matches} are not evaluated in this situation.
15699
15700 @example
15701 sum ( # , # ) := sum(#1,a,b,c) :: matches(#2, a=[b..c])
15702 @end example
15703
15704 @noindent
15705 This is another way to implement the Maple mode @code{sum} notation.
15706 In this approach, we allow @samp{#2} to equal the whole expression
15707 @samp{i=1..10}. Then, we use @code{matches} to break it apart into
15708 its components. If the expression turns out not to match the pattern,
15709 the syntax rule will fail. Note that @kbd{Z S} always uses Calc's
15710 Normal language mode for editing expressions in syntax rules, so we
15711 must use regular Calc notation for the interval @samp{[b..c]} that
15712 will correspond to the Maple mode interval @samp{1..10}.
15713
15714 @node Modes Variable, Calc Mode Line, Language Modes, Mode Settings
15715 @section The @code{Modes} Variable
15716
15717 @noindent
15718 @kindex m g
15719 @pindex calc-get-modes
15720 The @kbd{m g} (@code{calc-get-modes}) command pushes onto the stack
15721 a vector of numbers that describes the various mode settings that
15722 are in effect. With a numeric prefix argument, it pushes only the
15723 @var{n}th mode, i.e., the @var{n}th element of this vector. Keyboard
15724 macros can use the @kbd{m g} command to modify their behavior based
15725 on the current mode settings.
15726
15727 @cindex @code{Modes} variable
15728 @vindex Modes
15729 The modes vector is also available in the special variable
15730 @code{Modes}. In other words, @kbd{m g} is like @kbd{s r Modes @key{RET}}.
15731 It will not work to store into this variable; in fact, if you do,
15732 @code{Modes} will cease to track the current modes. (The @kbd{m g}
15733 command will continue to work, however.)
15734
15735 In general, each number in this vector is suitable as a numeric
15736 prefix argument to the associated mode-setting command. (Recall
15737 that the @kbd{~} key takes a number from the stack and gives it as
15738 a numeric prefix to the next command.)
15739
15740 The elements of the modes vector are as follows:
15741
15742 @enumerate
15743 @item
15744 Current precision. Default is 12; associated command is @kbd{p}.
15745
15746 @item
15747 Binary word size. Default is 32; associated command is @kbd{b w}.
15748
15749 @item
15750 Stack size (not counting the value about to be pushed by @kbd{m g}).
15751 This is zero if @kbd{m g} is executed with an empty stack.
15752
15753 @item
15754 Number radix. Default is 10; command is @kbd{d r}.
15755
15756 @item
15757 Floating-point format. This is the number of digits, plus the
15758 constant 0 for normal notation, 10000 for scientific notation,
15759 20000 for engineering notation, or 30000 for fixed-point notation.
15760 These codes are acceptable as prefix arguments to the @kbd{d n}
15761 command, but note that this may lose information: For example,
15762 @kbd{d s} and @kbd{C-u 12 d s} have similar (but not quite
15763 identical) effects if the current precision is 12, but they both
15764 produce a code of 10012, which will be treated by @kbd{d n} as
15765 @kbd{C-u 12 d s}. If the precision then changes, the float format
15766 will still be frozen at 12 significant figures.
15767
15768 @item
15769 Angular mode. Default is 1 (degrees). Other values are 2 (radians)
15770 and 3 (HMS). The @kbd{m d} command accepts these prefixes.
15771
15772 @item
15773 Symbolic mode. Value is 0 or 1; default is 0. Command is @kbd{m s}.
15774
15775 @item
15776 Fraction mode. Value is 0 or 1; default is 0. Command is @kbd{m f}.
15777
15778 @item
15779 Polar mode. Value is 0 (rectangular) or 1 (polar); default is 0.
15780 Command is @kbd{m p}.
15781
15782 @item
15783 Matrix/Scalar mode. Default value is @mathit{-1}. Value is 0 for Scalar
15784 mode, @mathit{-2} for Matrix mode, or @var{N} for
15785 @texline @math{N\times N}
15786 @infoline @var{N}x@var{N}
15787 Matrix mode. Command is @kbd{m v}.
15788
15789 @item
15790 Simplification mode. Default is 1. Value is @mathit{-1} for off (@kbd{m O}),
15791 0 for @kbd{m N}, 2 for @kbd{m B}, 3 for @kbd{m A}, 4 for @kbd{m E},
15792 or 5 for @w{@kbd{m U}}. The @kbd{m D} command accepts these prefixes.
15793
15794 @item
15795 Infinite mode. Default is @mathit{-1} (off). Value is 1 if the mode is on,
15796 or 0 if the mode is on with positive zeros. Command is @kbd{m i}.
15797 @end enumerate
15798
15799 For example, the sequence @kbd{M-1 m g @key{RET} 2 + ~ p} increases the
15800 precision by two, leaving a copy of the old precision on the stack.
15801 Later, @kbd{~ p} will restore the original precision using that
15802 stack value. (This sequence might be especially useful inside a
15803 keyboard macro.)
15804
15805 As another example, @kbd{M-3 m g 1 - ~ @key{DEL}} deletes all but the
15806 oldest (bottommost) stack entry.
15807
15808 Yet another example: The HP-48 ``round'' command rounds a number
15809 to the current displayed precision. You could roughly emulate this
15810 in Calc with the sequence @kbd{M-5 m g 10000 % ~ c c}. (This
15811 would not work for fixed-point mode, but it wouldn't be hard to
15812 do a full emulation with the help of the @kbd{Z [} and @kbd{Z ]}
15813 programming commands. @xref{Conditionals in Macros}.)
15814
15815 @node Calc Mode Line, , Modes Variable, Mode Settings
15816 @section The Calc Mode Line
15817
15818 @noindent
15819 @cindex Mode line indicators
15820 This section is a summary of all symbols that can appear on the
15821 Calc mode line, the highlighted bar that appears under the Calc
15822 stack window (or under an editing window in Embedded mode).
15823
15824 The basic mode line format is:
15825
15826 @example
15827 --%%-Calc: 12 Deg @var{other modes} (Calculator)
15828 @end example
15829
15830 The @samp{%%} is the Emacs symbol for ``read-only''; it shows that
15831 regular Emacs commands are not allowed to edit the stack buffer
15832 as if it were text.
15833
15834 The word @samp{Calc:} changes to @samp{CalcEmbed:} if Embedded mode
15835 is enabled. The words after this describe the various Calc modes
15836 that are in effect.
15837
15838 The first mode is always the current precision, an integer.
15839 The second mode is always the angular mode, either @code{Deg},
15840 @code{Rad}, or @code{Hms}.
15841
15842 Here is a complete list of the remaining symbols that can appear
15843 on the mode line:
15844
15845 @table @code
15846 @item Alg
15847 Algebraic mode (@kbd{m a}; @pxref{Algebraic Entry}).
15848
15849 @item Alg[(
15850 Incomplete algebraic mode (@kbd{C-u m a}).
15851
15852 @item Alg*
15853 Total algebraic mode (@kbd{m t}).
15854
15855 @item Symb
15856 Symbolic mode (@kbd{m s}; @pxref{Symbolic Mode}).
15857
15858 @item Matrix
15859 Matrix mode (@kbd{m v}; @pxref{Matrix Mode}).
15860
15861 @item Matrix@var{n}
15862 Dimensioned Matrix mode (@kbd{C-u @var{n} m v}).
15863
15864 @item Scalar
15865 Scalar mode (@kbd{m v}; @pxref{Matrix Mode}).
15866
15867 @item Polar
15868 Polar complex mode (@kbd{m p}; @pxref{Polar Mode}).
15869
15870 @item Frac
15871 Fraction mode (@kbd{m f}; @pxref{Fraction Mode}).
15872
15873 @item Inf
15874 Infinite mode (@kbd{m i}; @pxref{Infinite Mode}).
15875
15876 @item +Inf
15877 Positive Infinite mode (@kbd{C-u 0 m i}).
15878
15879 @item NoSimp
15880 Default simplifications off (@kbd{m O}; @pxref{Simplification Modes}).
15881
15882 @item NumSimp
15883 Default simplifications for numeric arguments only (@kbd{m N}).
15884
15885 @item BinSimp@var{w}
15886 Binary-integer simplification mode; word size @var{w} (@kbd{m B}, @kbd{b w}).
15887
15888 @item AlgSimp
15889 Algebraic simplification mode (@kbd{m A}).
15890
15891 @item ExtSimp
15892 Extended algebraic simplification mode (@kbd{m E}).
15893
15894 @item UnitSimp
15895 Units simplification mode (@kbd{m U}).
15896
15897 @item Bin
15898 Current radix is 2 (@kbd{d 2}; @pxref{Radix Modes}).
15899
15900 @item Oct
15901 Current radix is 8 (@kbd{d 8}).
15902
15903 @item Hex
15904 Current radix is 16 (@kbd{d 6}).
15905
15906 @item Radix@var{n}
15907 Current radix is @var{n} (@kbd{d r}).
15908
15909 @item Zero
15910 Leading zeros (@kbd{d z}; @pxref{Radix Modes}).
15911
15912 @item Big
15913 Big language mode (@kbd{d B}; @pxref{Normal Language Modes}).
15914
15915 @item Flat
15916 One-line normal language mode (@kbd{d O}).
15917
15918 @item Unform
15919 Unformatted language mode (@kbd{d U}).
15920
15921 @item C
15922 C language mode (@kbd{d C}; @pxref{C FORTRAN Pascal}).
15923
15924 @item Pascal
15925 Pascal language mode (@kbd{d P}).
15926
15927 @item Fortran
15928 FORTRAN language mode (@kbd{d F}).
15929
15930 @item TeX
15931 @TeX{} language mode (@kbd{d T}; @pxref{TeX and LaTeX Language Modes}).
15932
15933 @item LaTeX
15934 La@TeX{} language mode (@kbd{d L}; @pxref{TeX and LaTeX Language Modes}).
15935
15936 @item Eqn
15937 @dfn{Eqn} language mode (@kbd{d E}; @pxref{Eqn Language Mode}).
15938
15939 @item Math
15940 Mathematica language mode (@kbd{d M}; @pxref{Mathematica Language Mode}).
15941
15942 @item Maple
15943 Maple language mode (@kbd{d W}; @pxref{Maple Language Mode}).
15944
15945 @item Norm@var{n}
15946 Normal float mode with @var{n} digits (@kbd{d n}; @pxref{Float Formats}).
15947
15948 @item Fix@var{n}
15949 Fixed point mode with @var{n} digits after the point (@kbd{d f}).
15950
15951 @item Sci
15952 Scientific notation mode (@kbd{d s}).
15953
15954 @item Sci@var{n}
15955 Scientific notation with @var{n} digits (@kbd{d s}).
15956
15957 @item Eng
15958 Engineering notation mode (@kbd{d e}).
15959
15960 @item Eng@var{n}
15961 Engineering notation with @var{n} digits (@kbd{d e}).
15962
15963 @item Left@var{n}
15964 Left-justified display indented by @var{n} (@kbd{d <}; @pxref{Justification}).
15965
15966 @item Right
15967 Right-justified display (@kbd{d >}).
15968
15969 @item Right@var{n}
15970 Right-justified display with width @var{n} (@kbd{d >}).
15971
15972 @item Center
15973 Centered display (@kbd{d =}).
15974
15975 @item Center@var{n}
15976 Centered display with center column @var{n} (@kbd{d =}).
15977
15978 @item Wid@var{n}
15979 Line breaking with width @var{n} (@kbd{d b}; @pxref{Normal Language Modes}).
15980
15981 @item Wide
15982 No line breaking (@kbd{d b}).
15983
15984 @item Break
15985 Selections show deep structure (@kbd{j b}; @pxref{Making Selections}).
15986
15987 @item Save
15988 Record modes in @file{~/.calc.el} (@kbd{m R}; @pxref{General Mode Commands}).
15989
15990 @item Local
15991 Record modes in Embedded buffer (@kbd{m R}).
15992
15993 @item LocEdit
15994 Record modes as editing-only in Embedded buffer (@kbd{m R}).
15995
15996 @item LocPerm
15997 Record modes as permanent-only in Embedded buffer (@kbd{m R}).
15998
15999 @item Global
16000 Record modes as global in Embedded buffer (@kbd{m R}).
16001
16002 @item Manual
16003 Automatic recomputation turned off (@kbd{m C}; @pxref{Automatic
16004 Recomputation}).
16005
16006 @item Graph
16007 GNUPLOT process is alive in background (@pxref{Graphics}).
16008
16009 @item Sel
16010 Top-of-stack has a selection (Embedded only; @pxref{Making Selections}).
16011
16012 @item Dirty
16013 The stack display may not be up-to-date (@pxref{Display Modes}).
16014
16015 @item Inv
16016 ``Inverse'' prefix was pressed (@kbd{I}; @pxref{Inverse and Hyperbolic}).
16017
16018 @item Hyp
16019 ``Hyperbolic'' prefix was pressed (@kbd{H}).
16020
16021 @item Keep
16022 ``Keep-arguments'' prefix was pressed (@kbd{K}).
16023
16024 @item Narrow
16025 Stack is truncated (@kbd{d t}; @pxref{Truncating the Stack}).
16026 @end table
16027
16028 In addition, the symbols @code{Active} and @code{~Active} can appear
16029 as minor modes on an Embedded buffer's mode line. @xref{Embedded Mode}.
16030
16031 @node Arithmetic, Scientific Functions, Mode Settings, Top
16032 @chapter Arithmetic Functions
16033
16034 @noindent
16035 This chapter describes the Calc commands for doing simple calculations
16036 on numbers, such as addition, absolute value, and square roots. These
16037 commands work by removing the top one or two values from the stack,
16038 performing the desired operation, and pushing the result back onto the
16039 stack. If the operation cannot be performed, the result pushed is a
16040 formula instead of a number, such as @samp{2/0} (because division by zero
16041 is invalid) or @samp{sqrt(x)} (because the argument @samp{x} is a formula).
16042
16043 Most of the commands described here can be invoked by a single keystroke.
16044 Some of the more obscure ones are two-letter sequences beginning with
16045 the @kbd{f} (``functions'') prefix key.
16046
16047 @xref{Prefix Arguments}, for a discussion of the effect of numeric
16048 prefix arguments on commands in this chapter which do not otherwise
16049 interpret a prefix argument.
16050
16051 @menu
16052 * Basic Arithmetic::
16053 * Integer Truncation::
16054 * Complex Number Functions::
16055 * Conversions::
16056 * Date Arithmetic::
16057 * Financial Functions::
16058 * Binary Functions::
16059 @end menu
16060
16061 @node Basic Arithmetic, Integer Truncation, Arithmetic, Arithmetic
16062 @section Basic Arithmetic
16063
16064 @noindent
16065 @kindex +
16066 @pindex calc-plus
16067 @ignore
16068 @mindex @null
16069 @end ignore
16070 @tindex +
16071 The @kbd{+} (@code{calc-plus}) command adds two numbers. The numbers may
16072 be any of the standard Calc data types. The resulting sum is pushed back
16073 onto the stack.
16074
16075 If both arguments of @kbd{+} are vectors or matrices (of matching dimensions),
16076 the result is a vector or matrix sum. If one argument is a vector and the
16077 other a scalar (i.e., a non-vector), the scalar is added to each of the
16078 elements of the vector to form a new vector. If the scalar is not a
16079 number, the operation is left in symbolic form: Suppose you added @samp{x}
16080 to the vector @samp{[1,2]}. You may want the result @samp{[1+x,2+x]}, or
16081 you may plan to substitute a 2-vector for @samp{x} in the future. Since
16082 the Calculator can't tell which interpretation you want, it makes the
16083 safest assumption. @xref{Reducing and Mapping}, for a way to add @samp{x}
16084 to every element of a vector.
16085
16086 If either argument of @kbd{+} is a complex number, the result will in general
16087 be complex. If one argument is in rectangular form and the other polar,
16088 the current Polar mode determines the form of the result. If Symbolic
16089 mode is enabled, the sum may be left as a formula if the necessary
16090 conversions for polar addition are non-trivial.
16091
16092 If both arguments of @kbd{+} are HMS forms, the forms are added according to
16093 the usual conventions of hours-minutes-seconds notation. If one argument
16094 is an HMS form and the other is a number, that number is converted from
16095 degrees or radians (depending on the current Angular mode) to HMS format
16096 and then the two HMS forms are added.
16097
16098 If one argument of @kbd{+} is a date form, the other can be either a
16099 real number, which advances the date by a certain number of days, or
16100 an HMS form, which advances the date by a certain amount of time.
16101 Subtracting two date forms yields the number of days between them.
16102 Adding two date forms is meaningless, but Calc interprets it as the
16103 subtraction of one date form and the negative of the other. (The
16104 negative of a date form can be understood by remembering that dates
16105 are stored as the number of days before or after Jan 1, 1 AD.)
16106
16107 If both arguments of @kbd{+} are error forms, the result is an error form
16108 with an appropriately computed standard deviation. If one argument is an
16109 error form and the other is a number, the number is taken to have zero error.
16110 Error forms may have symbolic formulas as their mean and/or error parts;
16111 adding these will produce a symbolic error form result. However, adding an
16112 error form to a plain symbolic formula (as in @samp{(a +/- b) + c}) will not
16113 work, for the same reasons just mentioned for vectors. Instead you must
16114 write @samp{(a +/- b) + (c +/- 0)}.
16115
16116 If both arguments of @kbd{+} are modulo forms with equal values of @expr{M},
16117 or if one argument is a modulo form and the other a plain number, the
16118 result is a modulo form which represents the sum, modulo @expr{M}, of
16119 the two values.
16120
16121 If both arguments of @kbd{+} are intervals, the result is an interval
16122 which describes all possible sums of the possible input values. If
16123 one argument is a plain number, it is treated as the interval
16124 @w{@samp{[x ..@: x]}}.
16125
16126 If one argument of @kbd{+} is an infinity and the other is not, the
16127 result is that same infinity. If both arguments are infinite and in
16128 the same direction, the result is the same infinity, but if they are
16129 infinite in different directions the result is @code{nan}.
16130
16131 @kindex -
16132 @pindex calc-minus
16133 @ignore
16134 @mindex @null
16135 @end ignore
16136 @tindex -
16137 The @kbd{-} (@code{calc-minus}) command subtracts two values. The top
16138 number on the stack is subtracted from the one behind it, so that the
16139 computation @kbd{5 @key{RET} 2 -} produces 3, not @mathit{-3}. All options
16140 available for @kbd{+} are available for @kbd{-} as well.
16141
16142 @kindex *
16143 @pindex calc-times
16144 @ignore
16145 @mindex @null
16146 @end ignore
16147 @tindex *
16148 The @kbd{*} (@code{calc-times}) command multiplies two numbers. If one
16149 argument is a vector and the other a scalar, the scalar is multiplied by
16150 the elements of the vector to produce a new vector. If both arguments
16151 are vectors, the interpretation depends on the dimensions of the
16152 vectors: If both arguments are matrices, a matrix multiplication is
16153 done. If one argument is a matrix and the other a plain vector, the
16154 vector is interpreted as a row vector or column vector, whichever is
16155 dimensionally correct. If both arguments are plain vectors, the result
16156 is a single scalar number which is the dot product of the two vectors.
16157
16158 If one argument of @kbd{*} is an HMS form and the other a number, the
16159 HMS form is multiplied by that amount. It is an error to multiply two
16160 HMS forms together, or to attempt any multiplication involving date
16161 forms. Error forms, modulo forms, and intervals can be multiplied;
16162 see the comments for addition of those forms. When two error forms
16163 or intervals are multiplied they are considered to be statistically
16164 independent; thus, @samp{[-2 ..@: 3] * [-2 ..@: 3]} is @samp{[-6 ..@: 9]},
16165 whereas @w{@samp{[-2 ..@: 3] ^ 2}} is @samp{[0 ..@: 9]}.
16166
16167 @kindex /
16168 @pindex calc-divide
16169 @ignore
16170 @mindex @null
16171 @end ignore
16172 @tindex /
16173 The @kbd{/} (@code{calc-divide}) command divides two numbers. When
16174 dividing a scalar @expr{B} by a square matrix @expr{A}, the computation
16175 performed is @expr{B} times the inverse of @expr{A}. This also occurs
16176 if @expr{B} is itself a vector or matrix, in which case the effect is
16177 to solve the set of linear equations represented by @expr{B}. If @expr{B}
16178 is a matrix with the same number of rows as @expr{A}, or a plain vector
16179 (which is interpreted here as a column vector), then the equation
16180 @expr{A X = B} is solved for the vector or matrix @expr{X}. Otherwise,
16181 if @expr{B} is a non-square matrix with the same number of @emph{columns}
16182 as @expr{A}, the equation @expr{X A = B} is solved. If you wish a vector
16183 @expr{B} to be interpreted as a row vector to be solved as @expr{X A = B},
16184 make it into a one-row matrix with @kbd{C-u 1 v p} first. To force a
16185 left-handed solution with a square matrix @expr{B}, transpose @expr{A} and
16186 @expr{B} before dividing, then transpose the result.
16187
16188 HMS forms can be divided by real numbers or by other HMS forms. Error
16189 forms can be divided in any combination of ways. Modulo forms where both
16190 values and the modulo are integers can be divided to get an integer modulo
16191 form result. Intervals can be divided; dividing by an interval that
16192 encompasses zero or has zero as a limit will result in an infinite
16193 interval.
16194
16195 @kindex ^
16196 @pindex calc-power
16197 @ignore
16198 @mindex @null
16199 @end ignore
16200 @tindex ^
16201 The @kbd{^} (@code{calc-power}) command raises a number to a power. If
16202 the power is an integer, an exact result is computed using repeated
16203 multiplications. For non-integer powers, Calc uses Newton's method or
16204 logarithms and exponentials. Square matrices can be raised to integer
16205 powers. If either argument is an error (or interval or modulo) form,
16206 the result is also an error (or interval or modulo) form.
16207
16208 @kindex I ^
16209 @tindex nroot
16210 If you press the @kbd{I} (inverse) key first, the @kbd{I ^} command
16211 computes an Nth root: @kbd{125 @key{RET} 3 I ^} computes the number 5.
16212 (This is entirely equivalent to @kbd{125 @key{RET} 1:3 ^}.)
16213
16214 @kindex \
16215 @pindex calc-idiv
16216 @tindex idiv
16217 @ignore
16218 @mindex @null
16219 @end ignore
16220 @tindex \
16221 The @kbd{\} (@code{calc-idiv}) command divides two numbers on the stack
16222 to produce an integer result. It is equivalent to dividing with
16223 @key{/}, then rounding down with @kbd{F} (@code{calc-floor}), only a bit
16224 more convenient and efficient. Also, since it is an all-integer
16225 operation when the arguments are integers, it avoids problems that
16226 @kbd{/ F} would have with floating-point roundoff.
16227
16228 @kindex %
16229 @pindex calc-mod
16230 @ignore
16231 @mindex @null
16232 @end ignore
16233 @tindex %
16234 The @kbd{%} (@code{calc-mod}) command performs a ``modulo'' (or ``remainder'')
16235 operation. Mathematically, @samp{a%b = a - (a\b)*b}, and is defined
16236 for all real numbers @expr{a} and @expr{b} (except @expr{b=0}). For
16237 positive @expr{b}, the result will always be between 0 (inclusive) and
16238 @expr{b} (exclusive). Modulo does not work for HMS forms and error forms.
16239 If @expr{a} is a modulo form, its modulo is changed to @expr{b}, which
16240 must be positive real number.
16241
16242 @kindex :
16243 @pindex calc-fdiv
16244 @tindex fdiv
16245 The @kbd{:} (@code{calc-fdiv}) command [@code{fdiv} function in a formula]
16246 divides the two integers on the top of the stack to produce a fractional
16247 result. This is a convenient shorthand for enabling Fraction mode (with
16248 @kbd{m f}) temporarily and using @samp{/}. Note that during numeric entry
16249 the @kbd{:} key is interpreted as a fraction separator, so to divide 8 by 6
16250 you would have to type @kbd{8 @key{RET} 6 @key{RET} :}. (Of course, in
16251 this case, it would be much easier simply to enter the fraction directly
16252 as @kbd{8:6 @key{RET}}!)
16253
16254 @kindex n
16255 @pindex calc-change-sign
16256 The @kbd{n} (@code{calc-change-sign}) command negates the number on the top
16257 of the stack. It works on numbers, vectors and matrices, HMS forms, date
16258 forms, error forms, intervals, and modulo forms.
16259
16260 @kindex A
16261 @pindex calc-abs
16262 @tindex abs
16263 The @kbd{A} (@code{calc-abs}) [@code{abs}] command computes the absolute
16264 value of a number. The result of @code{abs} is always a nonnegative
16265 real number: With a complex argument, it computes the complex magnitude.
16266 With a vector or matrix argument, it computes the Frobenius norm, i.e.,
16267 the square root of the sum of the squares of the absolute values of the
16268 elements. The absolute value of an error form is defined by replacing
16269 the mean part with its absolute value and leaving the error part the same.
16270 The absolute value of a modulo form is undefined. The absolute value of
16271 an interval is defined in the obvious way.
16272
16273 @kindex f A
16274 @pindex calc-abssqr
16275 @tindex abssqr
16276 The @kbd{f A} (@code{calc-abssqr}) [@code{abssqr}] command computes the
16277 absolute value squared of a number, vector or matrix, or error form.
16278
16279 @kindex f s
16280 @pindex calc-sign
16281 @tindex sign
16282 The @kbd{f s} (@code{calc-sign}) [@code{sign}] command returns 1 if its
16283 argument is positive, @mathit{-1} if its argument is negative, or 0 if its
16284 argument is zero. In algebraic form, you can also write @samp{sign(a,x)}
16285 which evaluates to @samp{x * sign(a)}, i.e., either @samp{x}, @samp{-x}, or
16286 zero depending on the sign of @samp{a}.
16287
16288 @kindex &
16289 @pindex calc-inv
16290 @tindex inv
16291 @cindex Reciprocal
16292 The @kbd{&} (@code{calc-inv}) [@code{inv}] command computes the
16293 reciprocal of a number, i.e., @expr{1 / x}. Operating on a square
16294 matrix, it computes the inverse of that matrix.
16295
16296 @kindex Q
16297 @pindex calc-sqrt
16298 @tindex sqrt
16299 The @kbd{Q} (@code{calc-sqrt}) [@code{sqrt}] command computes the square
16300 root of a number. For a negative real argument, the result will be a
16301 complex number whose form is determined by the current Polar mode.
16302
16303 @kindex f h
16304 @pindex calc-hypot
16305 @tindex hypot
16306 The @kbd{f h} (@code{calc-hypot}) [@code{hypot}] command computes the square
16307 root of the sum of the squares of two numbers. That is, @samp{hypot(a,b)}
16308 is the length of the hypotenuse of a right triangle with sides @expr{a}
16309 and @expr{b}. If the arguments are complex numbers, their squared
16310 magnitudes are used.
16311
16312 @kindex f Q
16313 @pindex calc-isqrt
16314 @tindex isqrt
16315 The @kbd{f Q} (@code{calc-isqrt}) [@code{isqrt}] command computes the
16316 integer square root of an integer. This is the true square root of the
16317 number, rounded down to an integer. For example, @samp{isqrt(10)}
16318 produces 3. Note that, like @kbd{\} [@code{idiv}], this uses exact
16319 integer arithmetic throughout to avoid roundoff problems. If the input
16320 is a floating-point number or other non-integer value, this is exactly
16321 the same as @samp{floor(sqrt(x))}.
16322
16323 @kindex f n
16324 @kindex f x
16325 @pindex calc-min
16326 @tindex min
16327 @pindex calc-max
16328 @tindex max
16329 The @kbd{f n} (@code{calc-min}) [@code{min}] and @kbd{f x} (@code{calc-max})
16330 [@code{max}] commands take the minimum or maximum of two real numbers,
16331 respectively. These commands also work on HMS forms, date forms,
16332 intervals, and infinities. (In algebraic expressions, these functions
16333 take any number of arguments and return the maximum or minimum among
16334 all the arguments.)
16335
16336 @kindex f M
16337 @kindex f X
16338 @pindex calc-mant-part
16339 @tindex mant
16340 @pindex calc-xpon-part
16341 @tindex xpon
16342 The @kbd{f M} (@code{calc-mant-part}) [@code{mant}] function extracts
16343 the ``mantissa'' part @expr{m} of its floating-point argument; @kbd{f X}
16344 (@code{calc-xpon-part}) [@code{xpon}] extracts the ``exponent'' part
16345 @expr{e}. The original number is equal to
16346 @texline @math{m \times 10^e},
16347 @infoline @expr{m * 10^e},
16348 where @expr{m} is in the interval @samp{[1.0 ..@: 10.0)} except that
16349 @expr{m=e=0} if the original number is zero. For integers
16350 and fractions, @code{mant} returns the number unchanged and @code{xpon}
16351 returns zero. The @kbd{v u} (@code{calc-unpack}) command can also be
16352 used to ``unpack'' a floating-point number; this produces an integer
16353 mantissa and exponent, with the constraint that the mantissa is not
16354 a multiple of ten (again except for the @expr{m=e=0} case).
16355
16356 @kindex f S
16357 @pindex calc-scale-float
16358 @tindex scf
16359 The @kbd{f S} (@code{calc-scale-float}) [@code{scf}] function scales a number
16360 by a given power of ten. Thus, @samp{scf(mant(x), xpon(x)) = x} for any
16361 real @samp{x}. The second argument must be an integer, but the first
16362 may actually be any numeric value. For example, @samp{scf(5,-2) = 0.05}
16363 or @samp{1:20} depending on the current Fraction mode.
16364
16365 @kindex f [
16366 @kindex f ]
16367 @pindex calc-decrement
16368 @pindex calc-increment
16369 @tindex decr
16370 @tindex incr
16371 The @kbd{f [} (@code{calc-decrement}) [@code{decr}] and @kbd{f ]}
16372 (@code{calc-increment}) [@code{incr}] functions decrease or increase
16373 a number by one unit. For integers, the effect is obvious. For
16374 floating-point numbers, the change is by one unit in the last place.
16375 For example, incrementing @samp{12.3456} when the current precision
16376 is 6 digits yields @samp{12.3457}. If the current precision had been
16377 8 digits, the result would have been @samp{12.345601}. Incrementing
16378 @samp{0.0} produces
16379 @texline @math{10^{-p}},
16380 @infoline @expr{10^-p},
16381 where @expr{p} is the current
16382 precision. These operations are defined only on integers and floats.
16383 With numeric prefix arguments, they change the number by @expr{n} units.
16384
16385 Note that incrementing followed by decrementing, or vice-versa, will
16386 almost but not quite always cancel out. Suppose the precision is
16387 6 digits and the number @samp{9.99999} is on the stack. Incrementing
16388 will produce @samp{10.0000}; decrementing will produce @samp{9.9999}.
16389 One digit has been dropped. This is an unavoidable consequence of the
16390 way floating-point numbers work.
16391
16392 Incrementing a date/time form adjusts it by a certain number of seconds.
16393 Incrementing a pure date form adjusts it by a certain number of days.
16394
16395 @node Integer Truncation, Complex Number Functions, Basic Arithmetic, Arithmetic
16396 @section Integer Truncation
16397
16398 @noindent
16399 There are four commands for truncating a real number to an integer,
16400 differing mainly in their treatment of negative numbers. All of these
16401 commands have the property that if the argument is an integer, the result
16402 is the same integer. An integer-valued floating-point argument is converted
16403 to integer form.
16404
16405 If you press @kbd{H} (@code{calc-hyperbolic}) first, the result will be
16406 expressed as an integer-valued floating-point number.
16407
16408 @cindex Integer part of a number
16409 @kindex F
16410 @pindex calc-floor
16411 @tindex floor
16412 @tindex ffloor
16413 @ignore
16414 @mindex @null
16415 @end ignore
16416 @kindex H F
16417 The @kbd{F} (@code{calc-floor}) [@code{floor} or @code{ffloor}] command
16418 truncates a real number to the next lower integer, i.e., toward minus
16419 infinity. Thus @kbd{3.6 F} produces 3, but @kbd{_3.6 F} produces
16420 @mathit{-4}.
16421
16422 @kindex I F
16423 @pindex calc-ceiling
16424 @tindex ceil
16425 @tindex fceil
16426 @ignore
16427 @mindex @null
16428 @end ignore
16429 @kindex H I F
16430 The @kbd{I F} (@code{calc-ceiling}) [@code{ceil} or @code{fceil}]
16431 command truncates toward positive infinity. Thus @kbd{3.6 I F} produces
16432 4, and @kbd{_3.6 I F} produces @mathit{-3}.
16433
16434 @kindex R
16435 @pindex calc-round
16436 @tindex round
16437 @tindex fround
16438 @ignore
16439 @mindex @null
16440 @end ignore
16441 @kindex H R
16442 The @kbd{R} (@code{calc-round}) [@code{round} or @code{fround}] command
16443 rounds to the nearest integer. When the fractional part is .5 exactly,
16444 this command rounds away from zero. (All other rounding in the
16445 Calculator uses this convention as well.) Thus @kbd{3.5 R} produces 4
16446 but @kbd{3.4 R} produces 3; @kbd{_3.5 R} produces @mathit{-4}.
16447
16448 @kindex I R
16449 @pindex calc-trunc
16450 @tindex trunc
16451 @tindex ftrunc
16452 @ignore
16453 @mindex @null
16454 @end ignore
16455 @kindex H I R
16456 The @kbd{I R} (@code{calc-trunc}) [@code{trunc} or @code{ftrunc}]
16457 command truncates toward zero. In other words, it ``chops off''
16458 everything after the decimal point. Thus @kbd{3.6 I R} produces 3 and
16459 @kbd{_3.6 I R} produces @mathit{-3}.
16460
16461 These functions may not be applied meaningfully to error forms, but they
16462 do work for intervals. As a convenience, applying @code{floor} to a
16463 modulo form floors the value part of the form. Applied to a vector,
16464 these functions operate on all elements of the vector one by one.
16465 Applied to a date form, they operate on the internal numerical
16466 representation of dates, converting a date/time form into a pure date.
16467
16468 @ignore
16469 @starindex
16470 @end ignore
16471 @tindex rounde
16472 @ignore
16473 @starindex
16474 @end ignore
16475 @tindex roundu
16476 @ignore
16477 @starindex
16478 @end ignore
16479 @tindex frounde
16480 @ignore
16481 @starindex
16482 @end ignore
16483 @tindex froundu
16484 There are two more rounding functions which can only be entered in
16485 algebraic notation. The @code{roundu} function is like @code{round}
16486 except that it rounds up, toward plus infinity, when the fractional
16487 part is .5. This distinction matters only for negative arguments.
16488 Also, @code{rounde} rounds to an even number in the case of a tie,
16489 rounding up or down as necessary. For example, @samp{rounde(3.5)} and
16490 @samp{rounde(4.5)} both return 4, but @samp{rounde(5.5)} returns 6.
16491 The advantage of round-to-even is that the net error due to rounding
16492 after a long calculation tends to cancel out to zero. An important
16493 subtle point here is that the number being fed to @code{rounde} will
16494 already have been rounded to the current precision before @code{rounde}
16495 begins. For example, @samp{rounde(2.500001)} with a current precision
16496 of 6 will incorrectly, or at least surprisingly, yield 2 because the
16497 argument will first have been rounded down to @expr{2.5} (which
16498 @code{rounde} sees as an exact tie between 2 and 3).
16499
16500 Each of these functions, when written in algebraic formulas, allows
16501 a second argument which specifies the number of digits after the
16502 decimal point to keep. For example, @samp{round(123.4567, 2)} will
16503 produce the answer 123.46, and @samp{round(123.4567, -1)} will
16504 produce 120 (i.e., the cutoff is one digit to the @emph{left} of
16505 the decimal point). A second argument of zero is equivalent to
16506 no second argument at all.
16507
16508 @cindex Fractional part of a number
16509 To compute the fractional part of a number (i.e., the amount which, when
16510 added to `@tfn{floor(}@var{n}@tfn{)}', will produce @var{n}) just take @var{n}
16511 modulo 1 using the @code{%} command.
16512
16513 Note also the @kbd{\} (integer quotient), @kbd{f I} (integer logarithm),
16514 and @kbd{f Q} (integer square root) commands, which are analogous to
16515 @kbd{/}, @kbd{B}, and @kbd{Q}, respectively, except that they take integer
16516 arguments and return the result rounded down to an integer.
16517
16518 @node Complex Number Functions, Conversions, Integer Truncation, Arithmetic
16519 @section Complex Number Functions
16520
16521 @noindent
16522 @kindex J
16523 @pindex calc-conj
16524 @tindex conj
16525 The @kbd{J} (@code{calc-conj}) [@code{conj}] command computes the
16526 complex conjugate of a number. For complex number @expr{a+bi}, the
16527 complex conjugate is @expr{a-bi}. If the argument is a real number,
16528 this command leaves it the same. If the argument is a vector or matrix,
16529 this command replaces each element by its complex conjugate.
16530
16531 @kindex G
16532 @pindex calc-argument
16533 @tindex arg
16534 The @kbd{G} (@code{calc-argument}) [@code{arg}] command computes the
16535 ``argument'' or polar angle of a complex number. For a number in polar
16536 notation, this is simply the second component of the pair
16537 @texline `@tfn{(}@var{r}@tfn{;}@math{\theta}@tfn{)}'.
16538 @infoline `@tfn{(}@var{r}@tfn{;}@var{theta}@tfn{)}'.
16539 The result is expressed according to the current angular mode and will
16540 be in the range @mathit{-180} degrees (exclusive) to @mathit{+180} degrees
16541 (inclusive), or the equivalent range in radians.
16542
16543 @pindex calc-imaginary
16544 The @code{calc-imaginary} command multiplies the number on the
16545 top of the stack by the imaginary number @expr{i = (0,1)}. This
16546 command is not normally bound to a key in Calc, but it is available
16547 on the @key{IMAG} button in Keypad mode.
16548
16549 @kindex f r
16550 @pindex calc-re
16551 @tindex re
16552 The @kbd{f r} (@code{calc-re}) [@code{re}] command replaces a complex number
16553 by its real part. This command has no effect on real numbers. (As an
16554 added convenience, @code{re} applied to a modulo form extracts
16555 the value part.)
16556
16557 @kindex f i
16558 @pindex calc-im
16559 @tindex im
16560 The @kbd{f i} (@code{calc-im}) [@code{im}] command replaces a complex number
16561 by its imaginary part; real numbers are converted to zero. With a vector
16562 or matrix argument, these functions operate element-wise.
16563
16564 @ignore
16565 @mindex v p
16566 @end ignore
16567 @kindex v p (complex)
16568 @pindex calc-pack
16569 The @kbd{v p} (@code{calc-pack}) command can pack the top two numbers on
16570 the stack into a composite object such as a complex number. With
16571 a prefix argument of @mathit{-1}, it produces a rectangular complex number;
16572 with an argument of @mathit{-2}, it produces a polar complex number.
16573 (Also, @pxref{Building Vectors}.)
16574
16575 @ignore
16576 @mindex v u
16577 @end ignore
16578 @kindex v u (complex)
16579 @pindex calc-unpack
16580 The @kbd{v u} (@code{calc-unpack}) command takes the complex number
16581 (or other composite object) on the top of the stack and unpacks it
16582 into its separate components.
16583
16584 @node Conversions, Date Arithmetic, Complex Number Functions, Arithmetic
16585 @section Conversions
16586
16587 @noindent
16588 The commands described in this section convert numbers from one form
16589 to another; they are two-key sequences beginning with the letter @kbd{c}.
16590
16591 @kindex c f
16592 @pindex calc-float
16593 @tindex pfloat
16594 The @kbd{c f} (@code{calc-float}) [@code{pfloat}] command converts the
16595 number on the top of the stack to floating-point form. For example,
16596 @expr{23} is converted to @expr{23.0}, @expr{3:2} is converted to
16597 @expr{1.5}, and @expr{2.3} is left the same. If the value is a composite
16598 object such as a complex number or vector, each of the components is
16599 converted to floating-point. If the value is a formula, all numbers
16600 in the formula are converted to floating-point. Note that depending
16601 on the current floating-point precision, conversion to floating-point
16602 format may lose information.
16603
16604 As a special exception, integers which appear as powers or subscripts
16605 are not floated by @kbd{c f}. If you really want to float a power,
16606 you can use a @kbd{j s} command to select the power followed by @kbd{c f}.
16607 Because @kbd{c f} cannot examine the formula outside of the selection,
16608 it does not notice that the thing being floated is a power.
16609 @xref{Selecting Subformulas}.
16610
16611 The normal @kbd{c f} command is ``pervasive'' in the sense that it
16612 applies to all numbers throughout the formula. The @code{pfloat}
16613 algebraic function never stays around in a formula; @samp{pfloat(a + 1)}
16614 changes to @samp{a + 1.0} as soon as it is evaluated.
16615
16616 @kindex H c f
16617 @tindex float
16618 With the Hyperbolic flag, @kbd{H c f} [@code{float}] operates
16619 only on the number or vector of numbers at the top level of its
16620 argument. Thus, @samp{float(1)} is 1.0, but @samp{float(a + 1)}
16621 is left unevaluated because its argument is not a number.
16622
16623 You should use @kbd{H c f} if you wish to guarantee that the final
16624 value, once all the variables have been assigned, is a float; you
16625 would use @kbd{c f} if you wish to do the conversion on the numbers
16626 that appear right now.
16627
16628 @kindex c F
16629 @pindex calc-fraction
16630 @tindex pfrac
16631 The @kbd{c F} (@code{calc-fraction}) [@code{pfrac}] command converts a
16632 floating-point number into a fractional approximation. By default, it
16633 produces a fraction whose decimal representation is the same as the
16634 input number, to within the current precision. You can also give a
16635 numeric prefix argument to specify a tolerance, either directly, or,
16636 if the prefix argument is zero, by using the number on top of the stack
16637 as the tolerance. If the tolerance is a positive integer, the fraction
16638 is correct to within that many significant figures. If the tolerance is
16639 a non-positive integer, it specifies how many digits fewer than the current
16640 precision to use. If the tolerance is a floating-point number, the
16641 fraction is correct to within that absolute amount.
16642
16643 @kindex H c F
16644 @tindex frac
16645 The @code{pfrac} function is pervasive, like @code{pfloat}.
16646 There is also a non-pervasive version, @kbd{H c F} [@code{frac}],
16647 which is analogous to @kbd{H c f} discussed above.
16648
16649 @kindex c d
16650 @pindex calc-to-degrees
16651 @tindex deg
16652 The @kbd{c d} (@code{calc-to-degrees}) [@code{deg}] command converts a
16653 number into degrees form. The value on the top of the stack may be an
16654 HMS form (interpreted as degrees-minutes-seconds), or a real number which
16655 will be interpreted in radians regardless of the current angular mode.
16656
16657 @kindex c r
16658 @pindex calc-to-radians
16659 @tindex rad
16660 The @kbd{c r} (@code{calc-to-radians}) [@code{rad}] command converts an
16661 HMS form or angle in degrees into an angle in radians.
16662
16663 @kindex c h
16664 @pindex calc-to-hms
16665 @tindex hms
16666 The @kbd{c h} (@code{calc-to-hms}) [@code{hms}] command converts a real
16667 number, interpreted according to the current angular mode, to an HMS
16668 form describing the same angle. In algebraic notation, the @code{hms}
16669 function also accepts three arguments: @samp{hms(@var{h}, @var{m}, @var{s})}.
16670 (The three-argument version is independent of the current angular mode.)
16671
16672 @pindex calc-from-hms
16673 The @code{calc-from-hms} command converts the HMS form on the top of the
16674 stack into a real number according to the current angular mode.
16675
16676 @kindex c p
16677 @kindex I c p
16678 @pindex calc-polar
16679 @tindex polar
16680 @tindex rect
16681 The @kbd{c p} (@code{calc-polar}) command converts the complex number on
16682 the top of the stack from polar to rectangular form, or from rectangular
16683 to polar form, whichever is appropriate. Real numbers are left the same.
16684 This command is equivalent to the @code{rect} or @code{polar}
16685 functions in algebraic formulas, depending on the direction of
16686 conversion. (It uses @code{polar}, except that if the argument is
16687 already a polar complex number, it uses @code{rect} instead. The
16688 @kbd{I c p} command always uses @code{rect}.)
16689
16690 @kindex c c
16691 @pindex calc-clean
16692 @tindex pclean
16693 The @kbd{c c} (@code{calc-clean}) [@code{pclean}] command ``cleans'' the
16694 number on the top of the stack. Floating point numbers are re-rounded
16695 according to the current precision. Polar numbers whose angular
16696 components have strayed from the @mathit{-180} to @mathit{+180} degree range
16697 are normalized. (Note that results will be undesirable if the current
16698 angular mode is different from the one under which the number was
16699 produced!) Integers and fractions are generally unaffected by this
16700 operation. Vectors and formulas are cleaned by cleaning each component
16701 number (i.e., pervasively).
16702
16703 If the simplification mode is set below the default level, it is raised
16704 to the default level for the purposes of this command. Thus, @kbd{c c}
16705 applies the default simplifications even if their automatic application
16706 is disabled. @xref{Simplification Modes}.
16707
16708 @cindex Roundoff errors, correcting
16709 A numeric prefix argument to @kbd{c c} sets the floating-point precision
16710 to that value for the duration of the command. A positive prefix (of at
16711 least 3) sets the precision to the specified value; a negative or zero
16712 prefix decreases the precision by the specified amount.
16713
16714 @kindex c 0-9
16715 @pindex calc-clean-num
16716 The keystroke sequences @kbd{c 0} through @kbd{c 9} are equivalent
16717 to @kbd{c c} with the corresponding negative prefix argument. If roundoff
16718 errors have changed 2.0 into 1.999999, typing @kbd{c 1} to clip off one
16719 decimal place often conveniently does the trick.
16720
16721 The @kbd{c c} command with a numeric prefix argument, and the @kbd{c 0}
16722 through @kbd{c 9} commands, also ``clip'' very small floating-point
16723 numbers to zero. If the exponent is less than or equal to the negative
16724 of the specified precision, the number is changed to 0.0. For example,
16725 if the current precision is 12, then @kbd{c 2} changes the vector
16726 @samp{[1e-8, 1e-9, 1e-10, 1e-11]} to @samp{[1e-8, 1e-9, 0, 0]}.
16727 Numbers this small generally arise from roundoff noise.
16728
16729 If the numbers you are using really are legitimately this small,
16730 you should avoid using the @kbd{c 0} through @kbd{c 9} commands.
16731 (The plain @kbd{c c} command rounds to the current precision but
16732 does not clip small numbers.)
16733
16734 One more property of @kbd{c 0} through @kbd{c 9}, and of @kbd{c c} with
16735 a prefix argument, is that integer-valued floats are converted to
16736 plain integers, so that @kbd{c 1} on @samp{[1., 1.5, 2., 2.5, 3.]}
16737 produces @samp{[1, 1.5, 2, 2.5, 3]}. This is not done for huge
16738 numbers (@samp{1e100} is technically an integer-valued float, but
16739 you wouldn't want it automatically converted to a 100-digit integer).
16740
16741 @kindex H c 0-9
16742 @kindex H c c
16743 @tindex clean
16744 With the Hyperbolic flag, @kbd{H c c} and @kbd{H c 0} through @kbd{H c 9}
16745 operate non-pervasively [@code{clean}].
16746
16747 @node Date Arithmetic, Financial Functions, Conversions, Arithmetic
16748 @section Date Arithmetic
16749
16750 @noindent
16751 @cindex Date arithmetic, additional functions
16752 The commands described in this section perform various conversions
16753 and calculations involving date forms (@pxref{Date Forms}). They
16754 use the @kbd{t} (for time/date) prefix key followed by shifted
16755 letters.
16756
16757 The simplest date arithmetic is done using the regular @kbd{+} and @kbd{-}
16758 commands. In particular, adding a number to a date form advances the
16759 date form by a certain number of days; adding an HMS form to a date
16760 form advances the date by a certain amount of time; and subtracting two
16761 date forms produces a difference measured in days. The commands
16762 described here provide additional, more specialized operations on dates.
16763
16764 Many of these commands accept a numeric prefix argument; if you give
16765 plain @kbd{C-u} as the prefix, these commands will instead take the
16766 additional argument from the top of the stack.
16767
16768 @menu
16769 * Date Conversions::
16770 * Date Functions::
16771 * Time Zones::
16772 * Business Days::
16773 @end menu
16774
16775 @node Date Conversions, Date Functions, Date Arithmetic, Date Arithmetic
16776 @subsection Date Conversions
16777
16778 @noindent
16779 @kindex t D
16780 @pindex calc-date
16781 @tindex date
16782 The @kbd{t D} (@code{calc-date}) [@code{date}] command converts a
16783 date form into a number, measured in days since Jan 1, 1 AD. The
16784 result will be an integer if @var{date} is a pure date form, or a
16785 fraction or float if @var{date} is a date/time form. Or, if its
16786 argument is a number, it converts this number into a date form.
16787
16788 With a numeric prefix argument, @kbd{t D} takes that many objects
16789 (up to six) from the top of the stack and interprets them in one
16790 of the following ways:
16791
16792 The @samp{date(@var{year}, @var{month}, @var{day})} function
16793 builds a pure date form out of the specified year, month, and
16794 day, which must all be integers. @var{Year} is a year number,
16795 such as 1991 (@emph{not} the same as 91!). @var{Month} must be
16796 an integer in the range 1 to 12; @var{day} must be in the range
16797 1 to 31. If the specified month has fewer than 31 days and
16798 @var{day} is too large, the equivalent day in the following
16799 month will be used.
16800
16801 The @samp{date(@var{month}, @var{day})} function builds a
16802 pure date form using the current year, as determined by the
16803 real-time clock.
16804
16805 The @samp{date(@var{year}, @var{month}, @var{day}, @var{hms})}
16806 function builds a date/time form using an @var{hms} form.
16807
16808 The @samp{date(@var{year}, @var{month}, @var{day}, @var{hour},
16809 @var{minute}, @var{second})} function builds a date/time form.
16810 @var{hour} should be an integer in the range 0 to 23;
16811 @var{minute} should be an integer in the range 0 to 59;
16812 @var{second} should be any real number in the range @samp{[0 .. 60)}.
16813 The last two arguments default to zero if omitted.
16814
16815 @kindex t J
16816 @pindex calc-julian
16817 @tindex julian
16818 @cindex Julian day counts, conversions
16819 The @kbd{t J} (@code{calc-julian}) [@code{julian}] command converts
16820 a date form into a Julian day count, which is the number of days
16821 since noon on Jan 1, 4713 BC. A pure date is converted to an integer
16822 Julian count representing noon of that day. A date/time form is
16823 converted to an exact floating-point Julian count, adjusted to
16824 interpret the date form in the current time zone but the Julian
16825 day count in Greenwich Mean Time. A numeric prefix argument allows
16826 you to specify the time zone; @pxref{Time Zones}. Use a prefix of
16827 zero to suppress the time zone adjustment. Note that pure date forms
16828 are never time-zone adjusted.
16829
16830 This command can also do the opposite conversion, from a Julian day
16831 count (either an integer day, or a floating-point day and time in
16832 the GMT zone), into a pure date form or a date/time form in the
16833 current or specified time zone.
16834
16835 @kindex t U
16836 @pindex calc-unix-time
16837 @tindex unixtime
16838 @cindex Unix time format, conversions
16839 The @kbd{t U} (@code{calc-unix-time}) [@code{unixtime}] command
16840 converts a date form into a Unix time value, which is the number of
16841 seconds since midnight on Jan 1, 1970, or vice-versa. The numeric result
16842 will be an integer if the current precision is 12 or less; for higher
16843 precisions, the result may be a float with (@var{precision}@minus{}12)
16844 digits after the decimal. Just as for @kbd{t J}, the numeric time
16845 is interpreted in the GMT time zone and the date form is interpreted
16846 in the current or specified zone. Some systems use Unix-like
16847 numbering but with the local time zone; give a prefix of zero to
16848 suppress the adjustment if so.
16849
16850 @kindex t C
16851 @pindex calc-convert-time-zones
16852 @tindex tzconv
16853 @cindex Time Zones, converting between
16854 The @kbd{t C} (@code{calc-convert-time-zones}) [@code{tzconv}]
16855 command converts a date form from one time zone to another. You
16856 are prompted for each time zone name in turn; you can answer with
16857 any suitable Calc time zone expression (@pxref{Time Zones}).
16858 If you answer either prompt with a blank line, the local time
16859 zone is used for that prompt. You can also answer the first
16860 prompt with @kbd{$} to take the two time zone names from the
16861 stack (and the date to be converted from the third stack level).
16862
16863 @node Date Functions, Business Days, Date Conversions, Date Arithmetic
16864 @subsection Date Functions
16865
16866 @noindent
16867 @kindex t N
16868 @pindex calc-now
16869 @tindex now
16870 The @kbd{t N} (@code{calc-now}) [@code{now}] command pushes the
16871 current date and time on the stack as a date form. The time is
16872 reported in terms of the specified time zone; with no numeric prefix
16873 argument, @kbd{t N} reports for the current time zone.
16874
16875 @kindex t P
16876 @pindex calc-date-part
16877 The @kbd{t P} (@code{calc-date-part}) command extracts one part
16878 of a date form. The prefix argument specifies the part; with no
16879 argument, this command prompts for a part code from 1 to 9.
16880 The various part codes are described in the following paragraphs.
16881
16882 @tindex year
16883 The @kbd{M-1 t P} [@code{year}] function extracts the year number
16884 from a date form as an integer, e.g., 1991. This and the
16885 following functions will also accept a real number for an
16886 argument, which is interpreted as a standard Calc day number.
16887 Note that this function will never return zero, since the year
16888 1 BC immediately precedes the year 1 AD.
16889
16890 @tindex month
16891 The @kbd{M-2 t P} [@code{month}] function extracts the month number
16892 from a date form as an integer in the range 1 to 12.
16893
16894 @tindex day
16895 The @kbd{M-3 t P} [@code{day}] function extracts the day number
16896 from a date form as an integer in the range 1 to 31.
16897
16898 @tindex hour
16899 The @kbd{M-4 t P} [@code{hour}] function extracts the hour from
16900 a date form as an integer in the range 0 (midnight) to 23. Note
16901 that 24-hour time is always used. This returns zero for a pure
16902 date form. This function (and the following two) also accept
16903 HMS forms as input.
16904
16905 @tindex minute
16906 The @kbd{M-5 t P} [@code{minute}] function extracts the minute
16907 from a date form as an integer in the range 0 to 59.
16908
16909 @tindex second
16910 The @kbd{M-6 t P} [@code{second}] function extracts the second
16911 from a date form. If the current precision is 12 or less,
16912 the result is an integer in the range 0 to 59. For higher
16913 precisions, the result may instead be a floating-point number.
16914
16915 @tindex weekday
16916 The @kbd{M-7 t P} [@code{weekday}] function extracts the weekday
16917 number from a date form as an integer in the range 0 (Sunday)
16918 to 6 (Saturday).
16919
16920 @tindex yearday
16921 The @kbd{M-8 t P} [@code{yearday}] function extracts the day-of-year
16922 number from a date form as an integer in the range 1 (January 1)
16923 to 366 (December 31 of a leap year).
16924
16925 @tindex time
16926 The @kbd{M-9 t P} [@code{time}] function extracts the time portion
16927 of a date form as an HMS form. This returns @samp{0@@ 0' 0"}
16928 for a pure date form.
16929
16930 @kindex t M
16931 @pindex calc-new-month
16932 @tindex newmonth
16933 The @kbd{t M} (@code{calc-new-month}) [@code{newmonth}] command
16934 computes a new date form that represents the first day of the month
16935 specified by the input date. The result is always a pure date
16936 form; only the year and month numbers of the input are retained.
16937 With a numeric prefix argument @var{n} in the range from 1 to 31,
16938 @kbd{t M} computes the @var{n}th day of the month. (If @var{n}
16939 is greater than the actual number of days in the month, or if
16940 @var{n} is zero, the last day of the month is used.)
16941
16942 @kindex t Y
16943 @pindex calc-new-year
16944 @tindex newyear
16945 The @kbd{t Y} (@code{calc-new-year}) [@code{newyear}] command
16946 computes a new pure date form that represents the first day of
16947 the year specified by the input. The month, day, and time
16948 of the input date form are lost. With a numeric prefix argument
16949 @var{n} in the range from 1 to 366, @kbd{t Y} computes the
16950 @var{n}th day of the year (366 is treated as 365 in non-leap
16951 years). A prefix argument of 0 computes the last day of the
16952 year (December 31). A negative prefix argument from @mathit{-1} to
16953 @mathit{-12} computes the first day of the @var{n}th month of the year.
16954
16955 @kindex t W
16956 @pindex calc-new-week
16957 @tindex newweek
16958 The @kbd{t W} (@code{calc-new-week}) [@code{newweek}] command
16959 computes a new pure date form that represents the Sunday on or before
16960 the input date. With a numeric prefix argument, it can be made to
16961 use any day of the week as the starting day; the argument must be in
16962 the range from 0 (Sunday) to 6 (Saturday). This function always
16963 subtracts between 0 and 6 days from the input date.
16964
16965 Here's an example use of @code{newweek}: Find the date of the next
16966 Wednesday after a given date. Using @kbd{M-3 t W} or @samp{newweek(d, 3)}
16967 will give you the @emph{preceding} Wednesday, so @samp{newweek(d+7, 3)}
16968 will give you the following Wednesday. A further look at the definition
16969 of @code{newweek} shows that if the input date is itself a Wednesday,
16970 this formula will return the Wednesday one week in the future. An
16971 exercise for the reader is to modify this formula to yield the same day
16972 if the input is already a Wednesday. Another interesting exercise is
16973 to preserve the time-of-day portion of the input (@code{newweek} resets
16974 the time to midnight; hint:@: how can @code{newweek} be defined in terms
16975 of the @code{weekday} function?).
16976
16977 @ignore
16978 @starindex
16979 @end ignore
16980 @tindex pwday
16981 The @samp{pwday(@var{date})} function (not on any key) computes the
16982 day-of-month number of the Sunday on or before @var{date}. With
16983 two arguments, @samp{pwday(@var{date}, @var{day})} computes the day
16984 number of the Sunday on or before day number @var{day} of the month
16985 specified by @var{date}. The @var{day} must be in the range from
16986 7 to 31; if the day number is greater than the actual number of days
16987 in the month, the true number of days is used instead. Thus
16988 @samp{pwday(@var{date}, 7)} finds the first Sunday of the month, and
16989 @samp{pwday(@var{date}, 31)} finds the last Sunday of the month.
16990 With a third @var{weekday} argument, @code{pwday} can be made to look
16991 for any day of the week instead of Sunday.
16992
16993 @kindex t I
16994 @pindex calc-inc-month
16995 @tindex incmonth
16996 The @kbd{t I} (@code{calc-inc-month}) [@code{incmonth}] command
16997 increases a date form by one month, or by an arbitrary number of
16998 months specified by a numeric prefix argument. The time portion,
16999 if any, of the date form stays the same. The day also stays the
17000 same, except that if the new month has fewer days the day
17001 number may be reduced to lie in the valid range. For example,
17002 @samp{incmonth(<Jan 31, 1991>)} produces @samp{<Feb 28, 1991>}.
17003 Because of this, @kbd{t I t I} and @kbd{M-2 t I} do not always give
17004 the same results (@samp{<Mar 28, 1991>} versus @samp{<Mar 31, 1991>}
17005 in this case).
17006
17007 @ignore
17008 @starindex
17009 @end ignore
17010 @tindex incyear
17011 The @samp{incyear(@var{date}, @var{step})} function increases
17012 a date form by the specified number of years, which may be
17013 any positive or negative integer. Note that @samp{incyear(d, n)}
17014 is equivalent to @w{@samp{incmonth(d, 12*n)}}, but these do not have
17015 simple equivalents in terms of day arithmetic because
17016 months and years have varying lengths. If the @var{step}
17017 argument is omitted, 1 year is assumed. There is no keyboard
17018 command for this function; use @kbd{C-u 12 t I} instead.
17019
17020 There is no @code{newday} function at all because @kbd{F} [@code{floor}]
17021 serves this purpose. Similarly, instead of @code{incday} and
17022 @code{incweek} simply use @expr{d + n} or @expr{d + 7 n}.
17023
17024 @xref{Basic Arithmetic}, for the @kbd{f ]} [@code{incr}] command
17025 which can adjust a date/time form by a certain number of seconds.
17026
17027 @node Business Days, Time Zones, Date Functions, Date Arithmetic
17028 @subsection Business Days
17029
17030 @noindent
17031 Often time is measured in ``business days'' or ``working days,''
17032 where weekends and holidays are skipped. Calc's normal date
17033 arithmetic functions use calendar days, so that subtracting two
17034 consecutive Mondays will yield a difference of 7 days. By contrast,
17035 subtracting two consecutive Mondays would yield 5 business days
17036 (assuming two-day weekends and the absence of holidays).
17037
17038 @kindex t +
17039 @kindex t -
17040 @tindex badd
17041 @tindex bsub
17042 @pindex calc-business-days-plus
17043 @pindex calc-business-days-minus
17044 The @kbd{t +} (@code{calc-business-days-plus}) [@code{badd}]
17045 and @kbd{t -} (@code{calc-business-days-minus}) [@code{bsub}]
17046 commands perform arithmetic using business days. For @kbd{t +},
17047 one argument must be a date form and the other must be a real
17048 number (positive or negative). If the number is not an integer,
17049 then a certain amount of time is added as well as a number of
17050 days; for example, adding 0.5 business days to a time in Friday
17051 evening will produce a time in Monday morning. It is also
17052 possible to add an HMS form; adding @samp{12@@ 0' 0"} also adds
17053 half a business day. For @kbd{t -}, the arguments are either a
17054 date form and a number or HMS form, or two date forms, in which
17055 case the result is the number of business days between the two
17056 dates.
17057
17058 @cindex @code{Holidays} variable
17059 @vindex Holidays
17060 By default, Calc considers any day that is not a Saturday or
17061 Sunday to be a business day. You can define any number of
17062 additional holidays by editing the variable @code{Holidays}.
17063 (There is an @w{@kbd{s H}} convenience command for editing this
17064 variable.) Initially, @code{Holidays} contains the vector
17065 @samp{[sat, sun]}. Entries in the @code{Holidays} vector may
17066 be any of the following kinds of objects:
17067
17068 @itemize @bullet
17069 @item
17070 Date forms (pure dates, not date/time forms). These specify
17071 particular days which are to be treated as holidays.
17072
17073 @item
17074 Intervals of date forms. These specify a range of days, all of
17075 which are holidays (e.g., Christmas week). @xref{Interval Forms}.
17076
17077 @item
17078 Nested vectors of date forms. Each date form in the vector is
17079 considered to be a holiday.
17080
17081 @item
17082 Any Calc formula which evaluates to one of the above three things.
17083 If the formula involves the variable @expr{y}, it stands for a
17084 yearly repeating holiday; @expr{y} will take on various year
17085 numbers like 1992. For example, @samp{date(y, 12, 25)} specifies
17086 Christmas day, and @samp{newweek(date(y, 11, 7), 4) + 21} specifies
17087 Thanksgiving (which is held on the fourth Thursday of November).
17088 If the formula involves the variable @expr{m}, that variable
17089 takes on month numbers from 1 to 12: @samp{date(y, m, 15)} is
17090 a holiday that takes place on the 15th of every month.
17091
17092 @item
17093 A weekday name, such as @code{sat} or @code{sun}. This is really
17094 a variable whose name is a three-letter, lower-case day name.
17095
17096 @item
17097 An interval of year numbers (integers). This specifies the span of
17098 years over which this holiday list is to be considered valid. Any
17099 business-day arithmetic that goes outside this range will result
17100 in an error message. Use this if you are including an explicit
17101 list of holidays, rather than a formula to generate them, and you
17102 want to make sure you don't accidentally go beyond the last point
17103 where the holidays you entered are complete. If there is no
17104 limiting interval in the @code{Holidays} vector, the default
17105 @samp{[1 .. 2737]} is used. (This is the absolute range of years
17106 for which Calc's business-day algorithms will operate.)
17107
17108 @item
17109 An interval of HMS forms. This specifies the span of hours that
17110 are to be considered one business day. For example, if this
17111 range is @samp{[9@@ 0' 0" .. 17@@ 0' 0"]} (i.e., 9am to 5pm), then
17112 the business day is only eight hours long, so that @kbd{1.5 t +}
17113 on @samp{<4:00pm Fri Dec 13, 1991>} will add one business day and
17114 four business hours to produce @samp{<12:00pm Tue Dec 17, 1991>}.
17115 Likewise, @kbd{t -} will now express differences in time as
17116 fractions of an eight-hour day. Times before 9am will be treated
17117 as 9am by business date arithmetic, and times at or after 5pm will
17118 be treated as 4:59:59pm. If there is no HMS interval in @code{Holidays},
17119 the full 24-hour day @samp{[0@ 0' 0" .. 24@ 0' 0"]} is assumed.
17120 (Regardless of the type of bounds you specify, the interval is
17121 treated as inclusive on the low end and exclusive on the high end,
17122 so that the work day goes from 9am up to, but not including, 5pm.)
17123 @end itemize
17124
17125 If the @code{Holidays} vector is empty, then @kbd{t +} and
17126 @kbd{t -} will act just like @kbd{+} and @kbd{-} because there will
17127 then be no difference between business days and calendar days.
17128
17129 Calc expands the intervals and formulas you give into a complete
17130 list of holidays for internal use. This is done mainly to make
17131 sure it can detect multiple holidays. (For example,
17132 @samp{<Jan 1, 1989>} is both New Year's Day and a Sunday, but
17133 Calc's algorithms take care to count it only once when figuring
17134 the number of holidays between two dates.)
17135
17136 Since the complete list of holidays for all the years from 1 to
17137 2737 would be huge, Calc actually computes only the part of the
17138 list between the smallest and largest years that have been involved
17139 in business-day calculations so far. Normally, you won't have to
17140 worry about this. Keep in mind, however, that if you do one
17141 calculation for 1992, and another for 1792, even if both involve
17142 only a small range of years, Calc will still work out all the
17143 holidays that fall in that 200-year span.
17144
17145 If you add a (positive) number of days to a date form that falls on a
17146 weekend or holiday, the date form is treated as if it were the most
17147 recent business day. (Thus adding one business day to a Friday,
17148 Saturday, or Sunday will all yield the following Monday.) If you
17149 subtract a number of days from a weekend or holiday, the date is
17150 effectively on the following business day. (So subtracting one business
17151 day from Saturday, Sunday, or Monday yields the preceding Friday.) The
17152 difference between two dates one or both of which fall on holidays
17153 equals the number of actual business days between them. These
17154 conventions are consistent in the sense that, if you add @var{n}
17155 business days to any date, the difference between the result and the
17156 original date will come out to @var{n} business days. (It can't be
17157 completely consistent though; a subtraction followed by an addition
17158 might come out a bit differently, since @kbd{t +} is incapable of
17159 producing a date that falls on a weekend or holiday.)
17160
17161 @ignore
17162 @starindex
17163 @end ignore
17164 @tindex holiday
17165 There is a @code{holiday} function, not on any keys, that takes
17166 any date form and returns 1 if that date falls on a weekend or
17167 holiday, as defined in @code{Holidays}, or 0 if the date is a
17168 business day.
17169
17170 @node Time Zones, , Business Days, Date Arithmetic
17171 @subsection Time Zones
17172
17173 @noindent
17174 @cindex Time zones
17175 @cindex Daylight savings time
17176 Time zones and daylight savings time are a complicated business.
17177 The conversions to and from Julian and Unix-style dates automatically
17178 compute the correct time zone and daylight savings adjustment to use,
17179 provided they can figure out this information. This section describes
17180 Calc's time zone adjustment algorithm in detail, in case you want to
17181 do conversions in different time zones or in case Calc's algorithms
17182 can't determine the right correction to use.
17183
17184 Adjustments for time zones and daylight savings time are done by
17185 @kbd{t U}, @kbd{t J}, @kbd{t N}, and @kbd{t C}, but not by any other
17186 commands. In particular, @samp{<may 1 1991> - <apr 1 1991>} evaluates
17187 to exactly 30 days even though there is a daylight-savings
17188 transition in between. This is also true for Julian pure dates:
17189 @samp{julian(<may 1 1991>) - julian(<apr 1 1991>)}. But Julian
17190 and Unix date/times will adjust for daylight savings time:
17191 @samp{julian(<12am may 1 1991>) - julian(<12am apr 1 1991>)}
17192 evaluates to @samp{29.95834} (that's 29 days and 23 hours)
17193 because one hour was lost when daylight savings commenced on
17194 April 7, 1991.
17195
17196 In brief, the idiom @samp{julian(@var{date1}) - julian(@var{date2})}
17197 computes the actual number of 24-hour periods between two dates, whereas
17198 @samp{@var{date1} - @var{date2}} computes the number of calendar
17199 days between two dates without taking daylight savings into account.
17200
17201 @pindex calc-time-zone
17202 @ignore
17203 @starindex
17204 @end ignore
17205 @tindex tzone
17206 The @code{calc-time-zone} [@code{tzone}] command converts the time
17207 zone specified by its numeric prefix argument into a number of
17208 seconds difference from Greenwich mean time (GMT). If the argument
17209 is a number, the result is simply that value multiplied by 3600.
17210 Typical arguments for North America are 5 (Eastern) or 8 (Pacific). If
17211 Daylight Savings time is in effect, one hour should be subtracted from
17212 the normal difference.
17213
17214 If you give a prefix of plain @kbd{C-u}, @code{calc-time-zone} (like other
17215 date arithmetic commands that include a time zone argument) takes the
17216 zone argument from the top of the stack. (In the case of @kbd{t J}
17217 and @kbd{t U}, the normal argument is then taken from the second-to-top
17218 stack position.) This allows you to give a non-integer time zone
17219 adjustment. The time-zone argument can also be an HMS form, or
17220 it can be a variable which is a time zone name in upper- or lower-case.
17221 For example @samp{tzone(PST) = tzone(8)} and @samp{tzone(pdt) = tzone(7)}
17222 (for Pacific standard and daylight savings times, respectively).
17223
17224 North American and European time zone names are defined as follows;
17225 note that for each time zone there is one name for standard time,
17226 another for daylight savings time, and a third for ``generalized'' time
17227 in which the daylight savings adjustment is computed from context.
17228
17229 @smallexample
17230 @group
17231 YST PST MST CST EST AST NST GMT WET MET MEZ
17232 9 8 7 6 5 4 3.5 0 -1 -2 -2
17233
17234 YDT PDT MDT CDT EDT ADT NDT BST WETDST METDST MESZ
17235 8 7 6 5 4 3 2.5 -1 -2 -3 -3
17236
17237 YGT PGT MGT CGT EGT AGT NGT BGT WEGT MEGT MEGZ
17238 9/8 8/7 7/6 6/5 5/4 4/3 3.5/2.5 0/-1 -1/-2 -2/-3 -2/-3
17239 @end group
17240 @end smallexample
17241
17242 @vindex math-tzone-names
17243 To define time zone names that do not appear in the above table,
17244 you must modify the Lisp variable @code{math-tzone-names}. This
17245 is a list of lists describing the different time zone names; its
17246 structure is best explained by an example. The three entries for
17247 Pacific Time look like this:
17248
17249 @smallexample
17250 @group
17251 ( ( "PST" 8 0 ) ; Name as an upper-case string, then standard
17252 ( "PDT" 8 -1 ) ; adjustment, then daylight savings adjustment.
17253 ( "PGT" 8 "PST" "PDT" ) ) ; Generalized time zone.
17254 @end group
17255 @end smallexample
17256
17257 @cindex @code{TimeZone} variable
17258 @vindex TimeZone
17259 With no arguments, @code{calc-time-zone} or @samp{tzone()} obtains an
17260 argument from the Calc variable @code{TimeZone} if a value has been
17261 stored for that variable. If not, Calc runs the Unix @samp{date}
17262 command and looks for one of the above time zone names in the output;
17263 if this does not succeed, @samp{tzone()} leaves itself unevaluated.
17264 The time zone name in the @samp{date} output may be followed by a signed
17265 adjustment, e.g., @samp{GMT+5} or @samp{GMT+0500} which specifies a
17266 number of hours and minutes to be added to the base time zone.
17267 Calc stores the time zone it finds into @code{TimeZone} to speed
17268 later calls to @samp{tzone()}.
17269
17270 The special time zone name @code{local} is equivalent to no argument,
17271 i.e., it uses the local time zone as obtained from the @code{date}
17272 command.
17273
17274 If the time zone name found is one of the standard or daylight
17275 savings zone names from the above table, and Calc's internal
17276 daylight savings algorithm says that time and zone are consistent
17277 (e.g., @code{PDT} accompanies a date that Calc's algorithm would also
17278 consider to be daylight savings, or @code{PST} accompanies a date
17279 that Calc would consider to be standard time), then Calc substitutes
17280 the corresponding generalized time zone (like @code{PGT}).
17281
17282 If your system does not have a suitable @samp{date} command, you
17283 may wish to put a @samp{(setq var-TimeZone ...)} in your Emacs
17284 initialization file to set the time zone. (Since you are interacting
17285 with the variable @code{TimeZone} directly from Emacs Lisp, the
17286 @code{var-} prefix needs to be present.) The easiest way to do
17287 this is to edit the @code{TimeZone} variable using Calc's @kbd{s T}
17288 command, then use the @kbd{s p} (@code{calc-permanent-variable})
17289 command to save the value of @code{TimeZone} permanently.
17290
17291 The @kbd{t J} and @code{t U} commands with no numeric prefix
17292 arguments do the same thing as @samp{tzone()}. If the current
17293 time zone is a generalized time zone, e.g., @code{EGT}, Calc
17294 examines the date being converted to tell whether to use standard
17295 or daylight savings time. But if the current time zone is explicit,
17296 e.g., @code{EST} or @code{EDT}, then that adjustment is used exactly
17297 and Calc's daylight savings algorithm is not consulted.
17298
17299 Some places don't follow the usual rules for daylight savings time.
17300 The state of Arizona, for example, does not observe daylight savings
17301 time. If you run Calc during the winter season in Arizona, the
17302 Unix @code{date} command will report @code{MST} time zone, which
17303 Calc will change to @code{MGT}. If you then convert a time that
17304 lies in the summer months, Calc will apply an incorrect daylight
17305 savings time adjustment. To avoid this, set your @code{TimeZone}
17306 variable explicitly to @code{MST} to force the use of standard,
17307 non-daylight-savings time.
17308
17309 @vindex math-daylight-savings-hook
17310 @findex math-std-daylight-savings
17311 By default Calc always considers daylight savings time to begin at
17312 2 a.m.@: on the first Sunday of April, and to end at 2 a.m.@: on the
17313 last Sunday of October. This is the rule that has been in effect
17314 in North America since 1987. If you are in a country that uses
17315 different rules for computing daylight savings time, you have two
17316 choices: Write your own daylight savings hook, or control time
17317 zones explicitly by setting the @code{TimeZone} variable and/or
17318 always giving a time-zone argument for the conversion functions.
17319
17320 The Lisp variable @code{math-daylight-savings-hook} holds the
17321 name of a function that is used to compute the daylight savings
17322 adjustment for a given date. The default is
17323 @code{math-std-daylight-savings}, which computes an adjustment
17324 (either 0 or @mathit{-1}) using the North American rules given above.
17325
17326 The daylight savings hook function is called with four arguments:
17327 The date, as a floating-point number in standard Calc format;
17328 a six-element list of the date decomposed into year, month, day,
17329 hour, minute, and second, respectively; a string which contains
17330 the generalized time zone name in upper-case, e.g., @code{"WEGT"};
17331 and a special adjustment to be applied to the hour value when
17332 converting into a generalized time zone (see below).
17333
17334 @findex math-prev-weekday-in-month
17335 The Lisp function @code{math-prev-weekday-in-month} is useful for
17336 daylight savings computations. This is an internal version of
17337 the user-level @code{pwday} function described in the previous
17338 section. It takes four arguments: The floating-point date value,
17339 the corresponding six-element date list, the day-of-month number,
17340 and the weekday number (0-6).
17341
17342 The default daylight savings hook ignores the time zone name, but a
17343 more sophisticated hook could use different algorithms for different
17344 time zones. It would also be possible to use different algorithms
17345 depending on the year number, but the default hook always uses the
17346 algorithm for 1987 and later. Here is a listing of the default
17347 daylight savings hook:
17348
17349 @smallexample
17350 (defun math-std-daylight-savings (date dt zone bump)
17351 (cond ((< (nth 1 dt) 4) 0)
17352 ((= (nth 1 dt) 4)
17353 (let ((sunday (math-prev-weekday-in-month date dt 7 0)))
17354 (cond ((< (nth 2 dt) sunday) 0)
17355 ((= (nth 2 dt) sunday)
17356 (if (>= (nth 3 dt) (+ 3 bump)) -1 0))
17357 (t -1))))
17358 ((< (nth 1 dt) 10) -1)
17359 ((= (nth 1 dt) 10)
17360 (let ((sunday (math-prev-weekday-in-month date dt 31 0)))
17361 (cond ((< (nth 2 dt) sunday) -1)
17362 ((= (nth 2 dt) sunday)
17363 (if (>= (nth 3 dt) (+ 2 bump)) 0 -1))
17364 (t 0))))
17365 (t 0))
17366 )
17367 @end smallexample
17368
17369 @noindent
17370 The @code{bump} parameter is equal to zero when Calc is converting
17371 from a date form in a generalized time zone into a GMT date value.
17372 It is @mathit{-1} when Calc is converting in the other direction. The
17373 adjustments shown above ensure that the conversion behaves correctly
17374 and reasonably around the 2 a.m.@: transition in each direction.
17375
17376 There is a ``missing'' hour between 2 a.m.@: and 3 a.m.@: at the
17377 beginning of daylight savings time; converting a date/time form that
17378 falls in this hour results in a time value for the following hour,
17379 from 3 a.m.@: to 4 a.m. At the end of daylight savings time, the
17380 hour from 1 a.m.@: to 2 a.m.@: repeats itself; converting a date/time
17381 form that falls in in this hour results in a time value for the first
17382 manifestation of that time (@emph{not} the one that occurs one hour later).
17383
17384 If @code{math-daylight-savings-hook} is @code{nil}, then the
17385 daylight savings adjustment is always taken to be zero.
17386
17387 In algebraic formulas, @samp{tzone(@var{zone}, @var{date})}
17388 computes the time zone adjustment for a given zone name at a
17389 given date. The @var{date} is ignored unless @var{zone} is a
17390 generalized time zone. If @var{date} is a date form, the
17391 daylight savings computation is applied to it as it appears.
17392 If @var{date} is a numeric date value, it is adjusted for the
17393 daylight-savings version of @var{zone} before being given to
17394 the daylight savings hook. This odd-sounding rule ensures
17395 that the daylight-savings computation is always done in
17396 local time, not in the GMT time that a numeric @var{date}
17397 is typically represented in.
17398
17399 @ignore
17400 @starindex
17401 @end ignore
17402 @tindex dsadj
17403 The @samp{dsadj(@var{date}, @var{zone})} function computes the
17404 daylight savings adjustment that is appropriate for @var{date} in
17405 time zone @var{zone}. If @var{zone} is explicitly in or not in
17406 daylight savings time (e.g., @code{PDT} or @code{PST}) the
17407 @var{date} is ignored. If @var{zone} is a generalized time zone,
17408 the algorithms described above are used. If @var{zone} is omitted,
17409 the computation is done for the current time zone.
17410
17411 @xref{Reporting Bugs}, for the address of Calc's author, if you
17412 should wish to contribute your improved versions of
17413 @code{math-tzone-names} and @code{math-daylight-savings-hook}
17414 to the Calc distribution.
17415
17416 @node Financial Functions, Binary Functions, Date Arithmetic, Arithmetic
17417 @section Financial Functions
17418
17419 @noindent
17420 Calc's financial or business functions use the @kbd{b} prefix
17421 key followed by a shifted letter. (The @kbd{b} prefix followed by
17422 a lower-case letter is used for operations on binary numbers.)
17423
17424 Note that the rate and the number of intervals given to these
17425 functions must be on the same time scale, e.g., both months or
17426 both years. Mixing an annual interest rate with a time expressed
17427 in months will give you very wrong answers!
17428
17429 It is wise to compute these functions to a higher precision than
17430 you really need, just to make sure your answer is correct to the
17431 last penny; also, you may wish to check the definitions at the end
17432 of this section to make sure the functions have the meaning you expect.
17433
17434 @menu
17435 * Percentages::
17436 * Future Value::
17437 * Present Value::
17438 * Related Financial Functions::
17439 * Depreciation Functions::
17440 * Definitions of Financial Functions::
17441 @end menu
17442
17443 @node Percentages, Future Value, Financial Functions, Financial Functions
17444 @subsection Percentages
17445
17446 @kindex M-%
17447 @pindex calc-percent
17448 @tindex %
17449 @tindex percent
17450 The @kbd{M-%} (@code{calc-percent}) command takes a percentage value,
17451 say 5.4, and converts it to an equivalent actual number. For example,
17452 @kbd{5.4 M-%} enters 0.054 on the stack. (That's the @key{META} or
17453 @key{ESC} key combined with @kbd{%}.)
17454
17455 Actually, @kbd{M-%} creates a formula of the form @samp{5.4%}.
17456 You can enter @samp{5.4%} yourself during algebraic entry. The
17457 @samp{%} operator simply means, ``the preceding value divided by
17458 100.'' The @samp{%} operator has very high precedence, so that
17459 @samp{1+8%} is interpreted as @samp{1+(8%)}, not as @samp{(1+8)%}.
17460 (The @samp{%} operator is just a postfix notation for the
17461 @code{percent} function, just like @samp{20!} is the notation for
17462 @samp{fact(20)}, or twenty-factorial.)
17463
17464 The formula @samp{5.4%} would normally evaluate immediately to
17465 0.054, but the @kbd{M-%} command suppresses evaluation as it puts
17466 the formula onto the stack. However, the next Calc command that
17467 uses the formula @samp{5.4%} will evaluate it as its first step.
17468 The net effect is that you get to look at @samp{5.4%} on the stack,
17469 but Calc commands see it as @samp{0.054}, which is what they expect.
17470
17471 In particular, @samp{5.4%} and @samp{0.054} are suitable values
17472 for the @var{rate} arguments of the various financial functions,
17473 but the number @samp{5.4} is probably @emph{not} suitable---it
17474 represents a rate of 540 percent!
17475
17476 The key sequence @kbd{M-% *} effectively means ``percent-of.''
17477 For example, @kbd{68 @key{RET} 25 M-% *} computes 17, which is 25% of
17478 68 (and also 68% of 25, which comes out to the same thing).
17479
17480 @kindex c %
17481 @pindex calc-convert-percent
17482 The @kbd{c %} (@code{calc-convert-percent}) command converts the
17483 value on the top of the stack from numeric to percentage form.
17484 For example, if 0.08 is on the stack, @kbd{c %} converts it to
17485 @samp{8%}. The quantity is the same, it's just represented
17486 differently. (Contrast this with @kbd{M-%}, which would convert
17487 this number to @samp{0.08%}.) The @kbd{=} key is a convenient way
17488 to convert a formula like @samp{8%} back to numeric form, 0.08.
17489
17490 To compute what percentage one quantity is of another quantity,
17491 use @kbd{/ c %}. For example, @w{@kbd{17 @key{RET} 68 / c %}} displays
17492 @samp{25%}.
17493
17494 @kindex b %
17495 @pindex calc-percent-change
17496 @tindex relch
17497 The @kbd{b %} (@code{calc-percent-change}) [@code{relch}] command
17498 calculates the percentage change from one number to another.
17499 For example, @kbd{40 @key{RET} 50 b %} produces the answer @samp{25%},
17500 since 50 is 25% larger than 40. A negative result represents a
17501 decrease: @kbd{50 @key{RET} 40 b %} produces @samp{-20%}, since 40 is
17502 20% smaller than 50. (The answers are different in magnitude
17503 because, in the first case, we're increasing by 25% of 40, but
17504 in the second case, we're decreasing by 20% of 50.) The effect
17505 of @kbd{40 @key{RET} 50 b %} is to compute @expr{(50-40)/40}, converting
17506 the answer to percentage form as if by @kbd{c %}.
17507
17508 @node Future Value, Present Value, Percentages, Financial Functions
17509 @subsection Future Value
17510
17511 @noindent
17512 @kindex b F
17513 @pindex calc-fin-fv
17514 @tindex fv
17515 The @kbd{b F} (@code{calc-fin-fv}) [@code{fv}] command computes
17516 the future value of an investment. It takes three arguments
17517 from the stack: @samp{fv(@var{rate}, @var{n}, @var{payment})}.
17518 If you give payments of @var{payment} every year for @var{n}
17519 years, and the money you have paid earns interest at @var{rate} per
17520 year, then this function tells you what your investment would be
17521 worth at the end of the period. (The actual interval doesn't
17522 have to be years, as long as @var{n} and @var{rate} are expressed
17523 in terms of the same intervals.) This function assumes payments
17524 occur at the @emph{end} of each interval.
17525
17526 @kindex I b F
17527 @tindex fvb
17528 The @kbd{I b F} [@code{fvb}] command does the same computation,
17529 but assuming your payments are at the beginning of each interval.
17530 Suppose you plan to deposit $1000 per year in a savings account
17531 earning 5.4% interest, starting right now. How much will be
17532 in the account after five years? @code{fvb(5.4%, 5, 1000) = 5870.73}.
17533 Thus you will have earned $870 worth of interest over the years.
17534 Using the stack, this calculation would have been
17535 @kbd{5.4 M-% 5 @key{RET} 1000 I b F}. Note that the rate is expressed
17536 as a number between 0 and 1, @emph{not} as a percentage.
17537
17538 @kindex H b F
17539 @tindex fvl
17540 The @kbd{H b F} [@code{fvl}] command computes the future value
17541 of an initial lump sum investment. Suppose you could deposit
17542 those five thousand dollars in the bank right now; how much would
17543 they be worth in five years? @code{fvl(5.4%, 5, 5000) = 6503.89}.
17544
17545 The algebraic functions @code{fv} and @code{fvb} accept an optional
17546 fourth argument, which is used as an initial lump sum in the sense
17547 of @code{fvl}. In other words, @code{fv(@var{rate}, @var{n},
17548 @var{payment}, @var{initial}) = fv(@var{rate}, @var{n}, @var{payment})
17549 + fvl(@var{rate}, @var{n}, @var{initial})}.
17550
17551 To illustrate the relationships between these functions, we could
17552 do the @code{fvb} calculation ``by hand'' using @code{fvl}. The
17553 final balance will be the sum of the contributions of our five
17554 deposits at various times. The first deposit earns interest for
17555 five years: @code{fvl(5.4%, 5, 1000) = 1300.78}. The second
17556 deposit only earns interest for four years: @code{fvl(5.4%, 4, 1000) =
17557 1234.13}. And so on down to the last deposit, which earns one
17558 year's interest: @code{fvl(5.4%, 1, 1000) = 1054.00}. The sum of
17559 these five values is, sure enough, $5870.73, just as was computed
17560 by @code{fvb} directly.
17561
17562 What does @code{fv(5.4%, 5, 1000) = 5569.96} mean? The payments
17563 are now at the ends of the periods. The end of one year is the same
17564 as the beginning of the next, so what this really means is that we've
17565 lost the payment at year zero (which contributed $1300.78), but we're
17566 now counting the payment at year five (which, since it didn't have
17567 a chance to earn interest, counts as $1000). Indeed, @expr{5569.96 =
17568 5870.73 - 1300.78 + 1000} (give or take a bit of roundoff error).
17569
17570 @node Present Value, Related Financial Functions, Future Value, Financial Functions
17571 @subsection Present Value
17572
17573 @noindent
17574 @kindex b P
17575 @pindex calc-fin-pv
17576 @tindex pv
17577 The @kbd{b P} (@code{calc-fin-pv}) [@code{pv}] command computes
17578 the present value of an investment. Like @code{fv}, it takes
17579 three arguments: @code{pv(@var{rate}, @var{n}, @var{payment})}.
17580 It computes the present value of a series of regular payments.
17581 Suppose you have the chance to make an investment that will
17582 pay $2000 per year over the next four years; as you receive
17583 these payments you can put them in the bank at 9% interest.
17584 You want to know whether it is better to make the investment, or
17585 to keep the money in the bank where it earns 9% interest right
17586 from the start. The calculation @code{pv(9%, 4, 2000)} gives the
17587 result 6479.44. If your initial investment must be less than this,
17588 say, $6000, then the investment is worthwhile. But if you had to
17589 put up $7000, then it would be better just to leave it in the bank.
17590
17591 Here is the interpretation of the result of @code{pv}: You are
17592 trying to compare the return from the investment you are
17593 considering, which is @code{fv(9%, 4, 2000) = 9146.26}, with
17594 the return from leaving the money in the bank, which is
17595 @code{fvl(9%, 4, @var{x})} where @var{x} is the amount of money
17596 you would have to put up in advance. The @code{pv} function
17597 finds the break-even point, @expr{x = 6479.44}, at which
17598 @code{fvl(9%, 4, 6479.44)} is also equal to 9146.26. This is
17599 the largest amount you should be willing to invest.
17600
17601 @kindex I b P
17602 @tindex pvb
17603 The @kbd{I b P} [@code{pvb}] command solves the same problem,
17604 but with payments occurring at the beginning of each interval.
17605 It has the same relationship to @code{fvb} as @code{pv} has
17606 to @code{fv}. For example @code{pvb(9%, 4, 2000) = 7062.59},
17607 a larger number than @code{pv} produced because we get to start
17608 earning interest on the return from our investment sooner.
17609
17610 @kindex H b P
17611 @tindex pvl
17612 The @kbd{H b P} [@code{pvl}] command computes the present value of
17613 an investment that will pay off in one lump sum at the end of the
17614 period. For example, if we get our $8000 all at the end of the
17615 four years, @code{pvl(9%, 4, 8000) = 5667.40}. This is much
17616 less than @code{pv} reported, because we don't earn any interest
17617 on the return from this investment. Note that @code{pvl} and
17618 @code{fvl} are simple inverses: @code{fvl(9%, 4, 5667.40) = 8000}.
17619
17620 You can give an optional fourth lump-sum argument to @code{pv}
17621 and @code{pvb}; this is handled in exactly the same way as the
17622 fourth argument for @code{fv} and @code{fvb}.
17623
17624 @kindex b N
17625 @pindex calc-fin-npv
17626 @tindex npv
17627 The @kbd{b N} (@code{calc-fin-npv}) [@code{npv}] command computes
17628 the net present value of a series of irregular investments.
17629 The first argument is the interest rate. The second argument is
17630 a vector which represents the expected return from the investment
17631 at the end of each interval. For example, if the rate represents
17632 a yearly interest rate, then the vector elements are the return
17633 from the first year, second year, and so on.
17634
17635 Thus, @code{npv(9%, [2000,2000,2000,2000]) = pv(9%, 4, 2000) = 6479.44}.
17636 Obviously this function is more interesting when the payments are
17637 not all the same!
17638
17639 The @code{npv} function can actually have two or more arguments.
17640 Multiple arguments are interpreted in the same way as for the
17641 vector statistical functions like @code{vsum}.
17642 @xref{Single-Variable Statistics}. Basically, if there are several
17643 payment arguments, each either a vector or a plain number, all these
17644 values are collected left-to-right into the complete list of payments.
17645 A numeric prefix argument on the @kbd{b N} command says how many
17646 payment values or vectors to take from the stack.
17647
17648 @kindex I b N
17649 @tindex npvb
17650 The @kbd{I b N} [@code{npvb}] command computes the net present
17651 value where payments occur at the beginning of each interval
17652 rather than at the end.
17653
17654 @node Related Financial Functions, Depreciation Functions, Present Value, Financial Functions
17655 @subsection Related Financial Functions
17656
17657 @noindent
17658 The functions in this section are basically inverses of the
17659 present value functions with respect to the various arguments.
17660
17661 @kindex b M
17662 @pindex calc-fin-pmt
17663 @tindex pmt
17664 The @kbd{b M} (@code{calc-fin-pmt}) [@code{pmt}] command computes
17665 the amount of periodic payment necessary to amortize a loan.
17666 Thus @code{pmt(@var{rate}, @var{n}, @var{amount})} equals the
17667 value of @var{payment} such that @code{pv(@var{rate}, @var{n},
17668 @var{payment}) = @var{amount}}.
17669
17670 @kindex I b M
17671 @tindex pmtb
17672 The @kbd{I b M} [@code{pmtb}] command does the same computation
17673 but using @code{pvb} instead of @code{pv}. Like @code{pv} and
17674 @code{pvb}, these functions can also take a fourth argument which
17675 represents an initial lump-sum investment.
17676
17677 @kindex H b M
17678 The @kbd{H b M} key just invokes the @code{fvl} function, which is
17679 the inverse of @code{pvl}. There is no explicit @code{pmtl} function.
17680
17681 @kindex b #
17682 @pindex calc-fin-nper
17683 @tindex nper
17684 The @kbd{b #} (@code{calc-fin-nper}) [@code{nper}] command computes
17685 the number of regular payments necessary to amortize a loan.
17686 Thus @code{nper(@var{rate}, @var{payment}, @var{amount})} equals
17687 the value of @var{n} such that @code{pv(@var{rate}, @var{n},
17688 @var{payment}) = @var{amount}}. If @var{payment} is too small
17689 ever to amortize a loan for @var{amount} at interest rate @var{rate},
17690 the @code{nper} function is left in symbolic form.
17691
17692 @kindex I b #
17693 @tindex nperb
17694 The @kbd{I b #} [@code{nperb}] command does the same computation
17695 but using @code{pvb} instead of @code{pv}. You can give a fourth
17696 lump-sum argument to these functions, but the computation will be
17697 rather slow in the four-argument case.
17698
17699 @kindex H b #
17700 @tindex nperl
17701 The @kbd{H b #} [@code{nperl}] command does the same computation
17702 using @code{pvl}. By exchanging @var{payment} and @var{amount} you
17703 can also get the solution for @code{fvl}. For example,
17704 @code{nperl(8%, 2000, 1000) = 9.006}, so if you place $1000 in a
17705 bank account earning 8%, it will take nine years to grow to $2000.
17706
17707 @kindex b T
17708 @pindex calc-fin-rate
17709 @tindex rate
17710 The @kbd{b T} (@code{calc-fin-rate}) [@code{rate}] command computes
17711 the rate of return on an investment. This is also an inverse of @code{pv}:
17712 @code{rate(@var{n}, @var{payment}, @var{amount})} computes the value of
17713 @var{rate} such that @code{pv(@var{rate}, @var{n}, @var{payment}) =
17714 @var{amount}}. The result is expressed as a formula like @samp{6.3%}.
17715
17716 @kindex I b T
17717 @kindex H b T
17718 @tindex rateb
17719 @tindex ratel
17720 The @kbd{I b T} [@code{rateb}] and @kbd{H b T} [@code{ratel}]
17721 commands solve the analogous equations with @code{pvb} or @code{pvl}
17722 in place of @code{pv}. Also, @code{rate} and @code{rateb} can
17723 accept an optional fourth argument just like @code{pv} and @code{pvb}.
17724 To redo the above example from a different perspective,
17725 @code{ratel(9, 2000, 1000) = 8.00597%}, which says you will need an
17726 interest rate of 8% in order to double your account in nine years.
17727
17728 @kindex b I
17729 @pindex calc-fin-irr
17730 @tindex irr
17731 The @kbd{b I} (@code{calc-fin-irr}) [@code{irr}] command is the
17732 analogous function to @code{rate} but for net present value.
17733 Its argument is a vector of payments. Thus @code{irr(@var{payments})}
17734 computes the @var{rate} such that @code{npv(@var{rate}, @var{payments}) = 0};
17735 this rate is known as the @dfn{internal rate of return}.
17736
17737 @kindex I b I
17738 @tindex irrb
17739 The @kbd{I b I} [@code{irrb}] command computes the internal rate of
17740 return assuming payments occur at the beginning of each period.
17741
17742 @node Depreciation Functions, Definitions of Financial Functions, Related Financial Functions, Financial Functions
17743 @subsection Depreciation Functions
17744
17745 @noindent
17746 The functions in this section calculate @dfn{depreciation}, which is
17747 the amount of value that a possession loses over time. These functions
17748 are characterized by three parameters: @var{cost}, the original cost
17749 of the asset; @var{salvage}, the value the asset will have at the end
17750 of its expected ``useful life''; and @var{life}, the number of years
17751 (or other periods) of the expected useful life.
17752
17753 There are several methods for calculating depreciation that differ in
17754 the way they spread the depreciation over the lifetime of the asset.
17755
17756 @kindex b S
17757 @pindex calc-fin-sln
17758 @tindex sln
17759 The @kbd{b S} (@code{calc-fin-sln}) [@code{sln}] command computes the
17760 ``straight-line'' depreciation. In this method, the asset depreciates
17761 by the same amount every year (or period). For example,
17762 @samp{sln(12000, 2000, 5)} returns 2000. The asset costs $12000
17763 initially and will be worth $2000 after five years; it loses $2000
17764 per year.
17765
17766 @kindex b Y
17767 @pindex calc-fin-syd
17768 @tindex syd
17769 The @kbd{b Y} (@code{calc-fin-syd}) [@code{syd}] command computes the
17770 accelerated ``sum-of-years'-digits'' depreciation. Here the depreciation
17771 is higher during the early years of the asset's life. Since the
17772 depreciation is different each year, @kbd{b Y} takes a fourth @var{period}
17773 parameter which specifies which year is requested, from 1 to @var{life}.
17774 If @var{period} is outside this range, the @code{syd} function will
17775 return zero.
17776
17777 @kindex b D
17778 @pindex calc-fin-ddb
17779 @tindex ddb
17780 The @kbd{b D} (@code{calc-fin-ddb}) [@code{ddb}] command computes an
17781 accelerated depreciation using the double-declining balance method.
17782 It also takes a fourth @var{period} parameter.
17783
17784 For symmetry, the @code{sln} function will accept a @var{period}
17785 parameter as well, although it will ignore its value except that the
17786 return value will as usual be zero if @var{period} is out of range.
17787
17788 For example, pushing the vector @expr{[1,2,3,4,5]} (perhaps with @kbd{v x 5})
17789 and then mapping @kbd{V M ' [sln(12000,2000,5,$), syd(12000,2000,5,$),
17790 ddb(12000,2000,5,$)] @key{RET}} produces a matrix that allows us to compare
17791 the three depreciation methods:
17792
17793 @example
17794 @group
17795 [ [ 2000, 3333, 4800 ]
17796 [ 2000, 2667, 2880 ]
17797 [ 2000, 2000, 1728 ]
17798 [ 2000, 1333, 592 ]
17799 [ 2000, 667, 0 ] ]
17800 @end group
17801 @end example
17802
17803 @noindent
17804 (Values have been rounded to nearest integers in this figure.)
17805 We see that @code{sln} depreciates by the same amount each year,
17806 @kbd{syd} depreciates more at the beginning and less at the end,
17807 and @kbd{ddb} weights the depreciation even more toward the beginning.
17808
17809 Summing columns with @kbd{V R : +} yields @expr{[10000, 10000, 10000]};
17810 the total depreciation in any method is (by definition) the
17811 difference between the cost and the salvage value.
17812
17813 @node Definitions of Financial Functions, , Depreciation Functions, Financial Functions
17814 @subsection Definitions
17815
17816 @noindent
17817 For your reference, here are the actual formulas used to compute
17818 Calc's financial functions.
17819
17820 Calc will not evaluate a financial function unless the @var{rate} or
17821 @var{n} argument is known. However, @var{payment} or @var{amount} can
17822 be a variable. Calc expands these functions according to the
17823 formulas below for symbolic arguments only when you use the @kbd{a "}
17824 (@code{calc-expand-formula}) command, or when taking derivatives or
17825 integrals or solving equations involving the functions.
17826
17827 @ifinfo
17828 These formulas are shown using the conventions of Big display
17829 mode (@kbd{d B}); for example, the formula for @code{fv} written
17830 linearly is @samp{pmt * ((1 + rate)^n) - 1) / rate}.
17831
17832 @example
17833 n
17834 (1 + rate) - 1
17835 fv(rate, n, pmt) = pmt * ---------------
17836 rate
17837
17838 n
17839 ((1 + rate) - 1) (1 + rate)
17840 fvb(rate, n, pmt) = pmt * ----------------------------
17841 rate
17842
17843 n
17844 fvl(rate, n, pmt) = pmt * (1 + rate)
17845
17846 -n
17847 1 - (1 + rate)
17848 pv(rate, n, pmt) = pmt * ----------------
17849 rate
17850
17851 -n
17852 (1 - (1 + rate) ) (1 + rate)
17853 pvb(rate, n, pmt) = pmt * -----------------------------
17854 rate
17855
17856 -n
17857 pvl(rate, n, pmt) = pmt * (1 + rate)
17858
17859 -1 -2 -3
17860 npv(rate, [a, b, c]) = a*(1 + rate) + b*(1 + rate) + c*(1 + rate)
17861
17862 -1 -2
17863 npvb(rate, [a, b, c]) = a + b*(1 + rate) + c*(1 + rate)
17864
17865 -n
17866 (amt - x * (1 + rate) ) * rate
17867 pmt(rate, n, amt, x) = -------------------------------
17868 -n
17869 1 - (1 + rate)
17870
17871 -n
17872 (amt - x * (1 + rate) ) * rate
17873 pmtb(rate, n, amt, x) = -------------------------------
17874 -n
17875 (1 - (1 + rate) ) (1 + rate)
17876
17877 amt * rate
17878 nper(rate, pmt, amt) = - log(1 - ------------, 1 + rate)
17879 pmt
17880
17881 amt * rate
17882 nperb(rate, pmt, amt) = - log(1 - ---------------, 1 + rate)
17883 pmt * (1 + rate)
17884
17885 amt
17886 nperl(rate, pmt, amt) = - log(---, 1 + rate)
17887 pmt
17888
17889 1/n
17890 pmt
17891 ratel(n, pmt, amt) = ------ - 1
17892 1/n
17893 amt
17894
17895 cost - salv
17896 sln(cost, salv, life) = -----------
17897 life
17898
17899 (cost - salv) * (life - per + 1)
17900 syd(cost, salv, life, per) = --------------------------------
17901 life * (life + 1) / 2
17902
17903 book * 2
17904 ddb(cost, salv, life, per) = --------, book = cost - depreciation so far
17905 life
17906 @end example
17907 @end ifinfo
17908 @tex
17909 \turnoffactive
17910 $$ \code{fv}(r, n, p) = p { (1 + r)^n - 1 \over r } $$
17911 $$ \code{fvb}(r, n, p) = p { ((1 + r)^n - 1) (1 + r) \over r } $$
17912 $$ \code{fvl}(r, n, p) = p (1 + r)^n $$
17913 $$ \code{pv}(r, n, p) = p { 1 - (1 + r)^{-n} \over r } $$
17914 $$ \code{pvb}(r, n, p) = p { (1 - (1 + r)^{-n}) (1 + r) \over r } $$
17915 $$ \code{pvl}(r, n, p) = p (1 + r)^{-n} $$
17916 $$ \code{npv}(r, [a,b,c]) = a (1 + r)^{-1} + b (1 + r)^{-2} + c (1 + r)^{-3} $$
17917 $$ \code{npvb}(r, [a,b,c]) = a + b (1 + r)^{-1} + c (1 + r)^{-2} $$
17918 $$ \code{pmt}(r, n, a, x) = { (a - x (1 + r)^{-n}) r \over 1 - (1 + r)^{-n} }$$
17919 $$ \code{pmtb}(r, n, a, x) = { (a - x (1 + r)^{-n}) r \over
17920 (1 - (1 + r)^{-n}) (1 + r) } $$
17921 $$ \code{nper}(r, p, a) = -\code{log}(1 - { a r \over p }, 1 + r) $$
17922 $$ \code{nperb}(r, p, a) = -\code{log}(1 - { a r \over p (1 + r) }, 1 + r) $$
17923 $$ \code{nperl}(r, p, a) = -\code{log}({a \over p}, 1 + r) $$
17924 $$ \code{ratel}(n, p, a) = { p^{1/n} \over a^{1/n} } - 1 $$
17925 $$ \code{sln}(c, s, l) = { c - s \over l } $$
17926 $$ \code{syd}(c, s, l, p) = { (c - s) (l - p + 1) \over l (l+1) / 2 } $$
17927 $$ \code{ddb}(c, s, l, p) = { 2 (c - \hbox{depreciation so far}) \over l } $$
17928 @end tex
17929
17930 @noindent
17931 In @code{pmt} and @code{pmtb}, @expr{x=0} if omitted.
17932
17933 These functions accept any numeric objects, including error forms,
17934 intervals, and even (though not very usefully) complex numbers. The
17935 above formulas specify exactly the behavior of these functions with
17936 all sorts of inputs.
17937
17938 Note that if the first argument to the @code{log} in @code{nper} is
17939 negative, @code{nper} leaves itself in symbolic form rather than
17940 returning a (financially meaningless) complex number.
17941
17942 @samp{rate(num, pmt, amt)} solves the equation
17943 @samp{pv(rate, num, pmt) = amt} for @samp{rate} using @kbd{H a R}
17944 (@code{calc-find-root}), with the interval @samp{[.01% .. 100%]}
17945 for an initial guess. The @code{rateb} function is the same except
17946 that it uses @code{pvb}. Note that @code{ratel} can be solved
17947 directly; its formula is shown in the above list.
17948
17949 Similarly, @samp{irr(pmts)} solves the equation @samp{npv(rate, pmts) = 0}
17950 for @samp{rate}.
17951
17952 If you give a fourth argument to @code{nper} or @code{nperb}, Calc
17953 will also use @kbd{H a R} to solve the equation using an initial
17954 guess interval of @samp{[0 .. 100]}.
17955
17956 A fourth argument to @code{fv} simply sums the two components
17957 calculated from the above formulas for @code{fv} and @code{fvl}.
17958 The same is true of @code{fvb}, @code{pv}, and @code{pvb}.
17959
17960 The @kbd{ddb} function is computed iteratively; the ``book'' value
17961 starts out equal to @var{cost}, and decreases according to the above
17962 formula for the specified number of periods. If the book value
17963 would decrease below @var{salvage}, it only decreases to @var{salvage}
17964 and the depreciation is zero for all subsequent periods. The @code{ddb}
17965 function returns the amount the book value decreased in the specified
17966 period.
17967
17968 @node Binary Functions, , Financial Functions, Arithmetic
17969 @section Binary Number Functions
17970
17971 @noindent
17972 The commands in this chapter all use two-letter sequences beginning with
17973 the @kbd{b} prefix.
17974
17975 @cindex Binary numbers
17976 The ``binary'' operations actually work regardless of the currently
17977 displayed radix, although their results make the most sense in a radix
17978 like 2, 8, or 16 (as obtained by the @kbd{d 2}, @kbd{d 8}, or @w{@kbd{d 6}}
17979 commands, respectively). You may also wish to enable display of leading
17980 zeros with @kbd{d z}. @xref{Radix Modes}.
17981
17982 @cindex Word size for binary operations
17983 The Calculator maintains a current @dfn{word size} @expr{w}, an
17984 arbitrary positive or negative integer. For a positive word size, all
17985 of the binary operations described here operate modulo @expr{2^w}. In
17986 particular, negative arguments are converted to positive integers modulo
17987 @expr{2^w} by all binary functions.
17988
17989 If the word size is negative, binary operations produce 2's complement
17990 integers from
17991 @texline @math{-2^{-w-1}}
17992 @infoline @expr{-(2^(-w-1))}
17993 to
17994 @texline @math{2^{-w-1}-1}
17995 @infoline @expr{2^(-w-1)-1}
17996 inclusive. Either mode accepts inputs in any range; the sign of
17997 @expr{w} affects only the results produced.
17998
17999 @kindex b c
18000 @pindex calc-clip
18001 @tindex clip
18002 The @kbd{b c} (@code{calc-clip})
18003 [@code{clip}] command can be used to clip a number by reducing it modulo
18004 @expr{2^w}. The commands described in this chapter automatically clip
18005 their results to the current word size. Note that other operations like
18006 addition do not use the current word size, since integer addition
18007 generally is not ``binary.'' (However, @pxref{Simplification Modes},
18008 @code{calc-bin-simplify-mode}.) For example, with a word size of 8
18009 bits @kbd{b c} converts a number to the range 0 to 255; with a word
18010 size of @mathit{-8} @kbd{b c} converts to the range @mathit{-128} to 127.
18011
18012 @kindex b w
18013 @pindex calc-word-size
18014 The default word size is 32 bits. All operations except the shifts and
18015 rotates allow you to specify a different word size for that one
18016 operation by giving a numeric prefix argument: @kbd{C-u 8 b c} clips the
18017 top of stack to the range 0 to 255 regardless of the current word size.
18018 To set the word size permanently, use @kbd{b w} (@code{calc-word-size}).
18019 This command displays a prompt with the current word size; press @key{RET}
18020 immediately to keep this word size, or type a new word size at the prompt.
18021
18022 When the binary operations are written in symbolic form, they take an
18023 optional second (or third) word-size parameter. When a formula like
18024 @samp{and(a,b)} is finally evaluated, the word size current at that time
18025 will be used, but when @samp{and(a,b,-8)} is evaluated, a word size of
18026 @mathit{-8} will always be used. A symbolic binary function will be left
18027 in symbolic form unless the all of its argument(s) are integers or
18028 integer-valued floats.
18029
18030 If either or both arguments are modulo forms for which @expr{M} is a
18031 power of two, that power of two is taken as the word size unless a
18032 numeric prefix argument overrides it. The current word size is never
18033 consulted when modulo-power-of-two forms are involved.
18034
18035 @kindex b a
18036 @pindex calc-and
18037 @tindex and
18038 The @kbd{b a} (@code{calc-and}) [@code{and}] command computes the bitwise
18039 AND of the two numbers on the top of the stack. In other words, for each
18040 of the @expr{w} binary digits of the two numbers (pairwise), the corresponding
18041 bit of the result is 1 if and only if both input bits are 1:
18042 @samp{and(2#1100, 2#1010) = 2#1000}.
18043
18044 @kindex b o
18045 @pindex calc-or
18046 @tindex or
18047 The @kbd{b o} (@code{calc-or}) [@code{or}] command computes the bitwise
18048 inclusive OR of two numbers. A bit is 1 if either of the input bits, or
18049 both, are 1: @samp{or(2#1100, 2#1010) = 2#1110}.
18050
18051 @kindex b x
18052 @pindex calc-xor
18053 @tindex xor
18054 The @kbd{b x} (@code{calc-xor}) [@code{xor}] command computes the bitwise
18055 exclusive OR of two numbers. A bit is 1 if exactly one of the input bits
18056 is 1: @samp{xor(2#1100, 2#1010) = 2#0110}.
18057
18058 @kindex b d
18059 @pindex calc-diff
18060 @tindex diff
18061 The @kbd{b d} (@code{calc-diff}) [@code{diff}] command computes the bitwise
18062 difference of two numbers; this is defined by @samp{diff(a,b) = and(a,not(b))},
18063 so that @samp{diff(2#1100, 2#1010) = 2#0100}.
18064
18065 @kindex b n
18066 @pindex calc-not
18067 @tindex not
18068 The @kbd{b n} (@code{calc-not}) [@code{not}] command computes the bitwise
18069 NOT of a number. A bit is 1 if the input bit is 0 and vice-versa.
18070
18071 @kindex b l
18072 @pindex calc-lshift-binary
18073 @tindex lsh
18074 The @kbd{b l} (@code{calc-lshift-binary}) [@code{lsh}] command shifts a
18075 number left by one bit, or by the number of bits specified in the numeric
18076 prefix argument. A negative prefix argument performs a logical right shift,
18077 in which zeros are shifted in on the left. In symbolic form, @samp{lsh(a)}
18078 is short for @samp{lsh(a,1)}, which in turn is short for @samp{lsh(a,n,w)}.
18079 Bits shifted ``off the end,'' according to the current word size, are lost.
18080
18081 @kindex H b l
18082 @kindex H b r
18083 @ignore
18084 @mindex @idots
18085 @end ignore
18086 @kindex H b L
18087 @ignore
18088 @mindex @null
18089 @end ignore
18090 @kindex H b R
18091 @ignore
18092 @mindex @null
18093 @end ignore
18094 @kindex H b t
18095 The @kbd{H b l} command also does a left shift, but it takes two arguments
18096 from the stack (the value to shift, and, at top-of-stack, the number of
18097 bits to shift). This version interprets the prefix argument just like
18098 the regular binary operations, i.e., as a word size. The Hyperbolic flag
18099 has a similar effect on the rest of the binary shift and rotate commands.
18100
18101 @kindex b r
18102 @pindex calc-rshift-binary
18103 @tindex rsh
18104 The @kbd{b r} (@code{calc-rshift-binary}) [@code{rsh}] command shifts a
18105 number right by one bit, or by the number of bits specified in the numeric
18106 prefix argument: @samp{rsh(a,n) = lsh(a,-n)}.
18107
18108 @kindex b L
18109 @pindex calc-lshift-arith
18110 @tindex ash
18111 The @kbd{b L} (@code{calc-lshift-arith}) [@code{ash}] command shifts a
18112 number left. It is analogous to @code{lsh}, except that if the shift
18113 is rightward (the prefix argument is negative), an arithmetic shift
18114 is performed as described below.
18115
18116 @kindex b R
18117 @pindex calc-rshift-arith
18118 @tindex rash
18119 The @kbd{b R} (@code{calc-rshift-arith}) [@code{rash}] command performs
18120 an ``arithmetic'' shift to the right, in which the leftmost bit (according
18121 to the current word size) is duplicated rather than shifting in zeros.
18122 This corresponds to dividing by a power of two where the input is interpreted
18123 as a signed, twos-complement number. (The distinction between the @samp{rsh}
18124 and @samp{rash} operations is totally independent from whether the word
18125 size is positive or negative.) With a negative prefix argument, this
18126 performs a standard left shift.
18127
18128 @kindex b t
18129 @pindex calc-rotate-binary
18130 @tindex rot
18131 The @kbd{b t} (@code{calc-rotate-binary}) [@code{rot}] command rotates a
18132 number one bit to the left. The leftmost bit (according to the current
18133 word size) is dropped off the left and shifted in on the right. With a
18134 numeric prefix argument, the number is rotated that many bits to the left
18135 or right.
18136
18137 @xref{Set Operations}, for the @kbd{b p} and @kbd{b u} commands that
18138 pack and unpack binary integers into sets. (For example, @kbd{b u}
18139 unpacks the number @samp{2#11001} to the set of bit-numbers
18140 @samp{[0, 3, 4]}.) Type @kbd{b u V #} to count the number of ``1''
18141 bits in a binary integer.
18142
18143 Another interesting use of the set representation of binary integers
18144 is to reverse the bits in, say, a 32-bit integer. Type @kbd{b u} to
18145 unpack; type @kbd{31 @key{TAB} -} to replace each bit-number in the set
18146 with 31 minus that bit-number; type @kbd{b p} to pack the set back
18147 into a binary integer.
18148
18149 @node Scientific Functions, Matrix Functions, Arithmetic, Top
18150 @chapter Scientific Functions
18151
18152 @noindent
18153 The functions described here perform trigonometric and other transcendental
18154 calculations. They generally produce floating-point answers correct to the
18155 full current precision. The @kbd{H} (Hyperbolic) and @kbd{I} (Inverse)
18156 flag keys must be used to get some of these functions from the keyboard.
18157
18158 @kindex P
18159 @pindex calc-pi
18160 @cindex @code{pi} variable
18161 @vindex pi
18162 @kindex H P
18163 @cindex @code{e} variable
18164 @vindex e
18165 @kindex I P
18166 @cindex @code{gamma} variable
18167 @vindex gamma
18168 @cindex Gamma constant, Euler's
18169 @cindex Euler's gamma constant
18170 @kindex H I P
18171 @cindex @code{phi} variable
18172 @cindex Phi, golden ratio
18173 @cindex Golden ratio
18174 One miscellaneous command is shift-@kbd{P} (@code{calc-pi}), which pushes
18175 the value of @cpi{} (at the current precision) onto the stack. With the
18176 Hyperbolic flag, it pushes the value @expr{e}, the base of natural logarithms.
18177 With the Inverse flag, it pushes Euler's constant
18178 @texline @math{\gamma}
18179 @infoline @expr{gamma}
18180 (about 0.5772). With both Inverse and Hyperbolic, it
18181 pushes the ``golden ratio''
18182 @texline @math{\phi}
18183 @infoline @expr{phi}
18184 (about 1.618). (At present, Euler's constant is not available
18185 to unlimited precision; Calc knows only the first 100 digits.)
18186 In Symbolic mode, these commands push the
18187 actual variables @samp{pi}, @samp{e}, @samp{gamma}, and @samp{phi},
18188 respectively, instead of their values; @pxref{Symbolic Mode}.
18189
18190 @ignore
18191 @mindex Q
18192 @end ignore
18193 @ignore
18194 @mindex I Q
18195 @end ignore
18196 @kindex I Q
18197 @tindex sqr
18198 The @kbd{Q} (@code{calc-sqrt}) [@code{sqrt}] function is described elsewhere;
18199 @pxref{Basic Arithmetic}. With the Inverse flag [@code{sqr}], this command
18200 computes the square of the argument.
18201
18202 @xref{Prefix Arguments}, for a discussion of the effect of numeric
18203 prefix arguments on commands in this chapter which do not otherwise
18204 interpret a prefix argument.
18205
18206 @menu
18207 * Logarithmic Functions::
18208 * Trigonometric and Hyperbolic Functions::
18209 * Advanced Math Functions::
18210 * Branch Cuts::
18211 * Random Numbers::
18212 * Combinatorial Functions::
18213 * Probability Distribution Functions::
18214 @end menu
18215
18216 @node Logarithmic Functions, Trigonometric and Hyperbolic Functions, Scientific Functions, Scientific Functions
18217 @section Logarithmic Functions
18218
18219 @noindent
18220 @kindex L
18221 @pindex calc-ln
18222 @tindex ln
18223 @ignore
18224 @mindex @null
18225 @end ignore
18226 @kindex I E
18227 The shift-@kbd{L} (@code{calc-ln}) [@code{ln}] command computes the natural
18228 logarithm of the real or complex number on the top of the stack. With
18229 the Inverse flag it computes the exponential function instead, although
18230 this is redundant with the @kbd{E} command.
18231
18232 @kindex E
18233 @pindex calc-exp
18234 @tindex exp
18235 @ignore
18236 @mindex @null
18237 @end ignore
18238 @kindex I L
18239 The shift-@kbd{E} (@code{calc-exp}) [@code{exp}] command computes the
18240 exponential, i.e., @expr{e} raised to the power of the number on the stack.
18241 The meanings of the Inverse and Hyperbolic flags follow from those for
18242 the @code{calc-ln} command.
18243
18244 @kindex H L
18245 @kindex H E
18246 @pindex calc-log10
18247 @tindex log10
18248 @tindex exp10
18249 @ignore
18250 @mindex @null
18251 @end ignore
18252 @kindex H I L
18253 @ignore
18254 @mindex @null
18255 @end ignore
18256 @kindex H I E
18257 The @kbd{H L} (@code{calc-log10}) [@code{log10}] command computes the common
18258 (base-10) logarithm of a number. (With the Inverse flag [@code{exp10}],
18259 it raises ten to a given power.) Note that the common logarithm of a
18260 complex number is computed by taking the natural logarithm and dividing
18261 by
18262 @texline @math{\ln10}.
18263 @infoline @expr{ln(10)}.
18264
18265 @kindex B
18266 @kindex I B
18267 @pindex calc-log
18268 @tindex log
18269 @tindex alog
18270 The @kbd{B} (@code{calc-log}) [@code{log}] command computes a logarithm
18271 to any base. For example, @kbd{1024 @key{RET} 2 B} produces 10, since
18272 @texline @math{2^{10} = 1024}.
18273 @infoline @expr{2^10 = 1024}.
18274 In certain cases like @samp{log(3,9)}, the result
18275 will be either @expr{1:2} or @expr{0.5} depending on the current Fraction
18276 mode setting. With the Inverse flag [@code{alog}], this command is
18277 similar to @kbd{^} except that the order of the arguments is reversed.
18278
18279 @kindex f I
18280 @pindex calc-ilog
18281 @tindex ilog
18282 The @kbd{f I} (@code{calc-ilog}) [@code{ilog}] command computes the
18283 integer logarithm of a number to any base. The number and the base must
18284 themselves be positive integers. This is the true logarithm, rounded
18285 down to an integer. Thus @kbd{ilog(x,10)} is 3 for all @expr{x} in the
18286 range from 1000 to 9999. If both arguments are positive integers, exact
18287 integer arithmetic is used; otherwise, this is equivalent to
18288 @samp{floor(log(x,b))}.
18289
18290 @kindex f E
18291 @pindex calc-expm1
18292 @tindex expm1
18293 The @kbd{f E} (@code{calc-expm1}) [@code{expm1}] command computes
18294 @texline @math{e^x - 1},
18295 @infoline @expr{exp(x)-1},
18296 but using an algorithm that produces a more accurate
18297 answer when the result is close to zero, i.e., when
18298 @texline @math{e^x}
18299 @infoline @expr{exp(x)}
18300 is close to one.
18301
18302 @kindex f L
18303 @pindex calc-lnp1
18304 @tindex lnp1
18305 The @kbd{f L} (@code{calc-lnp1}) [@code{lnp1}] command computes
18306 @texline @math{\ln(x+1)},
18307 @infoline @expr{ln(x+1)},
18308 producing a more accurate answer when @expr{x} is close to zero.
18309
18310 @node Trigonometric and Hyperbolic Functions, Advanced Math Functions, Logarithmic Functions, Scientific Functions
18311 @section Trigonometric/Hyperbolic Functions
18312
18313 @noindent
18314 @kindex S
18315 @pindex calc-sin
18316 @tindex sin
18317 The shift-@kbd{S} (@code{calc-sin}) [@code{sin}] command computes the sine
18318 of an angle or complex number. If the input is an HMS form, it is interpreted
18319 as degrees-minutes-seconds; otherwise, the input is interpreted according
18320 to the current angular mode. It is best to use Radians mode when operating
18321 on complex numbers.
18322
18323 Calc's ``units'' mechanism includes angular units like @code{deg},
18324 @code{rad}, and @code{grad}. While @samp{sin(45 deg)} is not evaluated
18325 all the time, the @kbd{u s} (@code{calc-simplify-units}) command will
18326 simplify @samp{sin(45 deg)} by taking the sine of 45 degrees, regardless
18327 of the current angular mode. @xref{Basic Operations on Units}.
18328
18329 Also, the symbolic variable @code{pi} is not ordinarily recognized in
18330 arguments to trigonometric functions, as in @samp{sin(3 pi / 4)}, but
18331 the @kbd{a s} (@code{calc-simplify}) command recognizes many such
18332 formulas when the current angular mode is Radians @emph{and} Symbolic
18333 mode is enabled; this example would be replaced by @samp{sqrt(2) / 2}.
18334 @xref{Symbolic Mode}. Beware, this simplification occurs even if you
18335 have stored a different value in the variable @samp{pi}; this is one
18336 reason why changing built-in variables is a bad idea. Arguments of
18337 the form @expr{x} plus a multiple of @cpiover{2} are also simplified.
18338 Calc includes similar formulas for @code{cos} and @code{tan}.
18339
18340 The @kbd{a s} command knows all angles which are integer multiples of
18341 @cpiover{12}, @cpiover{10}, or @cpiover{8} radians. In Degrees mode,
18342 analogous simplifications occur for integer multiples of 15 or 18
18343 degrees, and for arguments plus multiples of 90 degrees.
18344
18345 @kindex I S
18346 @pindex calc-arcsin
18347 @tindex arcsin
18348 With the Inverse flag, @code{calc-sin} computes an arcsine. This is also
18349 available as the @code{calc-arcsin} command or @code{arcsin} algebraic
18350 function. The returned argument is converted to degrees, radians, or HMS
18351 notation depending on the current angular mode.
18352
18353 @kindex H S
18354 @pindex calc-sinh
18355 @tindex sinh
18356 @kindex H I S
18357 @pindex calc-arcsinh
18358 @tindex arcsinh
18359 With the Hyperbolic flag, @code{calc-sin} computes the hyperbolic
18360 sine, also available as @code{calc-sinh} [@code{sinh}]. With the
18361 Hyperbolic and Inverse flags, it computes the hyperbolic arcsine
18362 (@code{calc-arcsinh}) [@code{arcsinh}].
18363
18364 @kindex C
18365 @pindex calc-cos
18366 @tindex cos
18367 @ignore
18368 @mindex @idots
18369 @end ignore
18370 @kindex I C
18371 @pindex calc-arccos
18372 @ignore
18373 @mindex @null
18374 @end ignore
18375 @tindex arccos
18376 @ignore
18377 @mindex @null
18378 @end ignore
18379 @kindex H C
18380 @pindex calc-cosh
18381 @ignore
18382 @mindex @null
18383 @end ignore
18384 @tindex cosh
18385 @ignore
18386 @mindex @null
18387 @end ignore
18388 @kindex H I C
18389 @pindex calc-arccosh
18390 @ignore
18391 @mindex @null
18392 @end ignore
18393 @tindex arccosh
18394 @ignore
18395 @mindex @null
18396 @end ignore
18397 @kindex T
18398 @pindex calc-tan
18399 @ignore
18400 @mindex @null
18401 @end ignore
18402 @tindex tan
18403 @ignore
18404 @mindex @null
18405 @end ignore
18406 @kindex I T
18407 @pindex calc-arctan
18408 @ignore
18409 @mindex @null
18410 @end ignore
18411 @tindex arctan
18412 @ignore
18413 @mindex @null
18414 @end ignore
18415 @kindex H T
18416 @pindex calc-tanh
18417 @ignore
18418 @mindex @null
18419 @end ignore
18420 @tindex tanh
18421 @ignore
18422 @mindex @null
18423 @end ignore
18424 @kindex H I T
18425 @pindex calc-arctanh
18426 @ignore
18427 @mindex @null
18428 @end ignore
18429 @tindex arctanh
18430 The shift-@kbd{C} (@code{calc-cos}) [@code{cos}] command computes the cosine
18431 of an angle or complex number, and shift-@kbd{T} (@code{calc-tan}) [@code{tan}]
18432 computes the tangent, along with all the various inverse and hyperbolic
18433 variants of these functions.
18434
18435 @kindex f T
18436 @pindex calc-arctan2
18437 @tindex arctan2
18438 The @kbd{f T} (@code{calc-arctan2}) [@code{arctan2}] command takes two
18439 numbers from the stack and computes the arc tangent of their ratio. The
18440 result is in the full range from @mathit{-180} (exclusive) to @mathit{+180}
18441 (inclusive) degrees, or the analogous range in radians. A similar
18442 result would be obtained with @kbd{/} followed by @kbd{I T}, but the
18443 value would only be in the range from @mathit{-90} to @mathit{+90} degrees
18444 since the division loses information about the signs of the two
18445 components, and an error might result from an explicit division by zero
18446 which @code{arctan2} would avoid. By (arbitrary) definition,
18447 @samp{arctan2(0,0)=0}.
18448
18449 @pindex calc-sincos
18450 @ignore
18451 @starindex
18452 @end ignore
18453 @tindex sincos
18454 @ignore
18455 @starindex
18456 @end ignore
18457 @ignore
18458 @mindex arc@idots
18459 @end ignore
18460 @tindex arcsincos
18461 The @code{calc-sincos} [@code{sincos}] command computes the sine and
18462 cosine of a number, returning them as a vector of the form
18463 @samp{[@var{cos}, @var{sin}]}.
18464 With the Inverse flag [@code{arcsincos}], this command takes a two-element
18465 vector as an argument and computes @code{arctan2} of the elements.
18466 (This command does not accept the Hyperbolic flag.)
18467
18468 @pindex calc-sec
18469 @tindex sec
18470 @pindex calc-csc
18471 @tindex csc
18472 @pindex calc-cot
18473 @tindex cot
18474 @pindex calc-sech
18475 @tindex sech
18476 @pindex calc-csch
18477 @tindex csch
18478 @pindex calc-coth
18479 @tindex coth
18480 The remaining trigonometric functions, @code{calc-sec} [@code{sec}],
18481 @code{calc-csc} [@code{csc}] and @code{calc-sec} [@code{sec}], are also
18482 available. With the Hyperbolic flag, these compute their hyperbolic
18483 counterparts, which are also available separately as @code{calc-sech}
18484 [@code{sech}], @code{calc-csch} [@code{csch}] and @code{calc-sech}
18485 [@code{sech}]. (These commmands do not accept the Inverse flag.)
18486
18487 @node Advanced Math Functions, Branch Cuts, Trigonometric and Hyperbolic Functions, Scientific Functions
18488 @section Advanced Mathematical Functions
18489
18490 @noindent
18491 Calc can compute a variety of less common functions that arise in
18492 various branches of mathematics. All of the functions described in
18493 this section allow arbitrary complex arguments and, except as noted,
18494 will work to arbitrarily large precisions. They can not at present
18495 handle error forms or intervals as arguments.
18496
18497 NOTE: These functions are still experimental. In particular, their
18498 accuracy is not guaranteed in all domains. It is advisable to set the
18499 current precision comfortably higher than you actually need when
18500 using these functions. Also, these functions may be impractically
18501 slow for some values of the arguments.
18502
18503 @kindex f g
18504 @pindex calc-gamma
18505 @tindex gamma
18506 The @kbd{f g} (@code{calc-gamma}) [@code{gamma}] command computes the Euler
18507 gamma function. For positive integer arguments, this is related to the
18508 factorial function: @samp{gamma(n+1) = fact(n)}. For general complex
18509 arguments the gamma function can be defined by the following definite
18510 integral:
18511 @texline @math{\Gamma(a) = \int_0^\infty t^{a-1} e^t dt}.
18512 @infoline @expr{gamma(a) = integ(t^(a-1) exp(t), t, 0, inf)}.
18513 (The actual implementation uses far more efficient computational methods.)
18514
18515 @kindex f G
18516 @tindex gammaP
18517 @ignore
18518 @mindex @idots
18519 @end ignore
18520 @kindex I f G
18521 @ignore
18522 @mindex @null
18523 @end ignore
18524 @kindex H f G
18525 @ignore
18526 @mindex @null
18527 @end ignore
18528 @kindex H I f G
18529 @pindex calc-inc-gamma
18530 @ignore
18531 @mindex @null
18532 @end ignore
18533 @tindex gammaQ
18534 @ignore
18535 @mindex @null
18536 @end ignore
18537 @tindex gammag
18538 @ignore
18539 @mindex @null
18540 @end ignore
18541 @tindex gammaG
18542 The @kbd{f G} (@code{calc-inc-gamma}) [@code{gammaP}] command computes
18543 the incomplete gamma function, denoted @samp{P(a,x)}. This is defined by
18544 the integral,
18545 @texline @math{P(a,x) = \left( \int_0^x t^{a-1} e^t dt \right) / \Gamma(a)}.
18546 @infoline @expr{gammaP(a,x) = integ(t^(a-1) exp(t), t, 0, x) / gamma(a)}.
18547 This implies that @samp{gammaP(a,inf) = 1} for any @expr{a} (see the
18548 definition of the normal gamma function).
18549
18550 Several other varieties of incomplete gamma function are defined.
18551 The complement of @expr{P(a,x)}, called @expr{Q(a,x) = 1-P(a,x)} by
18552 some authors, is computed by the @kbd{I f G} [@code{gammaQ}] command.
18553 You can think of this as taking the other half of the integral, from
18554 @expr{x} to infinity.
18555
18556 @ifinfo
18557 The functions corresponding to the integrals that define @expr{P(a,x)}
18558 and @expr{Q(a,x)} but without the normalizing @expr{1/gamma(a)}
18559 factor are called @expr{g(a,x)} and @expr{G(a,x)}, respectively
18560 (where @expr{g} and @expr{G} represent the lower- and upper-case Greek
18561 letter gamma). You can obtain these using the @kbd{H f G} [@code{gammag}]
18562 and @kbd{H I f G} [@code{gammaG}] commands.
18563 @end ifinfo
18564 @tex
18565 \turnoffactive
18566 The functions corresponding to the integrals that define $P(a,x)$
18567 and $Q(a,x)$ but without the normalizing $1/\Gamma(a)$
18568 factor are called $\gamma(a,x)$ and $\Gamma(a,x)$, respectively.
18569 You can obtain these using the \kbd{H f G} [\code{gammag}] and
18570 \kbd{I H f G} [\code{gammaG}] commands.
18571 @end tex
18572
18573 @kindex f b
18574 @pindex calc-beta
18575 @tindex beta
18576 The @kbd{f b} (@code{calc-beta}) [@code{beta}] command computes the
18577 Euler beta function, which is defined in terms of the gamma function as
18578 @texline @math{B(a,b) = \Gamma(a) \Gamma(b) / \Gamma(a+b)},
18579 @infoline @expr{beta(a,b) = gamma(a) gamma(b) / gamma(a+b)},
18580 or by
18581 @texline @math{B(a,b) = \int_0^1 t^{a-1} (1-t)^{b-1} dt}.
18582 @infoline @expr{beta(a,b) = integ(t^(a-1) (1-t)^(b-1), t, 0, 1)}.
18583
18584 @kindex f B
18585 @kindex H f B
18586 @pindex calc-inc-beta
18587 @tindex betaI
18588 @tindex betaB
18589 The @kbd{f B} (@code{calc-inc-beta}) [@code{betaI}] command computes
18590 the incomplete beta function @expr{I(x,a,b)}. It is defined by
18591 @texline @math{I(x,a,b) = \left( \int_0^x t^{a-1} (1-t)^{b-1} dt \right) / B(a,b)}.
18592 @infoline @expr{betaI(x,a,b) = integ(t^(a-1) (1-t)^(b-1), t, 0, x) / beta(a,b)}.
18593 Once again, the @kbd{H} (hyperbolic) prefix gives the corresponding
18594 un-normalized version [@code{betaB}].
18595
18596 @kindex f e
18597 @kindex I f e
18598 @pindex calc-erf
18599 @tindex erf
18600 @tindex erfc
18601 The @kbd{f e} (@code{calc-erf}) [@code{erf}] command computes the
18602 error function
18603 @texline @math{\hbox{erf}(x) = {2 \over \sqrt{\pi}} \int_0^x e^{-t^2} dt}.
18604 @infoline @expr{erf(x) = 2 integ(exp(-(t^2)), t, 0, x) / sqrt(pi)}.
18605 The complementary error function @kbd{I f e} (@code{calc-erfc}) [@code{erfc}]
18606 is the corresponding integral from @samp{x} to infinity; the sum
18607 @texline @math{\hbox{erf}(x) + \hbox{erfc}(x) = 1}.
18608 @infoline @expr{erf(x) + erfc(x) = 1}.
18609
18610 @kindex f j
18611 @kindex f y
18612 @pindex calc-bessel-J
18613 @pindex calc-bessel-Y
18614 @tindex besJ
18615 @tindex besY
18616 The @kbd{f j} (@code{calc-bessel-J}) [@code{besJ}] and @kbd{f y}
18617 (@code{calc-bessel-Y}) [@code{besY}] commands compute the Bessel
18618 functions of the first and second kinds, respectively.
18619 In @samp{besJ(n,x)} and @samp{besY(n,x)} the ``order'' parameter
18620 @expr{n} is often an integer, but is not required to be one.
18621 Calc's implementation of the Bessel functions currently limits the
18622 precision to 8 digits, and may not be exact even to that precision.
18623 Use with care!
18624
18625 @node Branch Cuts, Random Numbers, Advanced Math Functions, Scientific Functions
18626 @section Branch Cuts and Principal Values
18627
18628 @noindent
18629 @cindex Branch cuts
18630 @cindex Principal values
18631 All of the logarithmic, trigonometric, and other scientific functions are
18632 defined for complex numbers as well as for reals.
18633 This section describes the values
18634 returned in cases where the general result is a family of possible values.
18635 Calc follows section 12.5.3 of Steele's @dfn{Common Lisp, the Language},
18636 second edition, in these matters. This section will describe each
18637 function briefly; for a more detailed discussion (including some nifty
18638 diagrams), consult Steele's book.
18639
18640 Note that the branch cuts for @code{arctan} and @code{arctanh} were
18641 changed between the first and second editions of Steele. Versions of
18642 Calc starting with 2.00 follow the second edition.
18643
18644 The new branch cuts exactly match those of the HP-28/48 calculators.
18645 They also match those of Mathematica 1.2, except that Mathematica's
18646 @code{arctan} cut is always in the right half of the complex plane,
18647 and its @code{arctanh} cut is always in the top half of the plane.
18648 Calc's cuts are continuous with quadrants I and III for @code{arctan},
18649 or II and IV for @code{arctanh}.
18650
18651 Note: The current implementations of these functions with complex arguments
18652 are designed with proper behavior around the branch cuts in mind, @emph{not}
18653 efficiency or accuracy. You may need to increase the floating precision
18654 and wait a while to get suitable answers from them.
18655
18656 For @samp{sqrt(a+bi)}: When @expr{a<0} and @expr{b} is small but positive
18657 or zero, the result is close to the @expr{+i} axis. For @expr{b} small and
18658 negative, the result is close to the @expr{-i} axis. The result always lies
18659 in the right half of the complex plane.
18660
18661 For @samp{ln(a+bi)}: The real part is defined as @samp{ln(abs(a+bi))}.
18662 The imaginary part is defined as @samp{arg(a+bi) = arctan2(b,a)}.
18663 Thus the branch cuts for @code{sqrt} and @code{ln} both lie on the
18664 negative real axis.
18665
18666 The following table describes these branch cuts in another way.
18667 If the real and imaginary parts of @expr{z} are as shown, then
18668 the real and imaginary parts of @expr{f(z)} will be as shown.
18669 Here @code{eps} stands for a small positive value; each
18670 occurrence of @code{eps} may stand for a different small value.
18671
18672 @smallexample
18673 z sqrt(z) ln(z)
18674 ----------------------------------------
18675 +, 0 +, 0 any, 0
18676 -, 0 0, + any, pi
18677 -, +eps +eps, + +eps, +
18678 -, -eps +eps, - +eps, -
18679 @end smallexample
18680
18681 For @samp{z1^z2}: This is defined by @samp{exp(ln(z1)*z2)}.
18682 One interesting consequence of this is that @samp{(-8)^1:3} does
18683 not evaluate to @mathit{-2} as you might expect, but to the complex
18684 number @expr{(1., 1.732)}. Both of these are valid cube roots
18685 of @mathit{-8} (as is @expr{(1., -1.732)}); Calc chooses a perhaps
18686 less-obvious root for the sake of mathematical consistency.
18687
18688 For @samp{arcsin(z)}: This is defined by @samp{-i*ln(i*z + sqrt(1-z^2))}.
18689 The branch cuts are on the real axis, less than @mathit{-1} and greater than 1.
18690
18691 For @samp{arccos(z)}: This is defined by @samp{-i*ln(z + i*sqrt(1-z^2))},
18692 or equivalently by @samp{pi/2 - arcsin(z)}. The branch cuts are on
18693 the real axis, less than @mathit{-1} and greater than 1.
18694
18695 For @samp{arctan(z)}: This is defined by
18696 @samp{(ln(1+i*z) - ln(1-i*z)) / (2*i)}. The branch cuts are on the
18697 imaginary axis, below @expr{-i} and above @expr{i}.
18698
18699 For @samp{arcsinh(z)}: This is defined by @samp{ln(z + sqrt(1+z^2))}.
18700 The branch cuts are on the imaginary axis, below @expr{-i} and
18701 above @expr{i}.
18702
18703 For @samp{arccosh(z)}: This is defined by
18704 @samp{ln(z + (z+1)*sqrt((z-1)/(z+1)))}. The branch cut is on the
18705 real axis less than 1.
18706
18707 For @samp{arctanh(z)}: This is defined by @samp{(ln(1+z) - ln(1-z)) / 2}.
18708 The branch cuts are on the real axis, less than @mathit{-1} and greater than 1.
18709
18710 The following tables for @code{arcsin}, @code{arccos}, and
18711 @code{arctan} assume the current angular mode is Radians. The
18712 hyperbolic functions operate independently of the angular mode.
18713
18714 @smallexample
18715 z arcsin(z) arccos(z)
18716 -------------------------------------------------------
18717 (-1..1), 0 (-pi/2..pi/2), 0 (0..pi), 0
18718 (-1..1), +eps (-pi/2..pi/2), +eps (0..pi), -eps
18719 (-1..1), -eps (-pi/2..pi/2), -eps (0..pi), +eps
18720 <-1, 0 -pi/2, + pi, -
18721 <-1, +eps -pi/2 + eps, + pi - eps, -
18722 <-1, -eps -pi/2 + eps, - pi - eps, +
18723 >1, 0 pi/2, - 0, +
18724 >1, +eps pi/2 - eps, + +eps, -
18725 >1, -eps pi/2 - eps, - +eps, +
18726 @end smallexample
18727
18728 @smallexample
18729 z arccosh(z) arctanh(z)
18730 -----------------------------------------------------
18731 (-1..1), 0 0, (0..pi) any, 0
18732 (-1..1), +eps +eps, (0..pi) any, +eps
18733 (-1..1), -eps +eps, (-pi..0) any, -eps
18734 <-1, 0 +, pi -, pi/2
18735 <-1, +eps +, pi - eps -, pi/2 - eps
18736 <-1, -eps +, -pi + eps -, -pi/2 + eps
18737 >1, 0 +, 0 +, -pi/2
18738 >1, +eps +, +eps +, pi/2 - eps
18739 >1, -eps +, -eps +, -pi/2 + eps
18740 @end smallexample
18741
18742 @smallexample
18743 z arcsinh(z) arctan(z)
18744 -----------------------------------------------------
18745 0, (-1..1) 0, (-pi/2..pi/2) 0, any
18746 0, <-1 -, -pi/2 -pi/2, -
18747 +eps, <-1 +, -pi/2 + eps pi/2 - eps, -
18748 -eps, <-1 -, -pi/2 + eps -pi/2 + eps, -
18749 0, >1 +, pi/2 pi/2, +
18750 +eps, >1 +, pi/2 - eps pi/2 - eps, +
18751 -eps, >1 -, pi/2 - eps -pi/2 + eps, +
18752 @end smallexample
18753
18754 Finally, the following identities help to illustrate the relationship
18755 between the complex trigonometric and hyperbolic functions. They
18756 are valid everywhere, including on the branch cuts.
18757
18758 @smallexample
18759 sin(i*z) = i*sinh(z) arcsin(i*z) = i*arcsinh(z)
18760 cos(i*z) = cosh(z) arcsinh(i*z) = i*arcsin(z)
18761 tan(i*z) = i*tanh(z) arctan(i*z) = i*arctanh(z)
18762 sinh(i*z) = i*sin(z) cosh(i*z) = cos(z)
18763 @end smallexample
18764
18765 The ``advanced math'' functions (gamma, Bessel, etc.@:) are also defined
18766 for general complex arguments, but their branch cuts and principal values
18767 are not rigorously specified at present.
18768
18769 @node Random Numbers, Combinatorial Functions, Branch Cuts, Scientific Functions
18770 @section Random Numbers
18771
18772 @noindent
18773 @kindex k r
18774 @pindex calc-random
18775 @tindex random
18776 The @kbd{k r} (@code{calc-random}) [@code{random}] command produces
18777 random numbers of various sorts.
18778
18779 Given a positive numeric prefix argument @expr{M}, it produces a random
18780 integer @expr{N} in the range
18781 @texline @math{0 \le N < M}.
18782 @infoline @expr{0 <= N < M}.
18783 Each of the @expr{M} values appears with equal probability.
18784
18785 With no numeric prefix argument, the @kbd{k r} command takes its argument
18786 from the stack instead. Once again, if this is a positive integer @expr{M}
18787 the result is a random integer less than @expr{M}. However, note that
18788 while numeric prefix arguments are limited to six digits or so, an @expr{M}
18789 taken from the stack can be arbitrarily large. If @expr{M} is negative,
18790 the result is a random integer in the range
18791 @texline @math{M < N \le 0}.
18792 @infoline @expr{M < N <= 0}.
18793
18794 If the value on the stack is a floating-point number @expr{M}, the result
18795 is a random floating-point number @expr{N} in the range
18796 @texline @math{0 \le N < M}
18797 @infoline @expr{0 <= N < M}
18798 or
18799 @texline @math{M < N \le 0},
18800 @infoline @expr{M < N <= 0},
18801 according to the sign of @expr{M}.
18802
18803 If @expr{M} is zero, the result is a Gaussian-distributed random real
18804 number; the distribution has a mean of zero and a standard deviation
18805 of one. The algorithm used generates random numbers in pairs; thus,
18806 every other call to this function will be especially fast.
18807
18808 If @expr{M} is an error form
18809 @texline @math{m} @code{+/-} @math{\sigma}
18810 @infoline @samp{m +/- s}
18811 where @var{m} and
18812 @texline @math{\sigma}
18813 @infoline @var{s}
18814 are both real numbers, the result uses a Gaussian distribution with mean
18815 @var{m} and standard deviation
18816 @texline @math{\sigma}.
18817 @infoline @var{s}.
18818
18819 If @expr{M} is an interval form, the lower and upper bounds specify the
18820 acceptable limits of the random numbers. If both bounds are integers,
18821 the result is a random integer in the specified range. If either bound
18822 is floating-point, the result is a random real number in the specified
18823 range. If the interval is open at either end, the result will be sure
18824 not to equal that end value. (This makes a big difference for integer
18825 intervals, but for floating-point intervals it's relatively minor:
18826 with a precision of 6, @samp{random([1.0..2.0))} will return any of one
18827 million numbers from 1.00000 to 1.99999; @samp{random([1.0..2.0])} may
18828 additionally return 2.00000, but the probability of this happening is
18829 extremely small.)
18830
18831 If @expr{M} is a vector, the result is one element taken at random from
18832 the vector. All elements of the vector are given equal probabilities.
18833
18834 @vindex RandSeed
18835 The sequence of numbers produced by @kbd{k r} is completely random by
18836 default, i.e., the sequence is seeded each time you start Calc using
18837 the current time and other information. You can get a reproducible
18838 sequence by storing a particular ``seed value'' in the Calc variable
18839 @code{RandSeed}. Any integer will do for a seed; integers of from 1
18840 to 12 digits are good. If you later store a different integer into
18841 @code{RandSeed}, Calc will switch to a different pseudo-random
18842 sequence. If you ``unstore'' @code{RandSeed}, Calc will re-seed itself
18843 from the current time. If you store the same integer that you used
18844 before back into @code{RandSeed}, you will get the exact same sequence
18845 of random numbers as before.
18846
18847 @pindex calc-rrandom
18848 The @code{calc-rrandom} command (not on any key) produces a random real
18849 number between zero and one. It is equivalent to @samp{random(1.0)}.
18850
18851 @kindex k a
18852 @pindex calc-random-again
18853 The @kbd{k a} (@code{calc-random-again}) command produces another random
18854 number, re-using the most recent value of @expr{M}. With a numeric
18855 prefix argument @var{n}, it produces @var{n} more random numbers using
18856 that value of @expr{M}.
18857
18858 @kindex k h
18859 @pindex calc-shuffle
18860 @tindex shuffle
18861 The @kbd{k h} (@code{calc-shuffle}) command produces a vector of several
18862 random values with no duplicates. The value on the top of the stack
18863 specifies the set from which the random values are drawn, and may be any
18864 of the @expr{M} formats described above. The numeric prefix argument
18865 gives the length of the desired list. (If you do not provide a numeric
18866 prefix argument, the length of the list is taken from the top of the
18867 stack, and @expr{M} from second-to-top.)
18868
18869 If @expr{M} is a floating-point number, zero, or an error form (so
18870 that the random values are being drawn from the set of real numbers)
18871 there is little practical difference between using @kbd{k h} and using
18872 @kbd{k r} several times. But if the set of possible values consists
18873 of just a few integers, or the elements of a vector, then there is
18874 a very real chance that multiple @kbd{k r}'s will produce the same
18875 number more than once. The @kbd{k h} command produces a vector whose
18876 elements are always distinct. (Actually, there is a slight exception:
18877 If @expr{M} is a vector, no given vector element will be drawn more
18878 than once, but if several elements of @expr{M} are equal, they may
18879 each make it into the result vector.)
18880
18881 One use of @kbd{k h} is to rearrange a list at random. This happens
18882 if the prefix argument is equal to the number of values in the list:
18883 @kbd{[1, 1.5, 2, 2.5, 3] 5 k h} might produce the permuted list
18884 @samp{[2.5, 1, 1.5, 3, 2]}. As a convenient feature, if the argument
18885 @var{n} is negative it is replaced by the size of the set represented
18886 by @expr{M}. Naturally, this is allowed only when @expr{M} specifies
18887 a small discrete set of possibilities.
18888
18889 To do the equivalent of @kbd{k h} but with duplications allowed,
18890 given @expr{M} on the stack and with @var{n} just entered as a numeric
18891 prefix, use @kbd{v b} to build a vector of copies of @expr{M}, then use
18892 @kbd{V M k r} to ``map'' the normal @kbd{k r} function over the
18893 elements of this vector. @xref{Matrix Functions}.
18894
18895 @menu
18896 * Random Number Generator:: (Complete description of Calc's algorithm)
18897 @end menu
18898
18899 @node Random Number Generator, , Random Numbers, Random Numbers
18900 @subsection Random Number Generator
18901
18902 Calc's random number generator uses several methods to ensure that
18903 the numbers it produces are highly random. Knuth's @emph{Art of
18904 Computer Programming}, Volume II, contains a thorough description
18905 of the theory of random number generators and their measurement and
18906 characterization.
18907
18908 If @code{RandSeed} has no stored value, Calc calls Emacs' built-in
18909 @code{random} function to get a stream of random numbers, which it
18910 then treats in various ways to avoid problems inherent in the simple
18911 random number generators that many systems use to implement @code{random}.
18912
18913 When Calc's random number generator is first invoked, it ``seeds''
18914 the low-level random sequence using the time of day, so that the
18915 random number sequence will be different every time you use Calc.
18916
18917 Since Emacs Lisp doesn't specify the range of values that will be
18918 returned by its @code{random} function, Calc exercises the function
18919 several times to estimate the range. When Calc subsequently uses
18920 the @code{random} function, it takes only 10 bits of the result
18921 near the most-significant end. (It avoids at least the bottom
18922 four bits, preferably more, and also tries to avoid the top two
18923 bits.) This strategy works well with the linear congruential
18924 generators that are typically used to implement @code{random}.
18925
18926 If @code{RandSeed} contains an integer, Calc uses this integer to
18927 seed an ``additive congruential'' method (Knuth's algorithm 3.2.2A,
18928 computing
18929 @texline @math{X_{n-55} - X_{n-24}}.
18930 @infoline @expr{X_n-55 - X_n-24}).
18931 This method expands the seed
18932 value into a large table which is maintained internally; the variable
18933 @code{RandSeed} is changed from, e.g., 42 to the vector @expr{[42]}
18934 to indicate that the seed has been absorbed into this table. When
18935 @code{RandSeed} contains a vector, @kbd{k r} and related commands
18936 continue to use the same internal table as last time. There is no
18937 way to extract the complete state of the random number generator
18938 so that you can restart it from any point; you can only restart it
18939 from the same initial seed value. A simple way to restart from the
18940 same seed is to type @kbd{s r RandSeed} to get the seed vector,
18941 @kbd{v u} to unpack it back into a number, then @kbd{s t RandSeed}
18942 to reseed the generator with that number.
18943
18944 Calc uses a ``shuffling'' method as described in algorithm 3.2.2B
18945 of Knuth. It fills a table with 13 random 10-bit numbers. Then,
18946 to generate a new random number, it uses the previous number to
18947 index into the table, picks the value it finds there as the new
18948 random number, then replaces that table entry with a new value
18949 obtained from a call to the base random number generator (either
18950 the additive congruential generator or the @code{random} function
18951 supplied by the system). If there are any flaws in the base
18952 generator, shuffling will tend to even them out. But if the system
18953 provides an excellent @code{random} function, shuffling will not
18954 damage its randomness.
18955
18956 To create a random integer of a certain number of digits, Calc
18957 builds the integer three decimal digits at a time. For each group
18958 of three digits, Calc calls its 10-bit shuffling random number generator
18959 (which returns a value from 0 to 1023); if the random value is 1000
18960 or more, Calc throws it out and tries again until it gets a suitable
18961 value.
18962
18963 To create a random floating-point number with precision @var{p}, Calc
18964 simply creates a random @var{p}-digit integer and multiplies by
18965 @texline @math{10^{-p}}.
18966 @infoline @expr{10^-p}.
18967 The resulting random numbers should be very clean, but note
18968 that relatively small numbers will have few significant random digits.
18969 In other words, with a precision of 12, you will occasionally get
18970 numbers on the order of
18971 @texline @math{10^{-9}}
18972 @infoline @expr{10^-9}
18973 or
18974 @texline @math{10^{-10}},
18975 @infoline @expr{10^-10},
18976 but those numbers will only have two or three random digits since they
18977 correspond to small integers times
18978 @texline @math{10^{-12}}.
18979 @infoline @expr{10^-12}.
18980
18981 To create a random integer in the interval @samp{[0 .. @var{m})}, Calc
18982 counts the digits in @var{m}, creates a random integer with three
18983 additional digits, then reduces modulo @var{m}. Unless @var{m} is a
18984 power of ten the resulting values will be very slightly biased toward
18985 the lower numbers, but this bias will be less than 0.1%. (For example,
18986 if @var{m} is 42, Calc will reduce a random integer less than 100000
18987 modulo 42 to get a result less than 42. It is easy to show that the
18988 numbers 40 and 41 will be only 2380/2381 as likely to result from this
18989 modulo operation as numbers 39 and below.) If @var{m} is a power of
18990 ten, however, the numbers should be completely unbiased.
18991
18992 The Gaussian random numbers generated by @samp{random(0.0)} use the
18993 ``polar'' method described in Knuth section 3.4.1C. This method
18994 generates a pair of Gaussian random numbers at a time, so only every
18995 other call to @samp{random(0.0)} will require significant calculations.
18996
18997 @node Combinatorial Functions, Probability Distribution Functions, Random Numbers, Scientific Functions
18998 @section Combinatorial Functions
18999
19000 @noindent
19001 Commands relating to combinatorics and number theory begin with the
19002 @kbd{k} key prefix.
19003
19004 @kindex k g
19005 @pindex calc-gcd
19006 @tindex gcd
19007 The @kbd{k g} (@code{calc-gcd}) [@code{gcd}] command computes the
19008 Greatest Common Divisor of two integers. It also accepts fractions;
19009 the GCD of two fractions is defined by taking the GCD of the
19010 numerators, and the LCM of the denominators. This definition is
19011 consistent with the idea that @samp{a / gcd(a,x)} should yield an
19012 integer for any @samp{a} and @samp{x}. For other types of arguments,
19013 the operation is left in symbolic form.
19014
19015 @kindex k l
19016 @pindex calc-lcm
19017 @tindex lcm
19018 The @kbd{k l} (@code{calc-lcm}) [@code{lcm}] command computes the
19019 Least Common Multiple of two integers or fractions. The product of
19020 the LCM and GCD of two numbers is equal to the product of the
19021 numbers.
19022
19023 @kindex k E
19024 @pindex calc-extended-gcd
19025 @tindex egcd
19026 The @kbd{k E} (@code{calc-extended-gcd}) [@code{egcd}] command computes
19027 the GCD of two integers @expr{x} and @expr{y} and returns a vector
19028 @expr{[g, a, b]} where
19029 @texline @math{g = \gcd(x,y) = a x + b y}.
19030 @infoline @expr{g = gcd(x,y) = a x + b y}.
19031
19032 @kindex !
19033 @pindex calc-factorial
19034 @tindex fact
19035 @ignore
19036 @mindex @null
19037 @end ignore
19038 @tindex !
19039 The @kbd{!} (@code{calc-factorial}) [@code{fact}] command computes the
19040 factorial of the number at the top of the stack. If the number is an
19041 integer, the result is an exact integer. If the number is an
19042 integer-valued float, the result is a floating-point approximation. If
19043 the number is a non-integral real number, the generalized factorial is used,
19044 as defined by the Euler Gamma function. Please note that computation of
19045 large factorials can be slow; using floating-point format will help
19046 since fewer digits must be maintained. The same is true of many of
19047 the commands in this section.
19048
19049 @kindex k d
19050 @pindex calc-double-factorial
19051 @tindex dfact
19052 @ignore
19053 @mindex @null
19054 @end ignore
19055 @tindex !!
19056 The @kbd{k d} (@code{calc-double-factorial}) [@code{dfact}] command
19057 computes the ``double factorial'' of an integer. For an even integer,
19058 this is the product of even integers from 2 to @expr{N}. For an odd
19059 integer, this is the product of odd integers from 3 to @expr{N}. If
19060 the argument is an integer-valued float, the result is a floating-point
19061 approximation. This function is undefined for negative even integers.
19062 The notation @expr{N!!} is also recognized for double factorials.
19063
19064 @kindex k c
19065 @pindex calc-choose
19066 @tindex choose
19067 The @kbd{k c} (@code{calc-choose}) [@code{choose}] command computes the
19068 binomial coefficient @expr{N}-choose-@expr{M}, where @expr{M} is the number
19069 on the top of the stack and @expr{N} is second-to-top. If both arguments
19070 are integers, the result is an exact integer. Otherwise, the result is a
19071 floating-point approximation. The binomial coefficient is defined for all
19072 real numbers by
19073 @texline @math{N! \over M! (N-M)!\,}.
19074 @infoline @expr{N! / M! (N-M)!}.
19075
19076 @kindex H k c
19077 @pindex calc-perm
19078 @tindex perm
19079 @ifinfo
19080 The @kbd{H k c} (@code{calc-perm}) [@code{perm}] command computes the
19081 number-of-permutations function @expr{N! / (N-M)!}.
19082 @end ifinfo
19083 @tex
19084 The \kbd{H k c} (\code{calc-perm}) [\code{perm}] command computes the
19085 number-of-perm\-utations function $N! \over (N-M)!\,$.
19086 @end tex
19087
19088 @kindex k b
19089 @kindex H k b
19090 @pindex calc-bernoulli-number
19091 @tindex bern
19092 The @kbd{k b} (@code{calc-bernoulli-number}) [@code{bern}] command
19093 computes a given Bernoulli number. The value at the top of the stack
19094 is a nonnegative integer @expr{n} that specifies which Bernoulli number
19095 is desired. The @kbd{H k b} command computes a Bernoulli polynomial,
19096 taking @expr{n} from the second-to-top position and @expr{x} from the
19097 top of the stack. If @expr{x} is a variable or formula the result is
19098 a polynomial in @expr{x}; if @expr{x} is a number the result is a number.
19099
19100 @kindex k e
19101 @kindex H k e
19102 @pindex calc-euler-number
19103 @tindex euler
19104 The @kbd{k e} (@code{calc-euler-number}) [@code{euler}] command similarly
19105 computes an Euler number, and @w{@kbd{H k e}} computes an Euler polynomial.
19106 Bernoulli and Euler numbers occur in the Taylor expansions of several
19107 functions.
19108
19109 @kindex k s
19110 @kindex H k s
19111 @pindex calc-stirling-number
19112 @tindex stir1
19113 @tindex stir2
19114 The @kbd{k s} (@code{calc-stirling-number}) [@code{stir1}] command
19115 computes a Stirling number of the first
19116 @texline kind@tie{}@math{n \brack m},
19117 @infoline kind,
19118 given two integers @expr{n} and @expr{m} on the stack. The @kbd{H k s}
19119 [@code{stir2}] command computes a Stirling number of the second
19120 @texline kind@tie{}@math{n \brace m}.
19121 @infoline kind.
19122 These are the number of @expr{m}-cycle permutations of @expr{n} objects,
19123 and the number of ways to partition @expr{n} objects into @expr{m}
19124 non-empty sets, respectively.
19125
19126 @kindex k p
19127 @pindex calc-prime-test
19128 @cindex Primes
19129 The @kbd{k p} (@code{calc-prime-test}) command checks if the integer on
19130 the top of the stack is prime. For integers less than eight million, the
19131 answer is always exact and reasonably fast. For larger integers, a
19132 probabilistic method is used (see Knuth vol. II, section 4.5.4, algorithm P).
19133 The number is first checked against small prime factors (up to 13). Then,
19134 any number of iterations of the algorithm are performed. Each step either
19135 discovers that the number is non-prime, or substantially increases the
19136 certainty that the number is prime. After a few steps, the chance that
19137 a number was mistakenly described as prime will be less than one percent.
19138 (Indeed, this is a worst-case estimate of the probability; in practice
19139 even a single iteration is quite reliable.) After the @kbd{k p} command,
19140 the number will be reported as definitely prime or non-prime if possible,
19141 or otherwise ``probably'' prime with a certain probability of error.
19142
19143 @ignore
19144 @starindex
19145 @end ignore
19146 @tindex prime
19147 The normal @kbd{k p} command performs one iteration of the primality
19148 test. Pressing @kbd{k p} repeatedly for the same integer will perform
19149 additional iterations. Also, @kbd{k p} with a numeric prefix performs
19150 the specified number of iterations. There is also an algebraic function
19151 @samp{prime(n)} or @samp{prime(n,iters)} which returns 1 if @expr{n}
19152 is (probably) prime and 0 if not.
19153
19154 @kindex k f
19155 @pindex calc-prime-factors
19156 @tindex prfac
19157 The @kbd{k f} (@code{calc-prime-factors}) [@code{prfac}] command
19158 attempts to decompose an integer into its prime factors. For numbers up
19159 to 25 million, the answer is exact although it may take some time. The
19160 result is a vector of the prime factors in increasing order. For larger
19161 inputs, prime factors above 5000 may not be found, in which case the
19162 last number in the vector will be an unfactored integer greater than 25
19163 million (with a warning message). For negative integers, the first
19164 element of the list will be @mathit{-1}. For inputs @mathit{-1}, @mathit{0}, and
19165 @mathit{1}, the result is a list of the same number.
19166
19167 @kindex k n
19168 @pindex calc-next-prime
19169 @ignore
19170 @mindex nextpr@idots
19171 @end ignore
19172 @tindex nextprime
19173 The @kbd{k n} (@code{calc-next-prime}) [@code{nextprime}] command finds
19174 the next prime above a given number. Essentially, it searches by calling
19175 @code{calc-prime-test} on successive integers until it finds one that
19176 passes the test. This is quite fast for integers less than eight million,
19177 but once the probabilistic test comes into play the search may be rather
19178 slow. Ordinarily this command stops for any prime that passes one iteration
19179 of the primality test. With a numeric prefix argument, a number must pass
19180 the specified number of iterations before the search stops. (This only
19181 matters when searching above eight million.) You can always use additional
19182 @kbd{k p} commands to increase your certainty that the number is indeed
19183 prime.
19184
19185 @kindex I k n
19186 @pindex calc-prev-prime
19187 @ignore
19188 @mindex prevpr@idots
19189 @end ignore
19190 @tindex prevprime
19191 The @kbd{I k n} (@code{calc-prev-prime}) [@code{prevprime}] command
19192 analogously finds the next prime less than a given number.
19193
19194 @kindex k t
19195 @pindex calc-totient
19196 @tindex totient
19197 The @kbd{k t} (@code{calc-totient}) [@code{totient}] command computes the
19198 Euler ``totient''
19199 @texline function@tie{}@math{\phi(n)},
19200 @infoline function,
19201 the number of integers less than @expr{n} which
19202 are relatively prime to @expr{n}.
19203
19204 @kindex k m
19205 @pindex calc-moebius
19206 @tindex moebius
19207 The @kbd{k m} (@code{calc-moebius}) [@code{moebius}] command computes the
19208 @texline M@"obius @math{\mu}
19209 @infoline Moebius ``mu''
19210 function. If the input number is a product of @expr{k}
19211 distinct factors, this is @expr{(-1)^k}. If the input number has any
19212 duplicate factors (i.e., can be divided by the same prime more than once),
19213 the result is zero.
19214
19215 @node Probability Distribution Functions, , Combinatorial Functions, Scientific Functions
19216 @section Probability Distribution Functions
19217
19218 @noindent
19219 The functions in this section compute various probability distributions.
19220 For continuous distributions, this is the integral of the probability
19221 density function from @expr{x} to infinity. (These are the ``upper
19222 tail'' distribution functions; there are also corresponding ``lower
19223 tail'' functions which integrate from minus infinity to @expr{x}.)
19224 For discrete distributions, the upper tail function gives the sum
19225 from @expr{x} to infinity; the lower tail function gives the sum
19226 from minus infinity up to, but not including,@w{ }@expr{x}.
19227
19228 To integrate from @expr{x} to @expr{y}, just use the distribution
19229 function twice and subtract. For example, the probability that a
19230 Gaussian random variable with mean 2 and standard deviation 1 will
19231 lie in the range from 2.5 to 2.8 is @samp{utpn(2.5,2,1) - utpn(2.8,2,1)}
19232 (``the probability that it is greater than 2.5, but not greater than 2.8''),
19233 or equivalently @samp{ltpn(2.8,2,1) - ltpn(2.5,2,1)}.
19234
19235 @kindex k B
19236 @kindex I k B
19237 @pindex calc-utpb
19238 @tindex utpb
19239 @tindex ltpb
19240 The @kbd{k B} (@code{calc-utpb}) [@code{utpb}] function uses the
19241 binomial distribution. Push the parameters @var{n}, @var{p}, and
19242 then @var{x} onto the stack; the result (@samp{utpb(x,n,p)}) is the
19243 probability that an event will occur @var{x} or more times out
19244 of @var{n} trials, if its probability of occurring in any given
19245 trial is @var{p}. The @kbd{I k B} [@code{ltpb}] function is
19246 the probability that the event will occur fewer than @var{x} times.
19247
19248 The other probability distribution functions similarly take the
19249 form @kbd{k @var{X}} (@code{calc-utp@var{x}}) [@code{utp@var{x}}]
19250 and @kbd{I k @var{X}} [@code{ltp@var{x}}], for various letters
19251 @var{x}. The arguments to the algebraic functions are the value of
19252 the random variable first, then whatever other parameters define the
19253 distribution. Note these are among the few Calc functions where the
19254 order of the arguments in algebraic form differs from the order of
19255 arguments as found on the stack. (The random variable comes last on
19256 the stack, so that you can type, e.g., @kbd{2 @key{RET} 1 @key{RET} 2.5
19257 k N M-@key{RET} @key{DEL} 2.8 k N -}, using @kbd{M-@key{RET} @key{DEL}} to
19258 recover the original arguments but substitute a new value for @expr{x}.)
19259
19260 @kindex k C
19261 @pindex calc-utpc
19262 @tindex utpc
19263 @ignore
19264 @mindex @idots
19265 @end ignore
19266 @kindex I k C
19267 @ignore
19268 @mindex @null
19269 @end ignore
19270 @tindex ltpc
19271 The @samp{utpc(x,v)} function uses the chi-square distribution with
19272 @texline @math{\nu}
19273 @infoline @expr{v}
19274 degrees of freedom. It is the probability that a model is
19275 correct if its chi-square statistic is @expr{x}.
19276
19277 @kindex k F
19278 @pindex calc-utpf
19279 @tindex utpf
19280 @ignore
19281 @mindex @idots
19282 @end ignore
19283 @kindex I k F
19284 @ignore
19285 @mindex @null
19286 @end ignore
19287 @tindex ltpf
19288 The @samp{utpf(F,v1,v2)} function uses the F distribution, used in
19289 various statistical tests. The parameters
19290 @texline @math{\nu_1}
19291 @infoline @expr{v1}
19292 and
19293 @texline @math{\nu_2}
19294 @infoline @expr{v2}
19295 are the degrees of freedom in the numerator and denominator,
19296 respectively, used in computing the statistic @expr{F}.
19297
19298 @kindex k N
19299 @pindex calc-utpn
19300 @tindex utpn
19301 @ignore
19302 @mindex @idots
19303 @end ignore
19304 @kindex I k N
19305 @ignore
19306 @mindex @null
19307 @end ignore
19308 @tindex ltpn
19309 The @samp{utpn(x,m,s)} function uses a normal (Gaussian) distribution
19310 with mean @expr{m} and standard deviation
19311 @texline @math{\sigma}.
19312 @infoline @expr{s}.
19313 It is the probability that such a normal-distributed random variable
19314 would exceed @expr{x}.
19315
19316 @kindex k P
19317 @pindex calc-utpp
19318 @tindex utpp
19319 @ignore
19320 @mindex @idots
19321 @end ignore
19322 @kindex I k P
19323 @ignore
19324 @mindex @null
19325 @end ignore
19326 @tindex ltpp
19327 The @samp{utpp(n,x)} function uses a Poisson distribution with
19328 mean @expr{x}. It is the probability that @expr{n} or more such
19329 Poisson random events will occur.
19330
19331 @kindex k T
19332 @pindex calc-ltpt
19333 @tindex utpt
19334 @ignore
19335 @mindex @idots
19336 @end ignore
19337 @kindex I k T
19338 @ignore
19339 @mindex @null
19340 @end ignore
19341 @tindex ltpt
19342 The @samp{utpt(t,v)} function uses the Student's ``t'' distribution
19343 with
19344 @texline @math{\nu}
19345 @infoline @expr{v}
19346 degrees of freedom. It is the probability that a
19347 t-distributed random variable will be greater than @expr{t}.
19348 (Note: This computes the distribution function
19349 @texline @math{A(t|\nu)}
19350 @infoline @expr{A(t|v)}
19351 where
19352 @texline @math{A(0|\nu) = 1}
19353 @infoline @expr{A(0|v) = 1}
19354 and
19355 @texline @math{A(\infty|\nu) \to 0}.
19356 @infoline @expr{A(inf|v) -> 0}.
19357 The @code{UTPT} operation on the HP-48 uses a different definition which
19358 returns half of Calc's value: @samp{UTPT(t,v) = .5*utpt(t,v)}.)
19359
19360 While Calc does not provide inverses of the probability distribution
19361 functions, the @kbd{a R} command can be used to solve for the inverse.
19362 Since the distribution functions are monotonic, @kbd{a R} is guaranteed
19363 to be able to find a solution given any initial guess.
19364 @xref{Numerical Solutions}.
19365
19366 @node Matrix Functions, Algebra, Scientific Functions, Top
19367 @chapter Vector/Matrix Functions
19368
19369 @noindent
19370 Many of the commands described here begin with the @kbd{v} prefix.
19371 (For convenience, the shift-@kbd{V} prefix is equivalent to @kbd{v}.)
19372 The commands usually apply to both plain vectors and matrices; some
19373 apply only to matrices or only to square matrices. If the argument
19374 has the wrong dimensions the operation is left in symbolic form.
19375
19376 Vectors are entered and displayed using @samp{[a,b,c]} notation.
19377 Matrices are vectors of which all elements are vectors of equal length.
19378 (Though none of the standard Calc commands use this concept, a
19379 three-dimensional matrix or rank-3 tensor could be defined as a
19380 vector of matrices, and so on.)
19381
19382 @menu
19383 * Packing and Unpacking::
19384 * Building Vectors::
19385 * Extracting Elements::
19386 * Manipulating Vectors::
19387 * Vector and Matrix Arithmetic::
19388 * Set Operations::
19389 * Statistical Operations::
19390 * Reducing and Mapping::
19391 * Vector and Matrix Formats::
19392 @end menu
19393
19394 @node Packing and Unpacking, Building Vectors, Matrix Functions, Matrix Functions
19395 @section Packing and Unpacking
19396
19397 @noindent
19398 Calc's ``pack'' and ``unpack'' commands collect stack entries to build
19399 composite objects such as vectors and complex numbers. They are
19400 described in this chapter because they are most often used to build
19401 vectors.
19402
19403 @kindex v p
19404 @pindex calc-pack
19405 The @kbd{v p} (@code{calc-pack}) [@code{pack}] command collects several
19406 elements from the stack into a matrix, complex number, HMS form, error
19407 form, etc. It uses a numeric prefix argument to specify the kind of
19408 object to be built; this argument is referred to as the ``packing mode.''
19409 If the packing mode is a nonnegative integer, a vector of that
19410 length is created. For example, @kbd{C-u 5 v p} will pop the top
19411 five stack elements and push back a single vector of those five
19412 elements. (@kbd{C-u 0 v p} simply creates an empty vector.)
19413
19414 The same effect can be had by pressing @kbd{[} to push an incomplete
19415 vector on the stack, using @key{TAB} (@code{calc-roll-down}) to sneak
19416 the incomplete object up past a certain number of elements, and
19417 then pressing @kbd{]} to complete the vector.
19418
19419 Negative packing modes create other kinds of composite objects:
19420
19421 @table @cite
19422 @item -1
19423 Two values are collected to build a complex number. For example,
19424 @kbd{5 @key{RET} 7 C-u -1 v p} creates the complex number
19425 @expr{(5, 7)}. The result is always a rectangular complex
19426 number. The two input values must both be real numbers,
19427 i.e., integers, fractions, or floats. If they are not, Calc
19428 will instead build a formula like @samp{a + (0, 1) b}. (The
19429 other packing modes also create a symbolic answer if the
19430 components are not suitable.)
19431
19432 @item -2
19433 Two values are collected to build a polar complex number.
19434 The first is the magnitude; the second is the phase expressed
19435 in either degrees or radians according to the current angular
19436 mode.
19437
19438 @item -3
19439 Three values are collected into an HMS form. The first
19440 two values (hours and minutes) must be integers or
19441 integer-valued floats. The third value may be any real
19442 number.
19443
19444 @item -4
19445 Two values are collected into an error form. The inputs
19446 may be real numbers or formulas.
19447
19448 @item -5
19449 Two values are collected into a modulo form. The inputs
19450 must be real numbers.
19451
19452 @item -6
19453 Two values are collected into the interval @samp{[a .. b]}.
19454 The inputs may be real numbers, HMS or date forms, or formulas.
19455
19456 @item -7
19457 Two values are collected into the interval @samp{[a .. b)}.
19458
19459 @item -8
19460 Two values are collected into the interval @samp{(a .. b]}.
19461
19462 @item -9
19463 Two values are collected into the interval @samp{(a .. b)}.
19464
19465 @item -10
19466 Two integer values are collected into a fraction.
19467
19468 @item -11
19469 Two values are collected into a floating-point number.
19470 The first is the mantissa; the second, which must be an
19471 integer, is the exponent. The result is the mantissa
19472 times ten to the power of the exponent.
19473
19474 @item -12
19475 This is treated the same as @mathit{-11} by the @kbd{v p} command.
19476 When unpacking, @mathit{-12} specifies that a floating-point mantissa
19477 is desired.
19478
19479 @item -13
19480 A real number is converted into a date form.
19481
19482 @item -14
19483 Three numbers (year, month, day) are packed into a pure date form.
19484
19485 @item -15
19486 Six numbers are packed into a date/time form.
19487 @end table
19488
19489 With any of the two-input negative packing modes, either or both
19490 of the inputs may be vectors. If both are vectors of the same
19491 length, the result is another vector made by packing corresponding
19492 elements of the input vectors. If one input is a vector and the
19493 other is a plain number, the number is packed along with each vector
19494 element to produce a new vector. For example, @kbd{C-u -4 v p}
19495 could be used to convert a vector of numbers and a vector of errors
19496 into a single vector of error forms; @kbd{C-u -5 v p} could convert
19497 a vector of numbers and a single number @var{M} into a vector of
19498 numbers modulo @var{M}.
19499
19500 If you don't give a prefix argument to @kbd{v p}, it takes
19501 the packing mode from the top of the stack. The elements to
19502 be packed then begin at stack level 2. Thus
19503 @kbd{1 @key{RET} 2 @key{RET} 4 n v p} is another way to
19504 enter the error form @samp{1 +/- 2}.
19505
19506 If the packing mode taken from the stack is a vector, the result is a
19507 matrix with the dimensions specified by the elements of the vector,
19508 which must each be integers. For example, if the packing mode is
19509 @samp{[2, 3]}, then six numbers will be taken from the stack and
19510 returned in the form @samp{[@w{[a, b, c]}, [d, e, f]]}.
19511
19512 If any elements of the vector are negative, other kinds of
19513 packing are done at that level as described above. For
19514 example, @samp{[2, 3, -4]} takes 12 objects and creates a
19515 @texline @math{2\times3}
19516 @infoline 2x3
19517 matrix of error forms: @samp{[[a +/- b, c +/- d ... ]]}.
19518 Also, @samp{[-4, -10]} will convert four integers into an
19519 error form consisting of two fractions: @samp{a:b +/- c:d}.
19520
19521 @ignore
19522 @starindex
19523 @end ignore
19524 @tindex pack
19525 There is an equivalent algebraic function,
19526 @samp{pack(@var{mode}, @var{items})} where @var{mode} is a
19527 packing mode (an integer or a vector of integers) and @var{items}
19528 is a vector of objects to be packed (re-packed, really) according
19529 to that mode. For example, @samp{pack([3, -4], [a,b,c,d,e,f])}
19530 yields @samp{[a +/- b, @w{c +/- d}, e +/- f]}. The function is
19531 left in symbolic form if the packing mode is invalid, or if the
19532 number of data items does not match the number of items required
19533 by the mode.
19534
19535 @kindex v u
19536 @pindex calc-unpack
19537 The @kbd{v u} (@code{calc-unpack}) command takes the vector, complex
19538 number, HMS form, or other composite object on the top of the stack and
19539 ``unpacks'' it, pushing each of its elements onto the stack as separate
19540 objects. Thus, it is the ``inverse'' of @kbd{v p}. If the value
19541 at the top of the stack is a formula, @kbd{v u} unpacks it by pushing
19542 each of the arguments of the top-level operator onto the stack.
19543
19544 You can optionally give a numeric prefix argument to @kbd{v u}
19545 to specify an explicit (un)packing mode. If the packing mode is
19546 negative and the input is actually a vector or matrix, the result
19547 will be two or more similar vectors or matrices of the elements.
19548 For example, given the vector @samp{[@w{a +/- b}, c^2, d +/- 7]},
19549 the result of @kbd{C-u -4 v u} will be the two vectors
19550 @samp{[a, c^2, d]} and @w{@samp{[b, 0, 7]}}.
19551
19552 Note that the prefix argument can have an effect even when the input is
19553 not a vector. For example, if the input is the number @mathit{-5}, then
19554 @kbd{c-u -1 v u} yields @mathit{-5} and 0 (the components of @mathit{-5}
19555 when viewed as a rectangular complex number); @kbd{C-u -2 v u} yields 5
19556 and 180 (assuming Degrees mode); and @kbd{C-u -10 v u} yields @mathit{-5}
19557 and 1 (the numerator and denominator of @mathit{-5}, viewed as a rational
19558 number). Plain @kbd{v u} with this input would complain that the input
19559 is not a composite object.
19560
19561 Unpacking mode @mathit{-11} converts a float into an integer mantissa and
19562 an integer exponent, where the mantissa is not divisible by 10
19563 (except that 0.0 is represented by a mantissa and exponent of 0).
19564 Unpacking mode @mathit{-12} converts a float into a floating-point mantissa
19565 and integer exponent, where the mantissa (for non-zero numbers)
19566 is guaranteed to lie in the range [1 .. 10). In both cases,
19567 the mantissa is shifted left or right (and the exponent adjusted
19568 to compensate) in order to satisfy these constraints.
19569
19570 Positive unpacking modes are treated differently than for @kbd{v p}.
19571 A mode of 1 is much like plain @kbd{v u} with no prefix argument,
19572 except that in addition to the components of the input object,
19573 a suitable packing mode to re-pack the object is also pushed.
19574 Thus, @kbd{C-u 1 v u} followed by @kbd{v p} will re-build the
19575 original object.
19576
19577 A mode of 2 unpacks two levels of the object; the resulting
19578 re-packing mode will be a vector of length 2. This might be used
19579 to unpack a matrix, say, or a vector of error forms. Higher
19580 unpacking modes unpack the input even more deeply.
19581
19582 @ignore
19583 @starindex
19584 @end ignore
19585 @tindex unpack
19586 There are two algebraic functions analogous to @kbd{v u}.
19587 The @samp{unpack(@var{mode}, @var{item})} function unpacks the
19588 @var{item} using the given @var{mode}, returning the result as
19589 a vector of components. Here the @var{mode} must be an
19590 integer, not a vector. For example, @samp{unpack(-4, a +/- b)}
19591 returns @samp{[a, b]}, as does @samp{unpack(1, a +/- b)}.
19592
19593 @ignore
19594 @starindex
19595 @end ignore
19596 @tindex unpackt
19597 The @code{unpackt} function is like @code{unpack} but instead
19598 of returning a simple vector of items, it returns a vector of
19599 two things: The mode, and the vector of items. For example,
19600 @samp{unpackt(1, 2:3 +/- 1:4)} returns @samp{[-4, [2:3, 1:4]]},
19601 and @samp{unpackt(2, 2:3 +/- 1:4)} returns @samp{[[-4, -10], [2, 3, 1, 4]]}.
19602 The identity for re-building the original object is
19603 @samp{apply(pack, unpackt(@var{n}, @var{x})) = @var{x}}. (The
19604 @code{apply} function builds a function call given the function
19605 name and a vector of arguments.)
19606
19607 @cindex Numerator of a fraction, extracting
19608 Subscript notation is a useful way to extract a particular part
19609 of an object. For example, to get the numerator of a rational
19610 number, you can use @samp{unpack(-10, @var{x})_1}.
19611
19612 @node Building Vectors, Extracting Elements, Packing and Unpacking, Matrix Functions
19613 @section Building Vectors
19614
19615 @noindent
19616 Vectors and matrices can be added,
19617 subtracted, multiplied, and divided; @pxref{Basic Arithmetic}.
19618
19619 @kindex |
19620 @pindex calc-concat
19621 @ignore
19622 @mindex @null
19623 @end ignore
19624 @tindex |
19625 The @kbd{|} (@code{calc-concat}) command ``concatenates'' two vectors
19626 into one. For example, after @kbd{@w{[ 1 , 2 ]} [ 3 , 4 ] |}, the stack
19627 will contain the single vector @samp{[1, 2, 3, 4]}. If the arguments
19628 are matrices, the rows of the first matrix are concatenated with the
19629 rows of the second. (In other words, two matrices are just two vectors
19630 of row-vectors as far as @kbd{|} is concerned.)
19631
19632 If either argument to @kbd{|} is a scalar (a non-vector), it is treated
19633 like a one-element vector for purposes of concatenation: @kbd{1 [ 2 , 3 ] |}
19634 produces the vector @samp{[1, 2, 3]}. Likewise, if one argument is a
19635 matrix and the other is a plain vector, the vector is treated as a
19636 one-row matrix.
19637
19638 @kindex H |
19639 @tindex append
19640 The @kbd{H |} (@code{calc-append}) [@code{append}] command concatenates
19641 two vectors without any special cases. Both inputs must be vectors.
19642 Whether or not they are matrices is not taken into account. If either
19643 argument is a scalar, the @code{append} function is left in symbolic form.
19644 See also @code{cons} and @code{rcons} below.
19645
19646 @kindex I |
19647 @kindex H I |
19648 The @kbd{I |} and @kbd{H I |} commands are similar, but they use their
19649 two stack arguments in the opposite order. Thus @kbd{I |} is equivalent
19650 to @kbd{@key{TAB} |}, but possibly more convenient and also a bit faster.
19651
19652 @kindex v d
19653 @pindex calc-diag
19654 @tindex diag
19655 The @kbd{v d} (@code{calc-diag}) [@code{diag}] function builds a diagonal
19656 square matrix. The optional numeric prefix gives the number of rows
19657 and columns in the matrix. If the value at the top of the stack is a
19658 vector, the elements of the vector are used as the diagonal elements; the
19659 prefix, if specified, must match the size of the vector. If the value on
19660 the stack is a scalar, it is used for each element on the diagonal, and
19661 the prefix argument is required.
19662
19663 To build a constant square matrix, e.g., a
19664 @texline @math{3\times3}
19665 @infoline 3x3
19666 matrix filled with ones, use @kbd{0 M-3 v d 1 +}, i.e., build a zero
19667 matrix first and then add a constant value to that matrix. (Another
19668 alternative would be to use @kbd{v b} and @kbd{v a}; see below.)
19669
19670 @kindex v i
19671 @pindex calc-ident
19672 @tindex idn
19673 The @kbd{v i} (@code{calc-ident}) [@code{idn}] function builds an identity
19674 matrix of the specified size. It is a convenient form of @kbd{v d}
19675 where the diagonal element is always one. If no prefix argument is given,
19676 this command prompts for one.
19677
19678 In algebraic notation, @samp{idn(a,n)} acts much like @samp{diag(a,n)},
19679 except that @expr{a} is required to be a scalar (non-vector) quantity.
19680 If @expr{n} is omitted, @samp{idn(a)} represents @expr{a} times an
19681 identity matrix of unknown size. Calc can operate algebraically on
19682 such generic identity matrices, and if one is combined with a matrix
19683 whose size is known, it is converted automatically to an identity
19684 matrix of a suitable matching size. The @kbd{v i} command with an
19685 argument of zero creates a generic identity matrix, @samp{idn(1)}.
19686 Note that in dimensioned Matrix mode (@pxref{Matrix Mode}), generic
19687 identity matrices are immediately expanded to the current default
19688 dimensions.
19689
19690 @kindex v x
19691 @pindex calc-index
19692 @tindex index
19693 The @kbd{v x} (@code{calc-index}) [@code{index}] function builds a vector
19694 of consecutive integers from 1 to @var{n}, where @var{n} is the numeric
19695 prefix argument. If you do not provide a prefix argument, you will be
19696 prompted to enter a suitable number. If @var{n} is negative, the result
19697 is a vector of negative integers from @var{n} to @mathit{-1}.
19698
19699 With a prefix argument of just @kbd{C-u}, the @kbd{v x} command takes
19700 three values from the stack: @var{n}, @var{start}, and @var{incr} (with
19701 @var{incr} at top-of-stack). Counting starts at @var{start} and increases
19702 by @var{incr} for successive vector elements. If @var{start} or @var{n}
19703 is in floating-point format, the resulting vector elements will also be
19704 floats. Note that @var{start} and @var{incr} may in fact be any kind
19705 of numbers or formulas.
19706
19707 When @var{start} and @var{incr} are specified, a negative @var{n} has a
19708 different interpretation: It causes a geometric instead of arithmetic
19709 sequence to be generated. For example, @samp{index(-3, a, b)} produces
19710 @samp{[a, a b, a b^2]}. If you omit @var{incr} in the algebraic form,
19711 @samp{index(@var{n}, @var{start})}, the default value for @var{incr}
19712 is one for positive @var{n} or two for negative @var{n}.
19713
19714 @kindex v b
19715 @pindex calc-build-vector
19716 @tindex cvec
19717 The @kbd{v b} (@code{calc-build-vector}) [@code{cvec}] function builds a
19718 vector of @var{n} copies of the value on the top of the stack, where @var{n}
19719 is the numeric prefix argument. In algebraic formulas, @samp{cvec(x,n,m)}
19720 can also be used to build an @var{n}-by-@var{m} matrix of copies of @var{x}.
19721 (Interactively, just use @kbd{v b} twice: once to build a row, then again
19722 to build a matrix of copies of that row.)
19723
19724 @kindex v h
19725 @kindex I v h
19726 @pindex calc-head
19727 @pindex calc-tail
19728 @tindex head
19729 @tindex tail
19730 The @kbd{v h} (@code{calc-head}) [@code{head}] function returns the first
19731 element of a vector. The @kbd{I v h} (@code{calc-tail}) [@code{tail}]
19732 function returns the vector with its first element removed. In both
19733 cases, the argument must be a non-empty vector.
19734
19735 @kindex v k
19736 @pindex calc-cons
19737 @tindex cons
19738 The @kbd{v k} (@code{calc-cons}) [@code{cons}] function takes a value @var{h}
19739 and a vector @var{t} from the stack, and produces the vector whose head is
19740 @var{h} and whose tail is @var{t}. This is similar to @kbd{|}, except
19741 if @var{h} is itself a vector, @kbd{|} will concatenate the two vectors
19742 whereas @code{cons} will insert @var{h} at the front of the vector @var{t}.
19743
19744 @kindex H v h
19745 @tindex rhead
19746 @ignore
19747 @mindex @idots
19748 @end ignore
19749 @kindex H I v h
19750 @ignore
19751 @mindex @null
19752 @end ignore
19753 @kindex H v k
19754 @ignore
19755 @mindex @null
19756 @end ignore
19757 @tindex rtail
19758 @ignore
19759 @mindex @null
19760 @end ignore
19761 @tindex rcons
19762 Each of these three functions also accepts the Hyperbolic flag [@code{rhead},
19763 @code{rtail}, @code{rcons}] in which case @var{t} instead represents
19764 the @emph{last} single element of the vector, with @var{h}
19765 representing the remainder of the vector. Thus the vector
19766 @samp{[a, b, c, d] = cons(a, [b, c, d]) = rcons([a, b, c], d)}.
19767 Also, @samp{head([a, b, c, d]) = a}, @samp{tail([a, b, c, d]) = [b, c, d]},
19768 @samp{rhead([a, b, c, d]) = [a, b, c]}, and @samp{rtail([a, b, c, d]) = d}.
19769
19770 @node Extracting Elements, Manipulating Vectors, Building Vectors, Matrix Functions
19771 @section Extracting Vector Elements
19772
19773 @noindent
19774 @kindex v r
19775 @pindex calc-mrow
19776 @tindex mrow
19777 The @kbd{v r} (@code{calc-mrow}) [@code{mrow}] command extracts one row of
19778 the matrix on the top of the stack, or one element of the plain vector on
19779 the top of the stack. The row or element is specified by the numeric
19780 prefix argument; the default is to prompt for the row or element number.
19781 The matrix or vector is replaced by the specified row or element in the
19782 form of a vector or scalar, respectively.
19783
19784 @cindex Permutations, applying
19785 With a prefix argument of @kbd{C-u} only, @kbd{v r} takes the index of
19786 the element or row from the top of the stack, and the vector or matrix
19787 from the second-to-top position. If the index is itself a vector of
19788 integers, the result is a vector of the corresponding elements of the
19789 input vector, or a matrix of the corresponding rows of the input matrix.
19790 This command can be used to obtain any permutation of a vector.
19791
19792 With @kbd{C-u}, if the index is an interval form with integer components,
19793 it is interpreted as a range of indices and the corresponding subvector or
19794 submatrix is returned.
19795
19796 @cindex Subscript notation
19797 @kindex a _
19798 @pindex calc-subscript
19799 @tindex subscr
19800 @tindex _
19801 Subscript notation in algebraic formulas (@samp{a_b}) stands for the
19802 Calc function @code{subscr}, which is synonymous with @code{mrow}.
19803 Thus, @samp{[x, y, z]_k} produces @expr{x}, @expr{y}, or @expr{z} if
19804 @expr{k} is one, two, or three, respectively. A double subscript
19805 (@samp{M_i_j}, equivalent to @samp{subscr(subscr(M, i), j)}) will
19806 access the element at row @expr{i}, column @expr{j} of a matrix.
19807 The @kbd{a _} (@code{calc-subscript}) command creates a subscript
19808 formula @samp{a_b} out of two stack entries. (It is on the @kbd{a}
19809 ``algebra'' prefix because subscripted variables are often used
19810 purely as an algebraic notation.)
19811
19812 @tindex mrrow
19813 Given a negative prefix argument, @kbd{v r} instead deletes one row or
19814 element from the matrix or vector on the top of the stack. Thus
19815 @kbd{C-u 2 v r} replaces a matrix with its second row, but @kbd{C-u -2 v r}
19816 replaces the matrix with the same matrix with its second row removed.
19817 In algebraic form this function is called @code{mrrow}.
19818
19819 @tindex getdiag
19820 Given a prefix argument of zero, @kbd{v r} extracts the diagonal elements
19821 of a square matrix in the form of a vector. In algebraic form this
19822 function is called @code{getdiag}.
19823
19824 @kindex v c
19825 @pindex calc-mcol
19826 @tindex mcol
19827 @tindex mrcol
19828 The @kbd{v c} (@code{calc-mcol}) [@code{mcol} or @code{mrcol}] command is
19829 the analogous operation on columns of a matrix. Given a plain vector
19830 it extracts (or removes) one element, just like @kbd{v r}. If the
19831 index in @kbd{C-u v c} is an interval or vector and the argument is a
19832 matrix, the result is a submatrix with only the specified columns
19833 retained (and possibly permuted in the case of a vector index).
19834
19835 To extract a matrix element at a given row and column, use @kbd{v r} to
19836 extract the row as a vector, then @kbd{v c} to extract the column element
19837 from that vector. In algebraic formulas, it is often more convenient to
19838 use subscript notation: @samp{m_i_j} gives row @expr{i}, column @expr{j}
19839 of matrix @expr{m}.
19840
19841 @kindex v s
19842 @pindex calc-subvector
19843 @tindex subvec
19844 The @kbd{v s} (@code{calc-subvector}) [@code{subvec}] command extracts
19845 a subvector of a vector. The arguments are the vector, the starting
19846 index, and the ending index, with the ending index in the top-of-stack
19847 position. The starting index indicates the first element of the vector
19848 to take. The ending index indicates the first element @emph{past} the
19849 range to be taken. Thus, @samp{subvec([a, b, c, d, e], 2, 4)} produces
19850 the subvector @samp{[b, c]}. You could get the same result using
19851 @samp{mrow([a, b, c, d, e], @w{[2 .. 4)})}.
19852
19853 If either the start or the end index is zero or negative, it is
19854 interpreted as relative to the end of the vector. Thus
19855 @samp{subvec([a, b, c, d, e], 2, -2)} also produces @samp{[b, c]}. In
19856 the algebraic form, the end index can be omitted in which case it
19857 is taken as zero, i.e., elements from the starting element to the
19858 end of the vector are used. The infinity symbol, @code{inf}, also
19859 has this effect when used as the ending index.
19860
19861 @kindex I v s
19862 @tindex rsubvec
19863 With the Inverse flag, @kbd{I v s} [@code{rsubvec}] removes a subvector
19864 from a vector. The arguments are interpreted the same as for the
19865 normal @kbd{v s} command. Thus, @samp{rsubvec([a, b, c, d, e], 2, 4)}
19866 produces @samp{[a, d, e]}. It is always true that @code{subvec} and
19867 @code{rsubvec} return complementary parts of the input vector.
19868
19869 @xref{Selecting Subformulas}, for an alternative way to operate on
19870 vectors one element at a time.
19871
19872 @node Manipulating Vectors, Vector and Matrix Arithmetic, Extracting Elements, Matrix Functions
19873 @section Manipulating Vectors
19874
19875 @noindent
19876 @kindex v l
19877 @pindex calc-vlength
19878 @tindex vlen
19879 The @kbd{v l} (@code{calc-vlength}) [@code{vlen}] command computes the
19880 length of a vector. The length of a non-vector is considered to be zero.
19881 Note that matrices are just vectors of vectors for the purposes of this
19882 command.
19883
19884 @kindex H v l
19885 @tindex mdims
19886 With the Hyperbolic flag, @kbd{H v l} [@code{mdims}] computes a vector
19887 of the dimensions of a vector, matrix, or higher-order object. For
19888 example, @samp{mdims([[a,b,c],[d,e,f]])} returns @samp{[2, 3]} since
19889 its argument is a
19890 @texline @math{2\times3}
19891 @infoline 2x3
19892 matrix.
19893
19894 @kindex v f
19895 @pindex calc-vector-find
19896 @tindex find
19897 The @kbd{v f} (@code{calc-vector-find}) [@code{find}] command searches
19898 along a vector for the first element equal to a given target. The target
19899 is on the top of the stack; the vector is in the second-to-top position.
19900 If a match is found, the result is the index of the matching element.
19901 Otherwise, the result is zero. The numeric prefix argument, if given,
19902 allows you to select any starting index for the search.
19903
19904 @kindex v a
19905 @pindex calc-arrange-vector
19906 @tindex arrange
19907 @cindex Arranging a matrix
19908 @cindex Reshaping a matrix
19909 @cindex Flattening a matrix
19910 The @kbd{v a} (@code{calc-arrange-vector}) [@code{arrange}] command
19911 rearranges a vector to have a certain number of columns and rows. The
19912 numeric prefix argument specifies the number of columns; if you do not
19913 provide an argument, you will be prompted for the number of columns.
19914 The vector or matrix on the top of the stack is @dfn{flattened} into a
19915 plain vector. If the number of columns is nonzero, this vector is
19916 then formed into a matrix by taking successive groups of @var{n} elements.
19917 If the number of columns does not evenly divide the number of elements
19918 in the vector, the last row will be short and the result will not be
19919 suitable for use as a matrix. For example, with the matrix
19920 @samp{[[1, 2], @w{[3, 4]}]} on the stack, @kbd{v a 4} produces
19921 @samp{[[1, 2, 3, 4]]} (a
19922 @texline @math{1\times4}
19923 @infoline 1x4
19924 matrix), @kbd{v a 1} produces @samp{[[1], [2], [3], [4]]} (a
19925 @texline @math{4\times1}
19926 @infoline 4x1
19927 matrix), @kbd{v a 2} produces @samp{[[1, 2], [3, 4]]} (the original
19928 @texline @math{2\times2}
19929 @infoline 2x2
19930 matrix), @w{@kbd{v a 3}} produces @samp{[[1, 2, 3], [4]]} (not a
19931 matrix), and @kbd{v a 0} produces the flattened list
19932 @samp{[1, 2, @w{3, 4}]}.
19933
19934 @cindex Sorting data
19935 @kindex V S
19936 @kindex I V S
19937 @pindex calc-sort
19938 @tindex sort
19939 @tindex rsort
19940 The @kbd{V S} (@code{calc-sort}) [@code{sort}] command sorts the elements of
19941 a vector into increasing order. Real numbers, real infinities, and
19942 constant interval forms come first in this ordering; next come other
19943 kinds of numbers, then variables (in alphabetical order), then finally
19944 come formulas and other kinds of objects; these are sorted according
19945 to a kind of lexicographic ordering with the useful property that
19946 one vector is less or greater than another if the first corresponding
19947 unequal elements are less or greater, respectively. Since quoted strings
19948 are stored by Calc internally as vectors of ASCII character codes
19949 (@pxref{Strings}), this means vectors of strings are also sorted into
19950 alphabetical order by this command.
19951
19952 The @kbd{I V S} [@code{rsort}] command sorts a vector into decreasing order.
19953
19954 @cindex Permutation, inverse of
19955 @cindex Inverse of permutation
19956 @cindex Index tables
19957 @cindex Rank tables
19958 @kindex V G
19959 @kindex I V G
19960 @pindex calc-grade
19961 @tindex grade
19962 @tindex rgrade
19963 The @kbd{V G} (@code{calc-grade}) [@code{grade}, @code{rgrade}] command
19964 produces an index table or permutation vector which, if applied to the
19965 input vector (as the index of @kbd{C-u v r}, say), would sort the vector.
19966 A permutation vector is just a vector of integers from 1 to @var{n}, where
19967 each integer occurs exactly once. One application of this is to sort a
19968 matrix of data rows using one column as the sort key; extract that column,
19969 grade it with @kbd{V G}, then use the result to reorder the original matrix
19970 with @kbd{C-u v r}. Another interesting property of the @code{V G} command
19971 is that, if the input is itself a permutation vector, the result will
19972 be the inverse of the permutation. The inverse of an index table is
19973 a rank table, whose @var{k}th element says where the @var{k}th original
19974 vector element will rest when the vector is sorted. To get a rank
19975 table, just use @kbd{V G V G}.
19976
19977 With the Inverse flag, @kbd{I V G} produces an index table that would
19978 sort the input into decreasing order. Note that @kbd{V S} and @kbd{V G}
19979 use a ``stable'' sorting algorithm, i.e., any two elements which are equal
19980 will not be moved out of their original order. Generally there is no way
19981 to tell with @kbd{V S}, since two elements which are equal look the same,
19982 but with @kbd{V G} this can be an important issue. In the matrix-of-rows
19983 example, suppose you have names and telephone numbers as two columns and
19984 you wish to sort by phone number primarily, and by name when the numbers
19985 are equal. You can sort the data matrix by names first, and then again
19986 by phone numbers. Because the sort is stable, any two rows with equal
19987 phone numbers will remain sorted by name even after the second sort.
19988
19989 @cindex Histograms
19990 @kindex V H
19991 @pindex calc-histogram
19992 @ignore
19993 @mindex histo@idots
19994 @end ignore
19995 @tindex histogram
19996 The @kbd{V H} (@code{calc-histogram}) [@code{histogram}] command builds a
19997 histogram of a vector of numbers. Vector elements are assumed to be
19998 integers or real numbers in the range [0..@var{n}) for some ``number of
19999 bins'' @var{n}, which is the numeric prefix argument given to the
20000 command. The result is a vector of @var{n} counts of how many times
20001 each value appeared in the original vector. Non-integers in the input
20002 are rounded down to integers. Any vector elements outside the specified
20003 range are ignored. (You can tell if elements have been ignored by noting
20004 that the counts in the result vector don't add up to the length of the
20005 input vector.)
20006
20007 @kindex H V H
20008 With the Hyperbolic flag, @kbd{H V H} pulls two vectors from the stack.
20009 The second-to-top vector is the list of numbers as before. The top
20010 vector is an equal-sized list of ``weights'' to attach to the elements
20011 of the data vector. For example, if the first data element is 4.2 and
20012 the first weight is 10, then 10 will be added to bin 4 of the result
20013 vector. Without the hyperbolic flag, every element has a weight of one.
20014
20015 @kindex v t
20016 @pindex calc-transpose
20017 @tindex trn
20018 The @kbd{v t} (@code{calc-transpose}) [@code{trn}] command computes
20019 the transpose of the matrix at the top of the stack. If the argument
20020 is a plain vector, it is treated as a row vector and transposed into
20021 a one-column matrix.
20022
20023 @kindex v v
20024 @pindex calc-reverse-vector
20025 @tindex rev
20026 The @kbd{v v} (@code{calc-reverse-vector}) [@code{vec}] command reverses
20027 a vector end-for-end. Given a matrix, it reverses the order of the rows.
20028 (To reverse the columns instead, just use @kbd{v t v v v t}. The same
20029 principle can be used to apply other vector commands to the columns of
20030 a matrix.)
20031
20032 @kindex v m
20033 @pindex calc-mask-vector
20034 @tindex vmask
20035 The @kbd{v m} (@code{calc-mask-vector}) [@code{vmask}] command uses
20036 one vector as a mask to extract elements of another vector. The mask
20037 is in the second-to-top position; the target vector is on the top of
20038 the stack. These vectors must have the same length. The result is
20039 the same as the target vector, but with all elements which correspond
20040 to zeros in the mask vector deleted. Thus, for example,
20041 @samp{vmask([1, 0, 1, 0, 1], [a, b, c, d, e])} produces @samp{[a, c, e]}.
20042 @xref{Logical Operations}.
20043
20044 @kindex v e
20045 @pindex calc-expand-vector
20046 @tindex vexp
20047 The @kbd{v e} (@code{calc-expand-vector}) [@code{vexp}] command
20048 expands a vector according to another mask vector. The result is a
20049 vector the same length as the mask, but with nonzero elements replaced
20050 by successive elements from the target vector. The length of the target
20051 vector is normally the number of nonzero elements in the mask. If the
20052 target vector is longer, its last few elements are lost. If the target
20053 vector is shorter, the last few nonzero mask elements are left
20054 unreplaced in the result. Thus @samp{vexp([2, 0, 3, 0, 7], [a, b])}
20055 produces @samp{[a, 0, b, 0, 7]}.
20056
20057 @kindex H v e
20058 With the Hyperbolic flag, @kbd{H v e} takes a filler value from the
20059 top of the stack; the mask and target vectors come from the third and
20060 second elements of the stack. This filler is used where the mask is
20061 zero: @samp{vexp([2, 0, 3, 0, 7], [a, b], z)} produces
20062 @samp{[a, z, c, z, 7]}. If the filler value is itself a vector,
20063 then successive values are taken from it, so that the effect is to
20064 interleave two vectors according to the mask:
20065 @samp{vexp([2, 0, 3, 7, 0, 0], [a, b], [x, y])} produces
20066 @samp{[a, x, b, 7, y, 0]}.
20067
20068 Another variation on the masking idea is to combine @samp{[a, b, c, d, e]}
20069 with the mask @samp{[1, 0, 1, 0, 1]} to produce @samp{[a, 0, c, 0, e]}.
20070 You can accomplish this with @kbd{V M a &}, mapping the logical ``and''
20071 operation across the two vectors. @xref{Logical Operations}. Note that
20072 the @code{? :} operation also discussed there allows other types of
20073 masking using vectors.
20074
20075 @node Vector and Matrix Arithmetic, Set Operations, Manipulating Vectors, Matrix Functions
20076 @section Vector and Matrix Arithmetic
20077
20078 @noindent
20079 Basic arithmetic operations like addition and multiplication are defined
20080 for vectors and matrices as well as for numbers. Division of matrices, in
20081 the sense of multiplying by the inverse, is supported. (Division by a
20082 matrix actually uses LU-decomposition for greater accuracy and speed.)
20083 @xref{Basic Arithmetic}.
20084
20085 The following functions are applied element-wise if their arguments are
20086 vectors or matrices: @code{change-sign}, @code{conj}, @code{arg},
20087 @code{re}, @code{im}, @code{polar}, @code{rect}, @code{clean},
20088 @code{float}, @code{frac}. @xref{Function Index}.
20089
20090 @kindex V J
20091 @pindex calc-conj-transpose
20092 @tindex ctrn
20093 The @kbd{V J} (@code{calc-conj-transpose}) [@code{ctrn}] command computes
20094 the conjugate transpose of its argument, i.e., @samp{conj(trn(x))}.
20095
20096 @ignore
20097 @mindex A
20098 @end ignore
20099 @kindex A (vectors)
20100 @pindex calc-abs (vectors)
20101 @ignore
20102 @mindex abs
20103 @end ignore
20104 @tindex abs (vectors)
20105 The @kbd{A} (@code{calc-abs}) [@code{abs}] command computes the
20106 Frobenius norm of a vector or matrix argument. This is the square
20107 root of the sum of the squares of the absolute values of the
20108 elements of the vector or matrix. If the vector is interpreted as
20109 a point in two- or three-dimensional space, this is the distance
20110 from that point to the origin.
20111
20112 @kindex v n
20113 @pindex calc-rnorm
20114 @tindex rnorm
20115 The @kbd{v n} (@code{calc-rnorm}) [@code{rnorm}] command computes
20116 the row norm, or infinity-norm, of a vector or matrix. For a plain
20117 vector, this is the maximum of the absolute values of the elements.
20118 For a matrix, this is the maximum of the row-absolute-value-sums,
20119 i.e., of the sums of the absolute values of the elements along the
20120 various rows.
20121
20122 @kindex V N
20123 @pindex calc-cnorm
20124 @tindex cnorm
20125 The @kbd{V N} (@code{calc-cnorm}) [@code{cnorm}] command computes
20126 the column norm, or one-norm, of a vector or matrix. For a plain
20127 vector, this is the sum of the absolute values of the elements.
20128 For a matrix, this is the maximum of the column-absolute-value-sums.
20129 General @expr{k}-norms for @expr{k} other than one or infinity are
20130 not provided.
20131
20132 @kindex V C
20133 @pindex calc-cross
20134 @tindex cross
20135 The @kbd{V C} (@code{calc-cross}) [@code{cross}] command computes the
20136 right-handed cross product of two vectors, each of which must have
20137 exactly three elements.
20138
20139 @ignore
20140 @mindex &
20141 @end ignore
20142 @kindex & (matrices)
20143 @pindex calc-inv (matrices)
20144 @ignore
20145 @mindex inv
20146 @end ignore
20147 @tindex inv (matrices)
20148 The @kbd{&} (@code{calc-inv}) [@code{inv}] command computes the
20149 inverse of a square matrix. If the matrix is singular, the inverse
20150 operation is left in symbolic form. Matrix inverses are recorded so
20151 that once an inverse (or determinant) of a particular matrix has been
20152 computed, the inverse and determinant of the matrix can be recomputed
20153 quickly in the future.
20154
20155 If the argument to @kbd{&} is a plain number @expr{x}, this
20156 command simply computes @expr{1/x}. This is okay, because the
20157 @samp{/} operator also does a matrix inversion when dividing one
20158 by a matrix.
20159
20160 @kindex V D
20161 @pindex calc-mdet
20162 @tindex det
20163 The @kbd{V D} (@code{calc-mdet}) [@code{det}] command computes the
20164 determinant of a square matrix.
20165
20166 @kindex V L
20167 @pindex calc-mlud
20168 @tindex lud
20169 The @kbd{V L} (@code{calc-mlud}) [@code{lud}] command computes the
20170 LU decomposition of a matrix. The result is a list of three matrices
20171 which, when multiplied together left-to-right, form the original matrix.
20172 The first is a permutation matrix that arises from pivoting in the
20173 algorithm, the second is lower-triangular with ones on the diagonal,
20174 and the third is upper-triangular.
20175
20176 @kindex V T
20177 @pindex calc-mtrace
20178 @tindex tr
20179 The @kbd{V T} (@code{calc-mtrace}) [@code{tr}] command computes the
20180 trace of a square matrix. This is defined as the sum of the diagonal
20181 elements of the matrix.
20182
20183 @node Set Operations, Statistical Operations, Vector and Matrix Arithmetic, Matrix Functions
20184 @section Set Operations using Vectors
20185
20186 @noindent
20187 @cindex Sets, as vectors
20188 Calc includes several commands which interpret vectors as @dfn{sets} of
20189 objects. A set is a collection of objects; any given object can appear
20190 only once in the set. Calc stores sets as vectors of objects in
20191 sorted order. Objects in a Calc set can be any of the usual things,
20192 such as numbers, variables, or formulas. Two set elements are considered
20193 equal if they are identical, except that numerically equal numbers like
20194 the integer 4 and the float 4.0 are considered equal even though they
20195 are not ``identical.'' Variables are treated like plain symbols without
20196 attached values by the set operations; subtracting the set @samp{[b]}
20197 from @samp{[a, b]} always yields the set @samp{[a]} even though if
20198 the variables @samp{a} and @samp{b} both equaled 17, you might
20199 expect the answer @samp{[]}.
20200
20201 If a set contains interval forms, then it is assumed to be a set of
20202 real numbers. In this case, all set operations require the elements
20203 of the set to be only things that are allowed in intervals: Real
20204 numbers, plus and minus infinity, HMS forms, and date forms. If
20205 there are variables or other non-real objects present in a real set,
20206 all set operations on it will be left in unevaluated form.
20207
20208 If the input to a set operation is a plain number or interval form
20209 @var{a}, it is treated like the one-element vector @samp{[@var{a}]}.
20210 The result is always a vector, except that if the set consists of a
20211 single interval, the interval itself is returned instead.
20212
20213 @xref{Logical Operations}, for the @code{in} function which tests if
20214 a certain value is a member of a given set. To test if the set @expr{A}
20215 is a subset of the set @expr{B}, use @samp{vdiff(A, B) = []}.
20216
20217 @kindex V +
20218 @pindex calc-remove-duplicates
20219 @tindex rdup
20220 The @kbd{V +} (@code{calc-remove-duplicates}) [@code{rdup}] command
20221 converts an arbitrary vector into set notation. It works by sorting
20222 the vector as if by @kbd{V S}, then removing duplicates. (For example,
20223 @kbd{[a, 5, 4, a, 4.0]} is sorted to @samp{[4, 4.0, 5, a, a]} and then
20224 reduced to @samp{[4, 5, a]}). Overlapping intervals are merged as
20225 necessary. You rarely need to use @kbd{V +} explicitly, since all the
20226 other set-based commands apply @kbd{V +} to their inputs before using
20227 them.
20228
20229 @kindex V V
20230 @pindex calc-set-union
20231 @tindex vunion
20232 The @kbd{V V} (@code{calc-set-union}) [@code{vunion}] command computes
20233 the union of two sets. An object is in the union of two sets if and
20234 only if it is in either (or both) of the input sets. (You could
20235 accomplish the same thing by concatenating the sets with @kbd{|},
20236 then using @kbd{V +}.)
20237
20238 @kindex V ^
20239 @pindex calc-set-intersect
20240 @tindex vint
20241 The @kbd{V ^} (@code{calc-set-intersect}) [@code{vint}] command computes
20242 the intersection of two sets. An object is in the intersection if
20243 and only if it is in both of the input sets. Thus if the input
20244 sets are disjoint, i.e., if they share no common elements, the result
20245 will be the empty vector @samp{[]}. Note that the characters @kbd{V}
20246 and @kbd{^} were chosen to be close to the conventional mathematical
20247 notation for set
20248 @texline union@tie{}(@math{A \cup B})
20249 @infoline union
20250 and
20251 @texline intersection@tie{}(@math{A \cap B}).
20252 @infoline intersection.
20253
20254 @kindex V -
20255 @pindex calc-set-difference
20256 @tindex vdiff
20257 The @kbd{V -} (@code{calc-set-difference}) [@code{vdiff}] command computes
20258 the difference between two sets. An object is in the difference
20259 @expr{A - B} if and only if it is in @expr{A} but not in @expr{B}.
20260 Thus subtracting @samp{[y,z]} from a set will remove the elements
20261 @samp{y} and @samp{z} if they are present. You can also think of this
20262 as a general @dfn{set complement} operator; if @expr{A} is the set of
20263 all possible values, then @expr{A - B} is the ``complement'' of @expr{B}.
20264 Obviously this is only practical if the set of all possible values in
20265 your problem is small enough to list in a Calc vector (or simple
20266 enough to express in a few intervals).
20267
20268 @kindex V X
20269 @pindex calc-set-xor
20270 @tindex vxor
20271 The @kbd{V X} (@code{calc-set-xor}) [@code{vxor}] command computes
20272 the ``exclusive-or,'' or ``symmetric difference'' of two sets.
20273 An object is in the symmetric difference of two sets if and only
20274 if it is in one, but @emph{not} both, of the sets. Objects that
20275 occur in both sets ``cancel out.''
20276
20277 @kindex V ~
20278 @pindex calc-set-complement
20279 @tindex vcompl
20280 The @kbd{V ~} (@code{calc-set-complement}) [@code{vcompl}] command
20281 computes the complement of a set with respect to the real numbers.
20282 Thus @samp{vcompl(x)} is equivalent to @samp{vdiff([-inf .. inf], x)}.
20283 For example, @samp{vcompl([2, (3 .. 4]])} evaluates to
20284 @samp{[[-inf .. 2), (2 .. 3], (4 .. inf]]}.
20285
20286 @kindex V F
20287 @pindex calc-set-floor
20288 @tindex vfloor
20289 The @kbd{V F} (@code{calc-set-floor}) [@code{vfloor}] command
20290 reinterprets a set as a set of integers. Any non-integer values,
20291 and intervals that do not enclose any integers, are removed. Open
20292 intervals are converted to equivalent closed intervals. Successive
20293 integers are converted into intervals of integers. For example, the
20294 complement of the set @samp{[2, 6, 7, 8]} is messy, but if you wanted
20295 the complement with respect to the set of integers you could type
20296 @kbd{V ~ V F} to get @samp{[[-inf .. 1], [3 .. 5], [9 .. inf]]}.
20297
20298 @kindex V E
20299 @pindex calc-set-enumerate
20300 @tindex venum
20301 The @kbd{V E} (@code{calc-set-enumerate}) [@code{venum}] command
20302 converts a set of integers into an explicit vector. Intervals in
20303 the set are expanded out to lists of all integers encompassed by
20304 the intervals. This only works for finite sets (i.e., sets which
20305 do not involve @samp{-inf} or @samp{inf}).
20306
20307 @kindex V :
20308 @pindex calc-set-span
20309 @tindex vspan
20310 The @kbd{V :} (@code{calc-set-span}) [@code{vspan}] command converts any
20311 set of reals into an interval form that encompasses all its elements.
20312 The lower limit will be the smallest element in the set; the upper
20313 limit will be the largest element. For an empty set, @samp{vspan([])}
20314 returns the empty interval @w{@samp{[0 .. 0)}}.
20315
20316 @kindex V #
20317 @pindex calc-set-cardinality
20318 @tindex vcard
20319 The @kbd{V #} (@code{calc-set-cardinality}) [@code{vcard}] command counts
20320 the number of integers in a set. The result is the length of the vector
20321 that would be produced by @kbd{V E}, although the computation is much
20322 more efficient than actually producing that vector.
20323
20324 @cindex Sets, as binary numbers
20325 Another representation for sets that may be more appropriate in some
20326 cases is binary numbers. If you are dealing with sets of integers
20327 in the range 0 to 49, you can use a 50-bit binary number where a
20328 particular bit is 1 if the corresponding element is in the set.
20329 @xref{Binary Functions}, for a list of commands that operate on
20330 binary numbers. Note that many of the above set operations have
20331 direct equivalents in binary arithmetic: @kbd{b o} (@code{calc-or}),
20332 @kbd{b a} (@code{calc-and}), @kbd{b d} (@code{calc-diff}),
20333 @kbd{b x} (@code{calc-xor}), and @kbd{b n} (@code{calc-not}),
20334 respectively. You can use whatever representation for sets is most
20335 convenient to you.
20336
20337 @kindex b p
20338 @kindex b u
20339 @pindex calc-pack-bits
20340 @pindex calc-unpack-bits
20341 @tindex vpack
20342 @tindex vunpack
20343 The @kbd{b u} (@code{calc-unpack-bits}) [@code{vunpack}] command
20344 converts an integer that represents a set in binary into a set
20345 in vector/interval notation. For example, @samp{vunpack(67)}
20346 returns @samp{[[0 .. 1], 6]}. If the input is negative, the set
20347 it represents is semi-infinite: @samp{vunpack(-4) = [2 .. inf)}.
20348 Use @kbd{V E} afterwards to expand intervals to individual
20349 values if you wish. Note that this command uses the @kbd{b}
20350 (binary) prefix key.
20351
20352 The @kbd{b p} (@code{calc-pack-bits}) [@code{vpack}] command
20353 converts the other way, from a vector or interval representing
20354 a set of nonnegative integers into a binary integer describing
20355 the same set. The set may include positive infinity, but must
20356 not include any negative numbers. The input is interpreted as a
20357 set of integers in the sense of @kbd{V F} (@code{vfloor}). Beware
20358 that a simple input like @samp{[100]} can result in a huge integer
20359 representation
20360 @texline (@math{2^{100}}, a 31-digit integer, in this case).
20361 @infoline (@expr{2^100}, a 31-digit integer, in this case).
20362
20363 @node Statistical Operations, Reducing and Mapping, Set Operations, Matrix Functions
20364 @section Statistical Operations on Vectors
20365
20366 @noindent
20367 @cindex Statistical functions
20368 The commands in this section take vectors as arguments and compute
20369 various statistical measures on the data stored in the vectors. The
20370 references used in the definitions of these functions are Bevington's
20371 @emph{Data Reduction and Error Analysis for the Physical Sciences},
20372 and @emph{Numerical Recipes} by Press, Flannery, Teukolsky and
20373 Vetterling.
20374
20375 The statistical commands use the @kbd{u} prefix key followed by
20376 a shifted letter or other character.
20377
20378 @xref{Manipulating Vectors}, for a description of @kbd{V H}
20379 (@code{calc-histogram}).
20380
20381 @xref{Curve Fitting}, for the @kbd{a F} command for doing
20382 least-squares fits to statistical data.
20383
20384 @xref{Probability Distribution Functions}, for several common
20385 probability distribution functions.
20386
20387 @menu
20388 * Single-Variable Statistics::
20389 * Paired-Sample Statistics::
20390 @end menu
20391
20392 @node Single-Variable Statistics, Paired-Sample Statistics, Statistical Operations, Statistical Operations
20393 @subsection Single-Variable Statistics
20394
20395 @noindent
20396 These functions do various statistical computations on single
20397 vectors. Given a numeric prefix argument, they actually pop
20398 @var{n} objects from the stack and combine them into a data
20399 vector. Each object may be either a number or a vector; if a
20400 vector, any sub-vectors inside it are ``flattened'' as if by
20401 @kbd{v a 0}; @pxref{Manipulating Vectors}. By default one object
20402 is popped, which (in order to be useful) is usually a vector.
20403
20404 If an argument is a variable name, and the value stored in that
20405 variable is a vector, then the stored vector is used. This method
20406 has the advantage that if your data vector is large, you can avoid
20407 the slow process of manipulating it directly on the stack.
20408
20409 These functions are left in symbolic form if any of their arguments
20410 are not numbers or vectors, e.g., if an argument is a formula, or
20411 a non-vector variable. However, formulas embedded within vector
20412 arguments are accepted; the result is a symbolic representation
20413 of the computation, based on the assumption that the formula does
20414 not itself represent a vector. All varieties of numbers such as
20415 error forms and interval forms are acceptable.
20416
20417 Some of the functions in this section also accept a single error form
20418 or interval as an argument. They then describe a property of the
20419 normal or uniform (respectively) statistical distribution described
20420 by the argument. The arguments are interpreted in the same way as
20421 the @var{M} argument of the random number function @kbd{k r}. In
20422 particular, an interval with integer limits is considered an integer
20423 distribution, so that @samp{[2 .. 6)} is the same as @samp{[2 .. 5]}.
20424 An interval with at least one floating-point limit is a continuous
20425 distribution: @samp{[2.0 .. 6.0)} is @emph{not} the same as
20426 @samp{[2.0 .. 5.0]}!
20427
20428 @kindex u #
20429 @pindex calc-vector-count
20430 @tindex vcount
20431 The @kbd{u #} (@code{calc-vector-count}) [@code{vcount}] command
20432 computes the number of data values represented by the inputs.
20433 For example, @samp{vcount(1, [2, 3], [[4, 5], [], x, y])} returns 7.
20434 If the argument is a single vector with no sub-vectors, this
20435 simply computes the length of the vector.
20436
20437 @kindex u +
20438 @kindex u *
20439 @pindex calc-vector-sum
20440 @pindex calc-vector-prod
20441 @tindex vsum
20442 @tindex vprod
20443 @cindex Summations (statistical)
20444 The @kbd{u +} (@code{calc-vector-sum}) [@code{vsum}] command
20445 computes the sum of the data values. The @kbd{u *}
20446 (@code{calc-vector-prod}) [@code{vprod}] command computes the
20447 product of the data values. If the input is a single flat vector,
20448 these are the same as @kbd{V R +} and @kbd{V R *}
20449 (@pxref{Reducing and Mapping}).
20450
20451 @kindex u X
20452 @kindex u N
20453 @pindex calc-vector-max
20454 @pindex calc-vector-min
20455 @tindex vmax
20456 @tindex vmin
20457 The @kbd{u X} (@code{calc-vector-max}) [@code{vmax}] command
20458 computes the maximum of the data values, and the @kbd{u N}
20459 (@code{calc-vector-min}) [@code{vmin}] command computes the minimum.
20460 If the argument is an interval, this finds the minimum or maximum
20461 value in the interval. (Note that @samp{vmax([2..6)) = 5} as
20462 described above.) If the argument is an error form, this returns
20463 plus or minus infinity.
20464
20465 @kindex u M
20466 @pindex calc-vector-mean
20467 @tindex vmean
20468 @cindex Mean of data values
20469 The @kbd{u M} (@code{calc-vector-mean}) [@code{vmean}] command
20470 computes the average (arithmetic mean) of the data values.
20471 If the inputs are error forms
20472 @texline @math{x \pm \sigma},
20473 @infoline @samp{x +/- s},
20474 this is the weighted mean of the @expr{x} values with weights
20475 @texline @math{1 /\sigma^2}.
20476 @infoline @expr{1 / s^2}.
20477 @tex
20478 \turnoffactive
20479 $$ \mu = { \displaystyle \sum { x_i \over \sigma_i^2 } \over
20480 \displaystyle \sum { 1 \over \sigma_i^2 } } $$
20481 @end tex
20482 If the inputs are not error forms, this is simply the sum of the
20483 values divided by the count of the values.
20484
20485 Note that a plain number can be considered an error form with
20486 error
20487 @texline @math{\sigma = 0}.
20488 @infoline @expr{s = 0}.
20489 If the input to @kbd{u M} is a mixture of
20490 plain numbers and error forms, the result is the mean of the
20491 plain numbers, ignoring all values with non-zero errors. (By the
20492 above definitions it's clear that a plain number effectively
20493 has an infinite weight, next to which an error form with a finite
20494 weight is completely negligible.)
20495
20496 This function also works for distributions (error forms or
20497 intervals). The mean of an error form `@var{a} @tfn{+/-} @var{b}' is simply
20498 @expr{a}. The mean of an interval is the mean of the minimum
20499 and maximum values of the interval.
20500
20501 @kindex I u M
20502 @pindex calc-vector-mean-error
20503 @tindex vmeane
20504 The @kbd{I u M} (@code{calc-vector-mean-error}) [@code{vmeane}]
20505 command computes the mean of the data points expressed as an
20506 error form. This includes the estimated error associated with
20507 the mean. If the inputs are error forms, the error is the square
20508 root of the reciprocal of the sum of the reciprocals of the squares
20509 of the input errors. (I.e., the variance is the reciprocal of the
20510 sum of the reciprocals of the variances.)
20511 @tex
20512 \turnoffactive
20513 $$ \sigma_\mu^2 = {1 \over \displaystyle \sum {1 \over \sigma_i^2}} $$
20514 @end tex
20515 If the inputs are plain
20516 numbers, the error is equal to the standard deviation of the values
20517 divided by the square root of the number of values. (This works
20518 out to be equivalent to calculating the standard deviation and
20519 then assuming each value's error is equal to this standard
20520 deviation.)
20521 @tex
20522 \turnoffactive
20523 $$ \sigma_\mu^2 = {\sigma^2 \over N} $$
20524 @end tex
20525
20526 @kindex H u M
20527 @pindex calc-vector-median
20528 @tindex vmedian
20529 @cindex Median of data values
20530 The @kbd{H u M} (@code{calc-vector-median}) [@code{vmedian}]
20531 command computes the median of the data values. The values are
20532 first sorted into numerical order; the median is the middle
20533 value after sorting. (If the number of data values is even,
20534 the median is taken to be the average of the two middle values.)
20535 The median function is different from the other functions in
20536 this section in that the arguments must all be real numbers;
20537 variables are not accepted even when nested inside vectors.
20538 (Otherwise it is not possible to sort the data values.) If
20539 any of the input values are error forms, their error parts are
20540 ignored.
20541
20542 The median function also accepts distributions. For both normal
20543 (error form) and uniform (interval) distributions, the median is
20544 the same as the mean.
20545
20546 @kindex H I u M
20547 @pindex calc-vector-harmonic-mean
20548 @tindex vhmean
20549 @cindex Harmonic mean
20550 The @kbd{H I u M} (@code{calc-vector-harmonic-mean}) [@code{vhmean}]
20551 command computes the harmonic mean of the data values. This is
20552 defined as the reciprocal of the arithmetic mean of the reciprocals
20553 of the values.
20554 @tex
20555 \turnoffactive
20556 $$ { N \over \displaystyle \sum {1 \over x_i} } $$
20557 @end tex
20558
20559 @kindex u G
20560 @pindex calc-vector-geometric-mean
20561 @tindex vgmean
20562 @cindex Geometric mean
20563 The @kbd{u G} (@code{calc-vector-geometric-mean}) [@code{vgmean}]
20564 command computes the geometric mean of the data values. This
20565 is the @var{n}th root of the product of the values. This is also
20566 equal to the @code{exp} of the arithmetic mean of the logarithms
20567 of the data values.
20568 @tex
20569 \turnoffactive
20570 $$ \exp \left ( \sum { \ln x_i } \right ) =
20571 \left ( \prod { x_i } \right)^{1 / N} $$
20572 @end tex
20573
20574 @kindex H u G
20575 @tindex agmean
20576 The @kbd{H u G} [@code{agmean}] command computes the ``arithmetic-geometric
20577 mean'' of two numbers taken from the stack. This is computed by
20578 replacing the two numbers with their arithmetic mean and geometric
20579 mean, then repeating until the two values converge.
20580 @tex
20581 \turnoffactive
20582 $$ a_{i+1} = { a_i + b_i \over 2 } , \qquad b_{i+1} = \sqrt{a_i b_i} $$
20583 @end tex
20584
20585 @cindex Root-mean-square
20586 Another commonly used mean, the RMS (root-mean-square), can be computed
20587 for a vector of numbers simply by using the @kbd{A} command.
20588
20589 @kindex u S
20590 @pindex calc-vector-sdev
20591 @tindex vsdev
20592 @cindex Standard deviation
20593 @cindex Sample statistics
20594 The @kbd{u S} (@code{calc-vector-sdev}) [@code{vsdev}] command
20595 computes the standard
20596 @texline deviation@tie{}@math{\sigma}
20597 @infoline deviation
20598 of the data values. If the values are error forms, the errors are used
20599 as weights just as for @kbd{u M}. This is the @emph{sample} standard
20600 deviation, whose value is the square root of the sum of the squares of
20601 the differences between the values and the mean of the @expr{N} values,
20602 divided by @expr{N-1}.
20603 @tex
20604 \turnoffactive
20605 $$ \sigma^2 = {1 \over N - 1} \sum (x_i - \mu)^2 $$
20606 @end tex
20607
20608 This function also applies to distributions. The standard deviation
20609 of a single error form is simply the error part. The standard deviation
20610 of a continuous interval happens to equal the difference between the
20611 limits, divided by
20612 @texline @math{\sqrt{12}}.
20613 @infoline @expr{sqrt(12)}.
20614 The standard deviation of an integer interval is the same as the
20615 standard deviation of a vector of those integers.
20616
20617 @kindex I u S
20618 @pindex calc-vector-pop-sdev
20619 @tindex vpsdev
20620 @cindex Population statistics
20621 The @kbd{I u S} (@code{calc-vector-pop-sdev}) [@code{vpsdev}]
20622 command computes the @emph{population} standard deviation.
20623 It is defined by the same formula as above but dividing
20624 by @expr{N} instead of by @expr{N-1}. The population standard
20625 deviation is used when the input represents the entire set of
20626 data values in the distribution; the sample standard deviation
20627 is used when the input represents a sample of the set of all
20628 data values, so that the mean computed from the input is itself
20629 only an estimate of the true mean.
20630 @tex
20631 \turnoffactive
20632 $$ \sigma^2 = {1 \over N} \sum (x_i - \mu)^2 $$
20633 @end tex
20634
20635 For error forms and continuous intervals, @code{vpsdev} works
20636 exactly like @code{vsdev}. For integer intervals, it computes the
20637 population standard deviation of the equivalent vector of integers.
20638
20639 @kindex H u S
20640 @kindex H I u S
20641 @pindex calc-vector-variance
20642 @pindex calc-vector-pop-variance
20643 @tindex vvar
20644 @tindex vpvar
20645 @cindex Variance of data values
20646 The @kbd{H u S} (@code{calc-vector-variance}) [@code{vvar}] and
20647 @kbd{H I u S} (@code{calc-vector-pop-variance}) [@code{vpvar}]
20648 commands compute the variance of the data values. The variance
20649 is the
20650 @texline square@tie{}@math{\sigma^2}
20651 @infoline square
20652 of the standard deviation, i.e., the sum of the
20653 squares of the deviations of the data values from the mean.
20654 (This definition also applies when the argument is a distribution.)
20655
20656 @ignore
20657 @starindex
20658 @end ignore
20659 @tindex vflat
20660 The @code{vflat} algebraic function returns a vector of its
20661 arguments, interpreted in the same way as the other functions
20662 in this section. For example, @samp{vflat(1, [2, [3, 4]], 5)}
20663 returns @samp{[1, 2, 3, 4, 5]}.
20664
20665 @node Paired-Sample Statistics, , Single-Variable Statistics, Statistical Operations
20666 @subsection Paired-Sample Statistics
20667
20668 @noindent
20669 The functions in this section take two arguments, which must be
20670 vectors of equal size. The vectors are each flattened in the same
20671 way as by the single-variable statistical functions. Given a numeric
20672 prefix argument of 1, these functions instead take one object from
20673 the stack, which must be an
20674 @texline @math{N\times2}
20675 @infoline Nx2
20676 matrix of data values. Once again, variable names can be used in place
20677 of actual vectors and matrices.
20678
20679 @kindex u C
20680 @pindex calc-vector-covariance
20681 @tindex vcov
20682 @cindex Covariance
20683 The @kbd{u C} (@code{calc-vector-covariance}) [@code{vcov}] command
20684 computes the sample covariance of two vectors. The covariance
20685 of vectors @var{x} and @var{y} is the sum of the products of the
20686 differences between the elements of @var{x} and the mean of @var{x}
20687 times the differences between the corresponding elements of @var{y}
20688 and the mean of @var{y}, all divided by @expr{N-1}. Note that
20689 the variance of a vector is just the covariance of the vector
20690 with itself. Once again, if the inputs are error forms the
20691 errors are used as weight factors. If both @var{x} and @var{y}
20692 are composed of error forms, the error for a given data point
20693 is taken as the square root of the sum of the squares of the two
20694 input errors.
20695 @tex
20696 \turnoffactive
20697 $$ \sigma_{x\!y}^2 = {1 \over N-1} \sum (x_i - \mu_x) (y_i - \mu_y) $$
20698 $$ \sigma_{x\!y}^2 =
20699 {\displaystyle {1 \over N-1}
20700 \sum {(x_i - \mu_x) (y_i - \mu_y) \over \sigma_i^2}
20701 \over \displaystyle {1 \over N} \sum {1 \over \sigma_i^2}}
20702 $$
20703 @end tex
20704
20705 @kindex I u C
20706 @pindex calc-vector-pop-covariance
20707 @tindex vpcov
20708 The @kbd{I u C} (@code{calc-vector-pop-covariance}) [@code{vpcov}]
20709 command computes the population covariance, which is the same as the
20710 sample covariance computed by @kbd{u C} except dividing by @expr{N}
20711 instead of @expr{N-1}.
20712
20713 @kindex H u C
20714 @pindex calc-vector-correlation
20715 @tindex vcorr
20716 @cindex Correlation coefficient
20717 @cindex Linear correlation
20718 The @kbd{H u C} (@code{calc-vector-correlation}) [@code{vcorr}]
20719 command computes the linear correlation coefficient of two vectors.
20720 This is defined by the covariance of the vectors divided by the
20721 product of their standard deviations. (There is no difference
20722 between sample or population statistics here.)
20723 @tex
20724 \turnoffactive
20725 $$ r_{x\!y} = { \sigma_{x\!y}^2 \over \sigma_x^2 \sigma_y^2 } $$
20726 @end tex
20727
20728 @node Reducing and Mapping, Vector and Matrix Formats, Statistical Operations, Matrix Functions
20729 @section Reducing and Mapping Vectors
20730
20731 @noindent
20732 The commands in this section allow for more general operations on the
20733 elements of vectors.
20734
20735 @kindex V A
20736 @pindex calc-apply
20737 @tindex apply
20738 The simplest of these operations is @kbd{V A} (@code{calc-apply})
20739 [@code{apply}], which applies a given operator to the elements of a vector.
20740 For example, applying the hypothetical function @code{f} to the vector
20741 @w{@samp{[1, 2, 3]}} would produce the function call @samp{f(1, 2, 3)}.
20742 Applying the @code{+} function to the vector @samp{[a, b]} gives
20743 @samp{a + b}. Applying @code{+} to the vector @samp{[a, b, c]} is an
20744 error, since the @code{+} function expects exactly two arguments.
20745
20746 While @kbd{V A} is useful in some cases, you will usually find that either
20747 @kbd{V R} or @kbd{V M}, described below, is closer to what you want.
20748
20749 @menu
20750 * Specifying Operators::
20751 * Mapping::
20752 * Reducing::
20753 * Nesting and Fixed Points::
20754 * Generalized Products::
20755 @end menu
20756
20757 @node Specifying Operators, Mapping, Reducing and Mapping, Reducing and Mapping
20758 @subsection Specifying Operators
20759
20760 @noindent
20761 Commands in this section (like @kbd{V A}) prompt you to press the key
20762 corresponding to the desired operator. Press @kbd{?} for a partial
20763 list of the available operators. Generally, an operator is any key or
20764 sequence of keys that would normally take one or more arguments from
20765 the stack and replace them with a result. For example, @kbd{V A H C}
20766 uses the hyperbolic cosine operator, @code{cosh}. (Since @code{cosh}
20767 expects one argument, @kbd{V A H C} requires a vector with a single
20768 element as its argument.)
20769
20770 You can press @kbd{x} at the operator prompt to select any algebraic
20771 function by name to use as the operator. This includes functions you
20772 have defined yourself using the @kbd{Z F} command. (@xref{Algebraic
20773 Definitions}.) If you give a name for which no function has been
20774 defined, the result is left in symbolic form, as in @samp{f(1, 2, 3)}.
20775 Calc will prompt for the number of arguments the function takes if it
20776 can't figure it out on its own (say, because you named a function that
20777 is currently undefined). It is also possible to type a digit key before
20778 the function name to specify the number of arguments, e.g.,
20779 @kbd{V M 3 x f @key{RET}} calls @code{f} with three arguments even if it
20780 looks like it ought to have only two. This technique may be necessary
20781 if the function allows a variable number of arguments. For example,
20782 the @kbd{v e} [@code{vexp}] function accepts two or three arguments;
20783 if you want to map with the three-argument version, you will have to
20784 type @kbd{V M 3 v e}.
20785
20786 It is also possible to apply any formula to a vector by treating that
20787 formula as a function. When prompted for the operator to use, press
20788 @kbd{'} (the apostrophe) and type your formula as an algebraic entry.
20789 You will then be prompted for the argument list, which defaults to a
20790 list of all variables that appear in the formula, sorted into alphabetic
20791 order. For example, suppose you enter the formula @w{@samp{x + 2y^x}}.
20792 The default argument list would be @samp{(x y)}, which means that if
20793 this function is applied to the arguments @samp{[3, 10]} the result will
20794 be @samp{3 + 2*10^3}. (If you plan to use a certain formula in this
20795 way often, you might consider defining it as a function with @kbd{Z F}.)
20796
20797 Another way to specify the arguments to the formula you enter is with
20798 @kbd{$}, @kbd{$$}, and so on. For example, @kbd{V A ' $$ + 2$^$$}
20799 has the same effect as the previous example. The argument list is
20800 automatically taken to be @samp{($$ $)}. (The order of the arguments
20801 may seem backwards, but it is analogous to the way normal algebraic
20802 entry interacts with the stack.)
20803
20804 If you press @kbd{$} at the operator prompt, the effect is similar to
20805 the apostrophe except that the relevant formula is taken from top-of-stack
20806 instead. The actual vector arguments of the @kbd{V A $} or related command
20807 then start at the second-to-top stack position. You will still be
20808 prompted for an argument list.
20809
20810 @cindex Nameless functions
20811 @cindex Generic functions
20812 A function can be written without a name using the notation @samp{<#1 - #2>},
20813 which means ``a function of two arguments that computes the first
20814 argument minus the second argument.'' The symbols @samp{#1} and @samp{#2}
20815 are placeholders for the arguments. You can use any names for these
20816 placeholders if you wish, by including an argument list followed by a
20817 colon: @samp{<x, y : x - y>}. When you type @kbd{V A ' $$ + 2$^$$ @key{RET}},
20818 Calc builds the nameless function @samp{<#1 + 2 #2^#1>} as the function
20819 to map across the vectors. When you type @kbd{V A ' x + 2y^x @key{RET} @key{RET}},
20820 Calc builds the nameless function @w{@samp{<x, y : x + 2 y^x>}}. In both
20821 cases, Calc also writes the nameless function to the Trail so that you
20822 can get it back later if you wish.
20823
20824 If there is only one argument, you can write @samp{#} in place of @samp{#1}.
20825 (Note that @samp{< >} notation is also used for date forms. Calc tells
20826 that @samp{<@var{stuff}>} is a nameless function by the presence of
20827 @samp{#} signs inside @var{stuff}, or by the fact that @var{stuff}
20828 begins with a list of variables followed by a colon.)
20829
20830 You can type a nameless function directly to @kbd{V A '}, or put one on
20831 the stack and use it with @w{@kbd{V A $}}. Calc will not prompt for an
20832 argument list in this case, since the nameless function specifies the
20833 argument list as well as the function itself. In @kbd{V A '}, you can
20834 omit the @samp{< >} marks if you use @samp{#} notation for the arguments,
20835 so that @kbd{V A ' #1+#2 @key{RET}} is the same as @kbd{V A ' <#1+#2> @key{RET}},
20836 which in turn is the same as @kbd{V A ' $$+$ @key{RET}}.
20837
20838 @cindex Lambda expressions
20839 @ignore
20840 @starindex
20841 @end ignore
20842 @tindex lambda
20843 The internal format for @samp{<x, y : x + y>} is @samp{lambda(x, y, x + y)}.
20844 (The word @code{lambda} derives from Lisp notation and the theory of
20845 functions.) The internal format for @samp{<#1 + #2>} is @samp{lambda(ArgA,
20846 ArgB, ArgA + ArgB)}. Note that there is no actual Calc function called
20847 @code{lambda}; the whole point is that the @code{lambda} expression is
20848 used in its symbolic form, not evaluated for an answer until it is applied
20849 to specific arguments by a command like @kbd{V A} or @kbd{V M}.
20850
20851 (Actually, @code{lambda} does have one special property: Its arguments
20852 are never evaluated; for example, putting @samp{<(2/3) #>} on the stack
20853 will not simplify the @samp{2/3} until the nameless function is actually
20854 called.)
20855
20856 @tindex add
20857 @tindex sub
20858 @ignore
20859 @mindex @idots
20860 @end ignore
20861 @tindex mul
20862 @ignore
20863 @mindex @null
20864 @end ignore
20865 @tindex div
20866 @ignore
20867 @mindex @null
20868 @end ignore
20869 @tindex pow
20870 @ignore
20871 @mindex @null
20872 @end ignore
20873 @tindex neg
20874 @ignore
20875 @mindex @null
20876 @end ignore
20877 @tindex mod
20878 @ignore
20879 @mindex @null
20880 @end ignore
20881 @tindex vconcat
20882 As usual, commands like @kbd{V A} have algebraic function name equivalents.
20883 For example, @kbd{V A k g} with an argument of @samp{v} is equivalent to
20884 @samp{apply(gcd, v)}. The first argument specifies the operator name,
20885 and is either a variable whose name is the same as the function name,
20886 or a nameless function like @samp{<#^3+1>}. Operators that are normally
20887 written as algebraic symbols have the names @code{add}, @code{sub},
20888 @code{mul}, @code{div}, @code{pow}, @code{neg}, @code{mod}, and
20889 @code{vconcat}.
20890
20891 @ignore
20892 @starindex
20893 @end ignore
20894 @tindex call
20895 The @code{call} function builds a function call out of several arguments:
20896 @samp{call(gcd, x, y)} is the same as @samp{apply(gcd, [x, y])}, which
20897 in turn is the same as @samp{gcd(x, y)}. The first argument of @code{call},
20898 like the other functions described here, may be either a variable naming a
20899 function, or a nameless function (@samp{call(<#1+2#2>, x, y)} is the same
20900 as @samp{x + 2y}).
20901
20902 (Experts will notice that it's not quite proper to use a variable to name
20903 a function, since the name @code{gcd} corresponds to the Lisp variable
20904 @code{var-gcd} but to the Lisp function @code{calcFunc-gcd}. Calc
20905 automatically makes this translation, so you don't have to worry
20906 about it.)
20907
20908 @node Mapping, Reducing, Specifying Operators, Reducing and Mapping
20909 @subsection Mapping
20910
20911 @noindent
20912 @kindex V M
20913 @pindex calc-map
20914 @tindex map
20915 The @kbd{V M} (@code{calc-map}) [@code{map}] command applies a given
20916 operator elementwise to one or more vectors. For example, mapping
20917 @code{A} [@code{abs}] produces a vector of the absolute values of the
20918 elements in the input vector. Mapping @code{+} pops two vectors from
20919 the stack, which must be of equal length, and produces a vector of the
20920 pairwise sums of the elements. If either argument is a non-vector, it
20921 is duplicated for each element of the other vector. For example,
20922 @kbd{[1,2,3] 2 V M ^} squares the elements of the specified vector.
20923 With the 2 listed first, it would have computed a vector of powers of
20924 two. Mapping a user-defined function pops as many arguments from the
20925 stack as the function requires. If you give an undefined name, you will
20926 be prompted for the number of arguments to use.
20927
20928 If any argument to @kbd{V M} is a matrix, the operator is normally mapped
20929 across all elements of the matrix. For example, given the matrix
20930 @expr{[[1, -2, 3], [-4, 5, -6]]}, @kbd{V M A} takes six absolute values to
20931 produce another
20932 @texline @math{3\times2}
20933 @infoline 3x2
20934 matrix, @expr{[[1, 2, 3], [4, 5, 6]]}.
20935
20936 @tindex mapr
20937 The command @kbd{V M _} [@code{mapr}] (i.e., type an underscore at the
20938 operator prompt) maps by rows instead. For example, @kbd{V M _ A} views
20939 the above matrix as a vector of two 3-element row vectors. It produces
20940 a new vector which contains the absolute values of those row vectors,
20941 namely @expr{[3.74, 8.77]}. (Recall, the absolute value of a vector is
20942 defined as the square root of the sum of the squares of the elements.)
20943 Some operators accept vectors and return new vectors; for example,
20944 @kbd{v v} reverses a vector, so @kbd{V M _ v v} would reverse each row
20945 of the matrix to get a new matrix, @expr{[[3, -2, 1], [-6, 5, -4]]}.
20946
20947 Sometimes a vector of vectors (representing, say, strings, sets, or lists)
20948 happens to look like a matrix. If so, remember to use @kbd{V M _} if you
20949 want to map a function across the whole strings or sets rather than across
20950 their individual elements.
20951
20952 @tindex mapc
20953 The command @kbd{V M :} [@code{mapc}] maps by columns. Basically, it
20954 transposes the input matrix, maps by rows, and then, if the result is a
20955 matrix, transposes again. For example, @kbd{V M : A} takes the absolute
20956 values of the three columns of the matrix, treating each as a 2-vector,
20957 and @kbd{V M : v v} reverses the columns to get the matrix
20958 @expr{[[-4, 5, -6], [1, -2, 3]]}.
20959
20960 (The symbols @kbd{_} and @kbd{:} were chosen because they had row-like
20961 and column-like appearances, and were not already taken by useful
20962 operators. Also, they appear shifted on most keyboards so they are easy
20963 to type after @kbd{V M}.)
20964
20965 The @kbd{_} and @kbd{:} modifiers have no effect on arguments that are
20966 not matrices (so if none of the arguments are matrices, they have no
20967 effect at all). If some of the arguments are matrices and others are
20968 plain numbers, the plain numbers are held constant for all rows of the
20969 matrix (so that @kbd{2 V M _ ^} squares every row of a matrix; squaring
20970 a vector takes a dot product of the vector with itself).
20971
20972 If some of the arguments are vectors with the same lengths as the
20973 rows (for @kbd{V M _}) or columns (for @kbd{V M :}) of the matrix
20974 arguments, those vectors are also held constant for every row or
20975 column.
20976
20977 Sometimes it is useful to specify another mapping command as the operator
20978 to use with @kbd{V M}. For example, @kbd{V M _ V A +} applies @kbd{V A +}
20979 to each row of the input matrix, which in turn adds the two values on that
20980 row. If you give another vector-operator command as the operator for
20981 @kbd{V M}, it automatically uses map-by-rows mode if you don't specify
20982 otherwise; thus @kbd{V M V A +} is equivalent to @kbd{V M _ V A +}. (If
20983 you really want to map-by-elements another mapping command, you can use
20984 a triple-nested mapping command: @kbd{V M V M V A +} means to map
20985 @kbd{V M V A +} over the rows of the matrix; in turn, @kbd{V A +} is
20986 mapped over the elements of each row.)
20987
20988 @tindex mapa
20989 @tindex mapd
20990 Previous versions of Calc had ``map across'' and ``map down'' modes
20991 that are now considered obsolete; the old ``map across'' is now simply
20992 @kbd{V M V A}, and ``map down'' is now @kbd{V M : V A}. The algebraic
20993 functions @code{mapa} and @code{mapd} are still supported, though.
20994 Note also that, while the old mapping modes were persistent (once you
20995 set the mode, it would apply to later mapping commands until you reset
20996 it), the new @kbd{:} and @kbd{_} modifiers apply only to the current
20997 mapping command. The default @kbd{V M} always means map-by-elements.
20998
20999 @xref{Algebraic Manipulation}, for the @kbd{a M} command, which is like
21000 @kbd{V M} but for equations and inequalities instead of vectors.
21001 @xref{Storing Variables}, for the @kbd{s m} command which modifies a
21002 variable's stored value using a @kbd{V M}-like operator.
21003
21004 @node Reducing, Nesting and Fixed Points, Mapping, Reducing and Mapping
21005 @subsection Reducing
21006
21007 @noindent
21008 @kindex V R
21009 @pindex calc-reduce
21010 @tindex reduce
21011 The @kbd{V R} (@code{calc-reduce}) [@code{reduce}] command applies a given
21012 binary operator across all the elements of a vector. A binary operator is
21013 a function such as @code{+} or @code{max} which takes two arguments. For
21014 example, reducing @code{+} over a vector computes the sum of the elements
21015 of the vector. Reducing @code{-} computes the first element minus each of
21016 the remaining elements. Reducing @code{max} computes the maximum element
21017 and so on. In general, reducing @code{f} over the vector @samp{[a, b, c, d]}
21018 produces @samp{f(f(f(a, b), c), d)}.
21019
21020 @kindex I V R
21021 @tindex rreduce
21022 The @kbd{I V R} [@code{rreduce}] command is similar to @kbd{V R} except
21023 that works from right to left through the vector. For example, plain
21024 @kbd{V R -} on the vector @samp{[a, b, c, d]} produces @samp{a - b - c - d}
21025 but @kbd{I V R -} on the same vector produces @samp{a - (b - (c - d))},
21026 or @samp{a - b + c - d}. This ``alternating sum'' occurs frequently
21027 in power series expansions.
21028
21029 @kindex V U
21030 @tindex accum
21031 The @kbd{V U} (@code{calc-accumulate}) [@code{accum}] command does an
21032 accumulation operation. Here Calc does the corresponding reduction
21033 operation, but instead of producing only the final result, it produces
21034 a vector of all the intermediate results. Accumulating @code{+} over
21035 the vector @samp{[a, b, c, d]} produces the vector
21036 @samp{[a, a + b, a + b + c, a + b + c + d]}.
21037
21038 @kindex I V U
21039 @tindex raccum
21040 The @kbd{I V U} [@code{raccum}] command does a right-to-left accumulation.
21041 For example, @kbd{I V U -} on the vector @samp{[a, b, c, d]} produces the
21042 vector @samp{[a - b + c - d, b - c + d, c - d, d]}.
21043
21044 @tindex reducea
21045 @tindex rreducea
21046 @tindex reduced
21047 @tindex rreduced
21048 As for @kbd{V M}, @kbd{V R} normally reduces a matrix elementwise. For
21049 example, given the matrix @expr{[[a, b, c], [d, e, f]]}, @kbd{V R +} will
21050 compute @expr{a + b + c + d + e + f}. You can type @kbd{V R _} or
21051 @kbd{V R :} to modify this behavior. The @kbd{V R _} [@code{reducea}]
21052 command reduces ``across'' the matrix; it reduces each row of the matrix
21053 as a vector, then collects the results. Thus @kbd{V R _ +} of this
21054 matrix would produce @expr{[a + b + c, d + e + f]}. Similarly, @kbd{V R :}
21055 [@code{reduced}] reduces down; @kbd{V R : +} would produce @expr{[a + d,
21056 b + e, c + f]}.
21057
21058 @tindex reducer
21059 @tindex rreducer
21060 There is a third ``by rows'' mode for reduction that is occasionally
21061 useful; @kbd{V R =} [@code{reducer}] simply reduces the operator over
21062 the rows of the matrix themselves. Thus @kbd{V R = +} on the above
21063 matrix would get the same result as @kbd{V R : +}, since adding two
21064 row vectors is equivalent to adding their elements. But @kbd{V R = *}
21065 would multiply the two rows (to get a single number, their dot product),
21066 while @kbd{V R : *} would produce a vector of the products of the columns.
21067
21068 These three matrix reduction modes work with @kbd{V R} and @kbd{I V R},
21069 but they are not currently supported with @kbd{V U} or @kbd{I V U}.
21070
21071 @tindex reducec
21072 @tindex rreducec
21073 The obsolete reduce-by-columns function, @code{reducec}, is still
21074 supported but there is no way to get it through the @kbd{V R} command.
21075
21076 The commands @kbd{M-# :} and @kbd{M-# _} are equivalent to typing
21077 @kbd{M-# r} to grab a rectangle of data into Calc, and then typing
21078 @kbd{V R : +} or @kbd{V R _ +}, respectively, to sum the columns or
21079 rows of the matrix. @xref{Grabbing From Buffers}.
21080
21081 @node Nesting and Fixed Points, Generalized Products, Reducing, Reducing and Mapping
21082 @subsection Nesting and Fixed Points
21083
21084 @noindent
21085 @kindex H V R
21086 @tindex nest
21087 The @kbd{H V R} [@code{nest}] command applies a function to a given
21088 argument repeatedly. It takes two values, @samp{a} and @samp{n}, from
21089 the stack, where @samp{n} must be an integer. It then applies the
21090 function nested @samp{n} times; if the function is @samp{f} and @samp{n}
21091 is 3, the result is @samp{f(f(f(a)))}. The number @samp{n} may be
21092 negative if Calc knows an inverse for the function @samp{f}; for
21093 example, @samp{nest(sin, a, -2)} returns @samp{arcsin(arcsin(a))}.
21094
21095 @kindex H V U
21096 @tindex anest
21097 The @kbd{H V U} [@code{anest}] command is an accumulating version of
21098 @code{nest}: It returns a vector of @samp{n+1} values, e.g.,
21099 @samp{[a, f(a), f(f(a)), f(f(f(a)))]}. If @samp{n} is negative and
21100 @samp{F} is the inverse of @samp{f}, then the result is of the
21101 form @samp{[a, F(a), F(F(a)), F(F(F(a)))]}.
21102
21103 @kindex H I V R
21104 @tindex fixp
21105 @cindex Fixed points
21106 The @kbd{H I V R} [@code{fixp}] command is like @kbd{H V R}, except
21107 that it takes only an @samp{a} value from the stack; the function is
21108 applied until it reaches a ``fixed point,'' i.e., until the result
21109 no longer changes.
21110
21111 @kindex H I V U
21112 @tindex afixp
21113 The @kbd{H I V U} [@code{afixp}] command is an accumulating @code{fixp}.
21114 The first element of the return vector will be the initial value @samp{a};
21115 the last element will be the final result that would have been returned
21116 by @code{fixp}.
21117
21118 For example, 0.739085 is a fixed point of the cosine function (in radians):
21119 @samp{cos(0.739085) = 0.739085}. You can find this value by putting, say,
21120 1.0 on the stack and typing @kbd{H I V U C}. (We use the accumulating
21121 version so we can see the intermediate results: @samp{[1, 0.540302, 0.857553,
21122 0.65329, ...]}. With a precision of six, this command will take 36 steps
21123 to converge to 0.739085.)
21124
21125 Newton's method for finding roots is a classic example of iteration
21126 to a fixed point. To find the square root of five starting with an
21127 initial guess, Newton's method would look for a fixed point of the
21128 function @samp{(x + 5/x) / 2}. Putting a guess of 1 on the stack
21129 and typing @kbd{H I V R ' ($ + 5/$)/2 @key{RET}} quickly yields the result
21130 2.23607. This is equivalent to using the @kbd{a R} (@code{calc-find-root})
21131 command to find a root of the equation @samp{x^2 = 5}.
21132
21133 These examples used numbers for @samp{a} values. Calc keeps applying
21134 the function until two successive results are equal to within the
21135 current precision. For complex numbers, both the real parts and the
21136 imaginary parts must be equal to within the current precision. If
21137 @samp{a} is a formula (say, a variable name), then the function is
21138 applied until two successive results are exactly the same formula.
21139 It is up to you to ensure that the function will eventually converge;
21140 if it doesn't, you may have to press @kbd{C-g} to stop the Calculator.
21141
21142 The algebraic @code{fixp} function takes two optional arguments, @samp{n}
21143 and @samp{tol}. The first is the maximum number of steps to be allowed,
21144 and must be either an integer or the symbol @samp{inf} (infinity, the
21145 default). The second is a convergence tolerance. If a tolerance is
21146 specified, all results during the calculation must be numbers, not
21147 formulas, and the iteration stops when the magnitude of the difference
21148 between two successive results is less than or equal to the tolerance.
21149 (This implies that a tolerance of zero iterates until the results are
21150 exactly equal.)
21151
21152 Putting it all together, @samp{fixp(<(# + A/#)/2>, B, 20, 1e-10)}
21153 computes the square root of @samp{A} given the initial guess @samp{B},
21154 stopping when the result is correct within the specified tolerance, or
21155 when 20 steps have been taken, whichever is sooner.
21156
21157 @node Generalized Products, , Nesting and Fixed Points, Reducing and Mapping
21158 @subsection Generalized Products
21159
21160 @kindex V O
21161 @pindex calc-outer-product
21162 @tindex outer
21163 The @kbd{V O} (@code{calc-outer-product}) [@code{outer}] command applies
21164 a given binary operator to all possible pairs of elements from two
21165 vectors, to produce a matrix. For example, @kbd{V O *} with @samp{[a, b]}
21166 and @samp{[x, y, z]} on the stack produces a multiplication table:
21167 @samp{[[a x, a y, a z], [b x, b y, b z]]}. Element @var{r},@var{c} of
21168 the result matrix is obtained by applying the operator to element @var{r}
21169 of the lefthand vector and element @var{c} of the righthand vector.
21170
21171 @kindex V I
21172 @pindex calc-inner-product
21173 @tindex inner
21174 The @kbd{V I} (@code{calc-inner-product}) [@code{inner}] command computes
21175 the generalized inner product of two vectors or matrices, given a
21176 ``multiplicative'' operator and an ``additive'' operator. These can each
21177 actually be any binary operators; if they are @samp{*} and @samp{+},
21178 respectively, the result is a standard matrix multiplication. Element
21179 @var{r},@var{c} of the result matrix is obtained by mapping the
21180 multiplicative operator across row @var{r} of the lefthand matrix and
21181 column @var{c} of the righthand matrix, and then reducing with the additive
21182 operator. Just as for the standard @kbd{*} command, this can also do a
21183 vector-matrix or matrix-vector inner product, or a vector-vector
21184 generalized dot product.
21185
21186 Since @kbd{V I} requires two operators, it prompts twice. In each case,
21187 you can use any of the usual methods for entering the operator. If you
21188 use @kbd{$} twice to take both operator formulas from the stack, the
21189 first (multiplicative) operator is taken from the top of the stack
21190 and the second (additive) operator is taken from second-to-top.
21191
21192 @node Vector and Matrix Formats, , Reducing and Mapping, Matrix Functions
21193 @section Vector and Matrix Display Formats
21194
21195 @noindent
21196 Commands for controlling vector and matrix display use the @kbd{v} prefix
21197 instead of the usual @kbd{d} prefix. But they are display modes; in
21198 particular, they are influenced by the @kbd{I} and @kbd{H} prefix keys
21199 in the same way (@pxref{Display Modes}). Matrix display is also
21200 influenced by the @kbd{d O} (@code{calc-flat-language}) mode;
21201 @pxref{Normal Language Modes}.
21202
21203 @kindex V <
21204 @pindex calc-matrix-left-justify
21205 @kindex V =
21206 @pindex calc-matrix-center-justify
21207 @kindex V >
21208 @pindex calc-matrix-right-justify
21209 The commands @kbd{v <} (@code{calc-matrix-left-justify}), @kbd{v >}
21210 (@code{calc-matrix-right-justify}), and @w{@kbd{v =}}
21211 (@code{calc-matrix-center-justify}) control whether matrix elements
21212 are justified to the left, right, or center of their columns.
21213
21214 @kindex V [
21215 @pindex calc-vector-brackets
21216 @kindex V @{
21217 @pindex calc-vector-braces
21218 @kindex V (
21219 @pindex calc-vector-parens
21220 The @kbd{v [} (@code{calc-vector-brackets}) command turns the square
21221 brackets that surround vectors and matrices displayed in the stack on
21222 and off. The @kbd{v @{} (@code{calc-vector-braces}) and @kbd{v (}
21223 (@code{calc-vector-parens}) commands use curly braces or parentheses,
21224 respectively, instead of square brackets. For example, @kbd{v @{} might
21225 be used in preparation for yanking a matrix into a buffer running
21226 Mathematica. (In fact, the Mathematica language mode uses this mode;
21227 @pxref{Mathematica Language Mode}.) Note that, regardless of the
21228 display mode, either brackets or braces may be used to enter vectors,
21229 and parentheses may never be used for this purpose.
21230
21231 @kindex V ]
21232 @pindex calc-matrix-brackets
21233 The @kbd{v ]} (@code{calc-matrix-brackets}) command controls the
21234 ``big'' style display of matrices. It prompts for a string of code
21235 letters; currently implemented letters are @code{R}, which enables
21236 brackets on each row of the matrix; @code{O}, which enables outer
21237 brackets in opposite corners of the matrix; and @code{C}, which
21238 enables commas or semicolons at the ends of all rows but the last.
21239 The default format is @samp{RO}. (Before Calc 2.00, the format
21240 was fixed at @samp{ROC}.) Here are some example matrices:
21241
21242 @example
21243 @group
21244 [ [ 123, 0, 0 ] [ [ 123, 0, 0 ],
21245 [ 0, 123, 0 ] [ 0, 123, 0 ],
21246 [ 0, 0, 123 ] ] [ 0, 0, 123 ] ]
21247
21248 RO ROC
21249
21250 @end group
21251 @end example
21252 @noindent
21253 @example
21254 @group
21255 [ 123, 0, 0 [ 123, 0, 0 ;
21256 0, 123, 0 0, 123, 0 ;
21257 0, 0, 123 ] 0, 0, 123 ]
21258
21259 O OC
21260
21261 @end group
21262 @end example
21263 @noindent
21264 @example
21265 @group
21266 [ 123, 0, 0 ] 123, 0, 0
21267 [ 0, 123, 0 ] 0, 123, 0
21268 [ 0, 0, 123 ] 0, 0, 123
21269
21270 R @r{blank}
21271 @end group
21272 @end example
21273
21274 @noindent
21275 Note that of the formats shown here, @samp{RO}, @samp{ROC}, and
21276 @samp{OC} are all recognized as matrices during reading, while
21277 the others are useful for display only.
21278
21279 @kindex V ,
21280 @pindex calc-vector-commas
21281 The @kbd{v ,} (@code{calc-vector-commas}) command turns commas on and
21282 off in vector and matrix display.
21283
21284 In vectors of length one, and in all vectors when commas have been
21285 turned off, Calc adds extra parentheses around formulas that might
21286 otherwise be ambiguous. For example, @samp{[a b]} could be a vector
21287 of the one formula @samp{a b}, or it could be a vector of two
21288 variables with commas turned off. Calc will display the former
21289 case as @samp{[(a b)]}. You can disable these extra parentheses
21290 (to make the output less cluttered at the expense of allowing some
21291 ambiguity) by adding the letter @code{P} to the control string you
21292 give to @kbd{v ]} (as described above).
21293
21294 @kindex V .
21295 @pindex calc-full-vectors
21296 The @kbd{v .} (@code{calc-full-vectors}) command turns abbreviated
21297 display of long vectors on and off. In this mode, vectors of six
21298 or more elements, or matrices of six or more rows or columns, will
21299 be displayed in an abbreviated form that displays only the first
21300 three elements and the last element: @samp{[a, b, c, ..., z]}.
21301 When very large vectors are involved this will substantially
21302 improve Calc's display speed.
21303
21304 @kindex t .
21305 @pindex calc-full-trail-vectors
21306 The @kbd{t .} (@code{calc-full-trail-vectors}) command controls a
21307 similar mode for recording vectors in the Trail. If you turn on
21308 this mode, vectors of six or more elements and matrices of six or
21309 more rows or columns will be abbreviated when they are put in the
21310 Trail. The @kbd{t y} (@code{calc-trail-yank}) command will be
21311 unable to recover those vectors. If you are working with very
21312 large vectors, this mode will improve the speed of all operations
21313 that involve the trail.
21314
21315 @kindex V /
21316 @pindex calc-break-vectors
21317 The @kbd{v /} (@code{calc-break-vectors}) command turns multi-line
21318 vector display on and off. Normally, matrices are displayed with one
21319 row per line but all other types of vectors are displayed in a single
21320 line. This mode causes all vectors, whether matrices or not, to be
21321 displayed with a single element per line. Sub-vectors within the
21322 vectors will still use the normal linear form.
21323
21324 @node Algebra, Units, Matrix Functions, Top
21325 @chapter Algebra
21326
21327 @noindent
21328 This section covers the Calc features that help you work with
21329 algebraic formulas. First, the general sub-formula selection
21330 mechanism is described; this works in conjunction with any Calc
21331 commands. Then, commands for specific algebraic operations are
21332 described. Finally, the flexible @dfn{rewrite rule} mechanism
21333 is discussed.
21334
21335 The algebraic commands use the @kbd{a} key prefix; selection
21336 commands use the @kbd{j} (for ``just a letter that wasn't used
21337 for anything else'') prefix.
21338
21339 @xref{Editing Stack Entries}, to see how to manipulate formulas
21340 using regular Emacs editing commands.
21341
21342 When doing algebraic work, you may find several of the Calculator's
21343 modes to be helpful, including Algebraic Simplification mode (@kbd{m A})
21344 or No-Simplification mode (@kbd{m O}),
21345 Algebraic entry mode (@kbd{m a}), Fraction mode (@kbd{m f}), and
21346 Symbolic mode (@kbd{m s}). @xref{Mode Settings}, for discussions
21347 of these modes. You may also wish to select Big display mode (@kbd{d B}).
21348 @xref{Normal Language Modes}.
21349
21350 @menu
21351 * Selecting Subformulas::
21352 * Algebraic Manipulation::
21353 * Simplifying Formulas::
21354 * Polynomials::
21355 * Calculus::
21356 * Solving Equations::
21357 * Numerical Solutions::
21358 * Curve Fitting::
21359 * Summations::
21360 * Logical Operations::
21361 * Rewrite Rules::
21362 @end menu
21363
21364 @node Selecting Subformulas, Algebraic Manipulation, Algebra, Algebra
21365 @section Selecting Sub-Formulas
21366
21367 @noindent
21368 @cindex Selections
21369 @cindex Sub-formulas
21370 @cindex Parts of formulas
21371 When working with an algebraic formula it is often necessary to
21372 manipulate a portion of the formula rather than the formula as a
21373 whole. Calc allows you to ``select'' a portion of any formula on
21374 the stack. Commands which would normally operate on that stack
21375 entry will now operate only on the sub-formula, leaving the
21376 surrounding part of the stack entry alone.
21377
21378 One common non-algebraic use for selection involves vectors. To work
21379 on one element of a vector in-place, simply select that element as a
21380 ``sub-formula'' of the vector.
21381
21382 @menu
21383 * Making Selections::
21384 * Changing Selections::
21385 * Displaying Selections::
21386 * Operating on Selections::
21387 * Rearranging with Selections::
21388 @end menu
21389
21390 @node Making Selections, Changing Selections, Selecting Subformulas, Selecting Subformulas
21391 @subsection Making Selections
21392
21393 @noindent
21394 @kindex j s
21395 @pindex calc-select-here
21396 To select a sub-formula, move the Emacs cursor to any character in that
21397 sub-formula, and press @w{@kbd{j s}} (@code{calc-select-here}). Calc will
21398 highlight the smallest portion of the formula that contains that
21399 character. By default the sub-formula is highlighted by blanking out
21400 all of the rest of the formula with dots. Selection works in any
21401 display mode but is perhaps easiest in Big mode (@kbd{d B}).
21402 Suppose you enter the following formula:
21403
21404 @smallexample
21405 @group
21406 3 ___
21407 (a + b) + V c
21408 1: ---------------
21409 2 x + 1
21410 @end group
21411 @end smallexample
21412
21413 @noindent
21414 (by typing @kbd{' ((a+b)^3 + sqrt(c)) / (2x+1)}). If you move the
21415 cursor to the letter @samp{b} and press @w{@kbd{j s}}, the display changes
21416 to
21417
21418 @smallexample
21419 @group
21420 . ...
21421 .. . b. . . .
21422 1* ...............
21423 . . . .
21424 @end group
21425 @end smallexample
21426
21427 @noindent
21428 Every character not part of the sub-formula @samp{b} has been changed
21429 to a dot. The @samp{*} next to the line number is to remind you that
21430 the formula has a portion of it selected. (In this case, it's very
21431 obvious, but it might not always be. If Embedded mode is enabled,
21432 the word @samp{Sel} also appears in the mode line because the stack
21433 may not be visible. @pxref{Embedded Mode}.)
21434
21435 If you had instead placed the cursor on the parenthesis immediately to
21436 the right of the @samp{b}, the selection would have been:
21437
21438 @smallexample
21439 @group
21440 . ...
21441 (a + b) . . .
21442 1* ...............
21443 . . . .
21444 @end group
21445 @end smallexample
21446
21447 @noindent
21448 The portion selected is always large enough to be considered a complete
21449 formula all by itself, so selecting the parenthesis selects the whole
21450 formula that it encloses. Putting the cursor on the @samp{+} sign
21451 would have had the same effect.
21452
21453 (Strictly speaking, the Emacs cursor is really the manifestation of
21454 the Emacs ``point,'' which is a position @emph{between} two characters
21455 in the buffer. So purists would say that Calc selects the smallest
21456 sub-formula which contains the character to the right of ``point.'')
21457
21458 If you supply a numeric prefix argument @var{n}, the selection is
21459 expanded to the @var{n}th enclosing sub-formula. Thus, positioning
21460 the cursor on the @samp{b} and typing @kbd{C-u 1 j s} will select
21461 @samp{a + b}; typing @kbd{C-u 2 j s} will select @samp{(a + b)^3},
21462 and so on.
21463
21464 If the cursor is not on any part of the formula, or if you give a
21465 numeric prefix that is too large, the entire formula is selected.
21466
21467 If the cursor is on the @samp{.} line that marks the top of the stack
21468 (i.e., its normal ``rest position''), this command selects the entire
21469 formula at stack level 1. Most selection commands similarly operate
21470 on the formula at the top of the stack if you haven't positioned the
21471 cursor on any stack entry.
21472
21473 @kindex j a
21474 @pindex calc-select-additional
21475 The @kbd{j a} (@code{calc-select-additional}) command enlarges the
21476 current selection to encompass the cursor. To select the smallest
21477 sub-formula defined by two different points, move to the first and
21478 press @kbd{j s}, then move to the other and press @kbd{j a}. This
21479 is roughly analogous to using @kbd{C-@@} (@code{set-mark-command}) to
21480 select the two ends of a region of text during normal Emacs editing.
21481
21482 @kindex j o
21483 @pindex calc-select-once
21484 The @kbd{j o} (@code{calc-select-once}) command selects a formula in
21485 exactly the same way as @kbd{j s}, except that the selection will
21486 last only as long as the next command that uses it. For example,
21487 @kbd{j o 1 +} is a handy way to add one to the sub-formula indicated
21488 by the cursor.
21489
21490 (A somewhat more precise definition: The @kbd{j o} command sets a flag
21491 such that the next command involving selected stack entries will clear
21492 the selections on those stack entries afterwards. All other selection
21493 commands except @kbd{j a} and @kbd{j O} clear this flag.)
21494
21495 @kindex j S
21496 @kindex j O
21497 @pindex calc-select-here-maybe
21498 @pindex calc-select-once-maybe
21499 The @kbd{j S} (@code{calc-select-here-maybe}) and @kbd{j O}
21500 (@code{calc-select-once-maybe}) commands are equivalent to @kbd{j s}
21501 and @kbd{j o}, respectively, except that if the formula already
21502 has a selection they have no effect. This is analogous to the
21503 behavior of some commands such as @kbd{j r} (@code{calc-rewrite-selection};
21504 @pxref{Selections with Rewrite Rules}) and is mainly intended to be
21505 used in keyboard macros that implement your own selection-oriented
21506 commands.
21507
21508 Selection of sub-formulas normally treats associative terms like
21509 @samp{a + b - c + d} and @samp{x * y * z} as single levels of the formula.
21510 If you place the cursor anywhere inside @samp{a + b - c + d} except
21511 on one of the variable names and use @kbd{j s}, you will select the
21512 entire four-term sum.
21513
21514 @kindex j b
21515 @pindex calc-break-selections
21516 The @kbd{j b} (@code{calc-break-selections}) command controls a mode
21517 in which the ``deep structure'' of these associative formulas shows
21518 through. Calc actually stores the above formulas as @samp{((a + b) - c) + d}
21519 and @samp{x * (y * z)}. (Note that for certain obscure reasons, Calc
21520 treats multiplication as right-associative.) Once you have enabled
21521 @kbd{j b} mode, selecting with the cursor on the @samp{-} sign would
21522 only select the @samp{a + b - c} portion, which makes sense when the
21523 deep structure of the sum is considered. There is no way to select
21524 the @samp{b - c + d} portion; although this might initially look
21525 like just as legitimate a sub-formula as @samp{a + b - c}, the deep
21526 structure shows that it isn't. The @kbd{d U} command can be used
21527 to view the deep structure of any formula (@pxref{Normal Language Modes}).
21528
21529 When @kbd{j b} mode has not been enabled, the deep structure is
21530 generally hidden by the selection commands---what you see is what
21531 you get.
21532
21533 @kindex j u
21534 @pindex calc-unselect
21535 The @kbd{j u} (@code{calc-unselect}) command unselects the formula
21536 that the cursor is on. If there was no selection in the formula,
21537 this command has no effect. With a numeric prefix argument, it
21538 unselects the @var{n}th stack element rather than using the cursor
21539 position.
21540
21541 @kindex j c
21542 @pindex calc-clear-selections
21543 The @kbd{j c} (@code{calc-clear-selections}) command unselects all
21544 stack elements.
21545
21546 @node Changing Selections, Displaying Selections, Making Selections, Selecting Subformulas
21547 @subsection Changing Selections
21548
21549 @noindent
21550 @kindex j m
21551 @pindex calc-select-more
21552 Once you have selected a sub-formula, you can expand it using the
21553 @w{@kbd{j m}} (@code{calc-select-more}) command. If @samp{a + b} is
21554 selected, pressing @w{@kbd{j m}} repeatedly works as follows:
21555
21556 @smallexample
21557 @group
21558 3 ... 3 ___ 3 ___
21559 (a + b) . . . (a + b) + V c (a + b) + V c
21560 1* ............... 1* ............... 1* ---------------
21561 . . . . . . . . 2 x + 1
21562 @end group
21563 @end smallexample
21564
21565 @noindent
21566 In the last example, the entire formula is selected. This is roughly
21567 the same as having no selection at all, but because there are subtle
21568 differences the @samp{*} character is still there on the line number.
21569
21570 With a numeric prefix argument @var{n}, @kbd{j m} expands @var{n}
21571 times (or until the entire formula is selected). Note that @kbd{j s}
21572 with argument @var{n} is equivalent to plain @kbd{j s} followed by
21573 @kbd{j m} with argument @var{n}. If @w{@kbd{j m}} is used when there
21574 is no current selection, it is equivalent to @w{@kbd{j s}}.
21575
21576 Even though @kbd{j m} does not explicitly use the location of the
21577 cursor within the formula, it nevertheless uses the cursor to determine
21578 which stack element to operate on. As usual, @kbd{j m} when the cursor
21579 is not on any stack element operates on the top stack element.
21580
21581 @kindex j l
21582 @pindex calc-select-less
21583 The @kbd{j l} (@code{calc-select-less}) command reduces the current
21584 selection around the cursor position. That is, it selects the
21585 immediate sub-formula of the current selection which contains the
21586 cursor, the opposite of @kbd{j m}. If the cursor is not inside the
21587 current selection, the command de-selects the formula.
21588
21589 @kindex j 1-9
21590 @pindex calc-select-part
21591 The @kbd{j 1} through @kbd{j 9} (@code{calc-select-part}) commands
21592 select the @var{n}th sub-formula of the current selection. They are
21593 like @kbd{j l} (@code{calc-select-less}) except they use counting
21594 rather than the cursor position to decide which sub-formula to select.
21595 For example, if the current selection is @kbd{a + b + c} or
21596 @kbd{f(a, b, c)} or @kbd{[a, b, c]}, then @kbd{j 1} selects @samp{a},
21597 @kbd{j 2} selects @samp{b}, and @kbd{j 3} selects @samp{c}; in each of
21598 these cases, @kbd{j 4} through @kbd{j 9} would be errors.
21599
21600 If there is no current selection, @kbd{j 1} through @kbd{j 9} select
21601 the @var{n}th top-level sub-formula. (In other words, they act as if
21602 the entire stack entry were selected first.) To select the @var{n}th
21603 sub-formula where @var{n} is greater than nine, you must instead invoke
21604 @w{@kbd{j 1}} with @var{n} as a numeric prefix argument.
21605
21606 @kindex j n
21607 @kindex j p
21608 @pindex calc-select-next
21609 @pindex calc-select-previous
21610 The @kbd{j n} (@code{calc-select-next}) and @kbd{j p}
21611 (@code{calc-select-previous}) commands change the current selection
21612 to the next or previous sub-formula at the same level. For example,
21613 if @samp{b} is selected in @w{@samp{2 + a*b*c + x}}, then @kbd{j n}
21614 selects @samp{c}. Further @kbd{j n} commands would be in error because,
21615 even though there is something to the right of @samp{c} (namely, @samp{x}),
21616 it is not at the same level; in this case, it is not a term of the
21617 same product as @samp{b} and @samp{c}. However, @kbd{j m} (to select
21618 the whole product @samp{a*b*c} as a term of the sum) followed by
21619 @w{@kbd{j n}} would successfully select the @samp{x}.
21620
21621 Similarly, @kbd{j p} moves the selection from the @samp{b} in this
21622 sample formula to the @samp{a}. Both commands accept numeric prefix
21623 arguments to move several steps at a time.
21624
21625 It is interesting to compare Calc's selection commands with the
21626 Emacs Info system's commands for navigating through hierarchically
21627 organized documentation. Calc's @kbd{j n} command is completely
21628 analogous to Info's @kbd{n} command. Likewise, @kbd{j p} maps to
21629 @kbd{p}, @kbd{j 2} maps to @kbd{2}, and Info's @kbd{u} is like @kbd{j m}.
21630 (Note that @kbd{j u} stands for @code{calc-unselect}, not ``up''.)
21631 The Info @kbd{m} command is somewhat similar to Calc's @kbd{j s} and
21632 @kbd{j l}; in each case, you can jump directly to a sub-component
21633 of the hierarchy simply by pointing to it with the cursor.
21634
21635 @node Displaying Selections, Operating on Selections, Changing Selections, Selecting Subformulas
21636 @subsection Displaying Selections
21637
21638 @noindent
21639 @kindex j d
21640 @pindex calc-show-selections
21641 The @kbd{j d} (@code{calc-show-selections}) command controls how
21642 selected sub-formulas are displayed. One of the alternatives is
21643 illustrated in the above examples; if we press @kbd{j d} we switch
21644 to the other style in which the selected portion itself is obscured
21645 by @samp{#} signs:
21646
21647 @smallexample
21648 @group
21649 3 ... # ___
21650 (a + b) . . . ## # ## + V c
21651 1* ............... 1* ---------------
21652 . . . . 2 x + 1
21653 @end group
21654 @end smallexample
21655
21656 @node Operating on Selections, Rearranging with Selections, Displaying Selections, Selecting Subformulas
21657 @subsection Operating on Selections
21658
21659 @noindent
21660 Once a selection is made, all Calc commands that manipulate items
21661 on the stack will operate on the selected portions of the items
21662 instead. (Note that several stack elements may have selections
21663 at once, though there can be only one selection at a time in any
21664 given stack element.)
21665
21666 @kindex j e
21667 @pindex calc-enable-selections
21668 The @kbd{j e} (@code{calc-enable-selections}) command disables the
21669 effect that selections have on Calc commands. The current selections
21670 still exist, but Calc commands operate on whole stack elements anyway.
21671 This mode can be identified by the fact that the @samp{*} markers on
21672 the line numbers are gone, even though selections are visible. To
21673 reactivate the selections, press @kbd{j e} again.
21674
21675 To extract a sub-formula as a new formula, simply select the
21676 sub-formula and press @key{RET}. This normally duplicates the top
21677 stack element; here it duplicates only the selected portion of that
21678 element.
21679
21680 To replace a sub-formula with something different, you can enter the
21681 new value onto the stack and press @key{TAB}. This normally exchanges
21682 the top two stack elements; here it swaps the value you entered into
21683 the selected portion of the formula, returning the old selected
21684 portion to the top of the stack.
21685
21686 @smallexample
21687 @group
21688 3 ... ... ___
21689 (a + b) . . . 17 x y . . . 17 x y + V c
21690 2* ............... 2* ............. 2: -------------
21691 . . . . . . . . 2 x + 1
21692
21693 3 3
21694 1: 17 x y 1: (a + b) 1: (a + b)
21695 @end group
21696 @end smallexample
21697
21698 In this example we select a sub-formula of our original example,
21699 enter a new formula, @key{TAB} it into place, then deselect to see
21700 the complete, edited formula.
21701
21702 If you want to swap whole formulas around even though they contain
21703 selections, just use @kbd{j e} before and after.
21704
21705 @kindex j '
21706 @pindex calc-enter-selection
21707 The @kbd{j '} (@code{calc-enter-selection}) command is another way
21708 to replace a selected sub-formula. This command does an algebraic
21709 entry just like the regular @kbd{'} key. When you press @key{RET},
21710 the formula you type replaces the original selection. You can use
21711 the @samp{$} symbol in the formula to refer to the original
21712 selection. If there is no selection in the formula under the cursor,
21713 the cursor is used to make a temporary selection for the purposes of
21714 the command. Thus, to change a term of a formula, all you have to
21715 do is move the Emacs cursor to that term and press @kbd{j '}.
21716
21717 @kindex j `
21718 @pindex calc-edit-selection
21719 The @kbd{j `} (@code{calc-edit-selection}) command is a similar
21720 analogue of the @kbd{`} (@code{calc-edit}) command. It edits the
21721 selected sub-formula in a separate buffer. If there is no
21722 selection, it edits the sub-formula indicated by the cursor.
21723
21724 To delete a sub-formula, press @key{DEL}. This generally replaces
21725 the sub-formula with the constant zero, but in a few suitable contexts
21726 it uses the constant one instead. The @key{DEL} key automatically
21727 deselects and re-simplifies the entire formula afterwards. Thus:
21728
21729 @smallexample
21730 @group
21731 ###
21732 17 x y + # # 17 x y 17 # y 17 y
21733 1* ------------- 1: ------- 1* ------- 1: -------
21734 2 x + 1 2 x + 1 2 x + 1 2 x + 1
21735 @end group
21736 @end smallexample
21737
21738 In this example, we first delete the @samp{sqrt(c)} term; Calc
21739 accomplishes this by replacing @samp{sqrt(c)} with zero and
21740 resimplifying. We then delete the @kbd{x} in the numerator;
21741 since this is part of a product, Calc replaces it with @samp{1}
21742 and resimplifies.
21743
21744 If you select an element of a vector and press @key{DEL}, that
21745 element is deleted from the vector. If you delete one side of
21746 an equation or inequality, only the opposite side remains.
21747
21748 @kindex j @key{DEL}
21749 @pindex calc-del-selection
21750 The @kbd{j @key{DEL}} (@code{calc-del-selection}) command is like
21751 @key{DEL} but with the auto-selecting behavior of @kbd{j '} and
21752 @kbd{j `}. It deletes the selected portion of the formula
21753 indicated by the cursor, or, in the absence of a selection, it
21754 deletes the sub-formula indicated by the cursor position.
21755
21756 @kindex j @key{RET}
21757 @pindex calc-grab-selection
21758 (There is also an auto-selecting @kbd{j @key{RET}} (@code{calc-copy-selection})
21759 command.)
21760
21761 Normal arithmetic operations also apply to sub-formulas. Here we
21762 select the denominator, press @kbd{5 -} to subtract five from the
21763 denominator, press @kbd{n} to negate the denominator, then
21764 press @kbd{Q} to take the square root.
21765
21766 @smallexample
21767 @group
21768 .. . .. . .. . .. .
21769 1* ....... 1* ....... 1* ....... 1* ..........
21770 2 x + 1 2 x - 4 4 - 2 x _________
21771 V 4 - 2 x
21772 @end group
21773 @end smallexample
21774
21775 Certain types of operations on selections are not allowed. For
21776 example, for an arithmetic function like @kbd{-} no more than one of
21777 the arguments may be a selected sub-formula. (As the above example
21778 shows, the result of the subtraction is spliced back into the argument
21779 which had the selection; if there were more than one selection involved,
21780 this would not be well-defined.) If you try to subtract two selections,
21781 the command will abort with an error message.
21782
21783 Operations on sub-formulas sometimes leave the formula as a whole
21784 in an ``un-natural'' state. Consider negating the @samp{2 x} term
21785 of our sample formula by selecting it and pressing @kbd{n}
21786 (@code{calc-change-sign}).
21787
21788 @smallexample
21789 @group
21790 .. . .. .
21791 1* .......... 1* ...........
21792 ......... ..........
21793 . . . 2 x . . . -2 x
21794 @end group
21795 @end smallexample
21796
21797 Unselecting the sub-formula reveals that the minus sign, which would
21798 normally have cancelled out with the subtraction automatically, has
21799 not been able to do so because the subtraction was not part of the
21800 selected portion. Pressing @kbd{=} (@code{calc-evaluate}) or doing
21801 any other mathematical operation on the whole formula will cause it
21802 to be simplified.
21803
21804 @smallexample
21805 @group
21806 17 y 17 y
21807 1: ----------- 1: ----------
21808 __________ _________
21809 V 4 - -2 x V 4 + 2 x
21810 @end group
21811 @end smallexample
21812
21813 @node Rearranging with Selections, , Operating on Selections, Selecting Subformulas
21814 @subsection Rearranging Formulas using Selections
21815
21816 @noindent
21817 @kindex j R
21818 @pindex calc-commute-right
21819 The @kbd{j R} (@code{calc-commute-right}) command moves the selected
21820 sub-formula to the right in its surrounding formula. Generally the
21821 selection is one term of a sum or product; the sum or product is
21822 rearranged according to the commutative laws of algebra.
21823
21824 As with @kbd{j '} and @kbd{j @key{DEL}}, the term under the cursor is used
21825 if there is no selection in the current formula. All commands described
21826 in this section share this property. In this example, we place the
21827 cursor on the @samp{a} and type @kbd{j R}, then repeat.
21828
21829 @smallexample
21830 1: a + b - c 1: b + a - c 1: b - c + a
21831 @end smallexample
21832
21833 @noindent
21834 Note that in the final step above, the @samp{a} is switched with
21835 the @samp{c} but the signs are adjusted accordingly. When moving
21836 terms of sums and products, @kbd{j R} will never change the
21837 mathematical meaning of the formula.
21838
21839 The selected term may also be an element of a vector or an argument
21840 of a function. The term is exchanged with the one to its right.
21841 In this case, the ``meaning'' of the vector or function may of
21842 course be drastically changed.
21843
21844 @smallexample
21845 1: [a, b, c] 1: [b, a, c] 1: [b, c, a]
21846
21847 1: f(a, b, c) 1: f(b, a, c) 1: f(b, c, a)
21848 @end smallexample
21849
21850 @kindex j L
21851 @pindex calc-commute-left
21852 The @kbd{j L} (@code{calc-commute-left}) command is like @kbd{j R}
21853 except that it swaps the selected term with the one to its left.
21854
21855 With numeric prefix arguments, these commands move the selected
21856 term several steps at a time. It is an error to try to move a
21857 term left or right past the end of its enclosing formula.
21858 With numeric prefix arguments of zero, these commands move the
21859 selected term as far as possible in the given direction.
21860
21861 @kindex j D
21862 @pindex calc-sel-distribute
21863 The @kbd{j D} (@code{calc-sel-distribute}) command mixes the selected
21864 sum or product into the surrounding formula using the distributive
21865 law. For example, in @samp{a * (b - c)} with the @samp{b - c}
21866 selected, the result is @samp{a b - a c}. This also distributes
21867 products or quotients into surrounding powers, and can also do
21868 transformations like @samp{exp(a + b)} to @samp{exp(a) exp(b)},
21869 where @samp{a + b} is the selected term, and @samp{ln(a ^ b)}
21870 to @samp{ln(a) b}, where @samp{a ^ b} is the selected term.
21871
21872 For multiple-term sums or products, @kbd{j D} takes off one term
21873 at a time: @samp{a * (b + c - d)} goes to @samp{a * (c - d) + a b}
21874 with the @samp{c - d} selected so that you can type @kbd{j D}
21875 repeatedly to expand completely. The @kbd{j D} command allows a
21876 numeric prefix argument which specifies the maximum number of
21877 times to expand at once; the default is one time only.
21878
21879 @vindex DistribRules
21880 The @kbd{j D} command is implemented using rewrite rules.
21881 @xref{Selections with Rewrite Rules}. The rules are stored in
21882 the Calc variable @code{DistribRules}. A convenient way to view
21883 these rules is to use @kbd{s e} (@code{calc-edit-variable}) which
21884 displays and edits the stored value of a variable. Press @kbd{C-c C-c}
21885 to return from editing mode; be careful not to make any actual changes
21886 or else you will affect the behavior of future @kbd{j D} commands!
21887
21888 To extend @kbd{j D} to handle new cases, just edit @code{DistribRules}
21889 as described above. You can then use the @kbd{s p} command to save
21890 this variable's value permanently for future Calc sessions.
21891 @xref{Operations on Variables}.
21892
21893 @kindex j M
21894 @pindex calc-sel-merge
21895 @vindex MergeRules
21896 The @kbd{j M} (@code{calc-sel-merge}) command is the complement
21897 of @kbd{j D}; given @samp{a b - a c} with either @samp{a b} or
21898 @samp{a c} selected, the result is @samp{a * (b - c)}. Once
21899 again, @kbd{j M} can also merge calls to functions like @code{exp}
21900 and @code{ln}; examine the variable @code{MergeRules} to see all
21901 the relevant rules.
21902
21903 @kindex j C
21904 @pindex calc-sel-commute
21905 @vindex CommuteRules
21906 The @kbd{j C} (@code{calc-sel-commute}) command swaps the arguments
21907 of the selected sum, product, or equation. It always behaves as
21908 if @kbd{j b} mode were in effect, i.e., the sum @samp{a + b + c} is
21909 treated as the nested sums @samp{(a + b) + c} by this command.
21910 If you put the cursor on the first @samp{+}, the result is
21911 @samp{(b + a) + c}; if you put the cursor on the second @samp{+}, the
21912 result is @samp{c + (a + b)} (which the default simplifications
21913 will rearrange to @samp{(c + a) + b}). The relevant rules are stored
21914 in the variable @code{CommuteRules}.
21915
21916 You may need to turn default simplifications off (with the @kbd{m O}
21917 command) in order to get the full benefit of @kbd{j C}. For example,
21918 commuting @samp{a - b} produces @samp{-b + a}, but the default
21919 simplifications will ``simplify'' this right back to @samp{a - b} if
21920 you don't turn them off. The same is true of some of the other
21921 manipulations described in this section.
21922
21923 @kindex j N
21924 @pindex calc-sel-negate
21925 @vindex NegateRules
21926 The @kbd{j N} (@code{calc-sel-negate}) command replaces the selected
21927 term with the negative of that term, then adjusts the surrounding
21928 formula in order to preserve the meaning. For example, given
21929 @samp{exp(a - b)} where @samp{a - b} is selected, the result is
21930 @samp{1 / exp(b - a)}. By contrast, selecting a term and using the
21931 regular @kbd{n} (@code{calc-change-sign}) command negates the
21932 term without adjusting the surroundings, thus changing the meaning
21933 of the formula as a whole. The rules variable is @code{NegateRules}.
21934
21935 @kindex j &
21936 @pindex calc-sel-invert
21937 @vindex InvertRules
21938 The @kbd{j &} (@code{calc-sel-invert}) command is similar to @kbd{j N}
21939 except it takes the reciprocal of the selected term. For example,
21940 given @samp{a - ln(b)} with @samp{b} selected, the result is
21941 @samp{a + ln(1/b)}. The rules variable is @code{InvertRules}.
21942
21943 @kindex j E
21944 @pindex calc-sel-jump-equals
21945 @vindex JumpRules
21946 The @kbd{j E} (@code{calc-sel-jump-equals}) command moves the
21947 selected term from one side of an equation to the other. Given
21948 @samp{a + b = c + d} with @samp{c} selected, the result is
21949 @samp{a + b - c = d}. This command also works if the selected
21950 term is part of a @samp{*}, @samp{/}, or @samp{^} formula. The
21951 relevant rules variable is @code{JumpRules}.
21952
21953 @kindex j I
21954 @kindex H j I
21955 @pindex calc-sel-isolate
21956 The @kbd{j I} (@code{calc-sel-isolate}) command isolates the
21957 selected term on its side of an equation. It uses the @kbd{a S}
21958 (@code{calc-solve-for}) command to solve the equation, and the
21959 Hyperbolic flag affects it in the same way. @xref{Solving Equations}.
21960 When it applies, @kbd{j I} is often easier to use than @kbd{j E}.
21961 It understands more rules of algebra, and works for inequalities
21962 as well as equations.
21963
21964 @kindex j *
21965 @kindex j /
21966 @pindex calc-sel-mult-both-sides
21967 @pindex calc-sel-div-both-sides
21968 The @kbd{j *} (@code{calc-sel-mult-both-sides}) command prompts for a
21969 formula using algebraic entry, then multiplies both sides of the
21970 selected quotient or equation by that formula. It simplifies each
21971 side with @kbd{a s} (@code{calc-simplify}) before re-forming the
21972 quotient or equation. You can suppress this simplification by
21973 providing any numeric prefix argument. There is also a @kbd{j /}
21974 (@code{calc-sel-div-both-sides}) which is similar to @kbd{j *} but
21975 dividing instead of multiplying by the factor you enter.
21976
21977 As a special feature, if the numerator of the quotient is 1, then
21978 the denominator is expanded at the top level using the distributive
21979 law (i.e., using the @kbd{C-u -1 a x} command). Suppose the
21980 formula on the stack is @samp{1 / (sqrt(a) + 1)}, and you wish
21981 to eliminate the square root in the denominator by multiplying both
21982 sides by @samp{sqrt(a) - 1}. Calc's default simplifications would
21983 change the result @samp{(sqrt(a) - 1) / (sqrt(a) - 1) (sqrt(a) + 1)}
21984 right back to the original form by cancellation; Calc expands the
21985 denominator to @samp{sqrt(a) (sqrt(a) - 1) + sqrt(a) - 1} to prevent
21986 this. (You would now want to use an @kbd{a x} command to expand
21987 the rest of the way, whereupon the denominator would cancel out to
21988 the desired form, @samp{a - 1}.) When the numerator is not 1, this
21989 initial expansion is not necessary because Calc's default
21990 simplifications will not notice the potential cancellation.
21991
21992 If the selection is an inequality, @kbd{j *} and @kbd{j /} will
21993 accept any factor, but will warn unless they can prove the factor
21994 is either positive or negative. (In the latter case the direction
21995 of the inequality will be switched appropriately.) @xref{Declarations},
21996 for ways to inform Calc that a given variable is positive or
21997 negative. If Calc can't tell for sure what the sign of the factor
21998 will be, it will assume it is positive and display a warning
21999 message.
22000
22001 For selections that are not quotients, equations, or inequalities,
22002 these commands pull out a multiplicative factor: They divide (or
22003 multiply) by the entered formula, simplify, then multiply (or divide)
22004 back by the formula.
22005
22006 @kindex j +
22007 @kindex j -
22008 @pindex calc-sel-add-both-sides
22009 @pindex calc-sel-sub-both-sides
22010 The @kbd{j +} (@code{calc-sel-add-both-sides}) and @kbd{j -}
22011 (@code{calc-sel-sub-both-sides}) commands analogously add to or
22012 subtract from both sides of an equation or inequality. For other
22013 types of selections, they extract an additive factor. A numeric
22014 prefix argument suppresses simplification of the intermediate
22015 results.
22016
22017 @kindex j U
22018 @pindex calc-sel-unpack
22019 The @kbd{j U} (@code{calc-sel-unpack}) command replaces the
22020 selected function call with its argument. For example, given
22021 @samp{a + sin(x^2)} with @samp{sin(x^2)} selected, the result
22022 is @samp{a + x^2}. (The @samp{x^2} will remain selected; if you
22023 wanted to change the @code{sin} to @code{cos}, just press @kbd{C}
22024 now to take the cosine of the selected part.)
22025
22026 @kindex j v
22027 @pindex calc-sel-evaluate
22028 The @kbd{j v} (@code{calc-sel-evaluate}) command performs the
22029 normal default simplifications on the selected sub-formula.
22030 These are the simplifications that are normally done automatically
22031 on all results, but which may have been partially inhibited by
22032 previous selection-related operations, or turned off altogether
22033 by the @kbd{m O} command. This command is just an auto-selecting
22034 version of the @w{@kbd{a v}} command (@pxref{Algebraic Manipulation}).
22035
22036 With a numeric prefix argument of 2, @kbd{C-u 2 j v} applies
22037 the @kbd{a s} (@code{calc-simplify}) command to the selected
22038 sub-formula. With a prefix argument of 3 or more, e.g., @kbd{C-u j v}
22039 applies the @kbd{a e} (@code{calc-simplify-extended}) command.
22040 @xref{Simplifying Formulas}. With a negative prefix argument
22041 it simplifies at the top level only, just as with @kbd{a v}.
22042 Here the ``top'' level refers to the top level of the selected
22043 sub-formula.
22044
22045 @kindex j "
22046 @pindex calc-sel-expand-formula
22047 The @kbd{j "} (@code{calc-sel-expand-formula}) command is to @kbd{a "}
22048 (@pxref{Algebraic Manipulation}) what @kbd{j v} is to @kbd{a v}.
22049
22050 You can use the @kbd{j r} (@code{calc-rewrite-selection}) command
22051 to define other algebraic operations on sub-formulas. @xref{Rewrite Rules}.
22052
22053 @node Algebraic Manipulation, Simplifying Formulas, Selecting Subformulas, Algebra
22054 @section Algebraic Manipulation
22055
22056 @noindent
22057 The commands in this section perform general-purpose algebraic
22058 manipulations. They work on the whole formula at the top of the
22059 stack (unless, of course, you have made a selection in that
22060 formula).
22061
22062 Many algebra commands prompt for a variable name or formula. If you
22063 answer the prompt with a blank line, the variable or formula is taken
22064 from top-of-stack, and the normal argument for the command is taken
22065 from the second-to-top stack level.
22066
22067 @kindex a v
22068 @pindex calc-alg-evaluate
22069 The @kbd{a v} (@code{calc-alg-evaluate}) command performs the normal
22070 default simplifications on a formula; for example, @samp{a - -b} is
22071 changed to @samp{a + b}. These simplifications are normally done
22072 automatically on all Calc results, so this command is useful only if
22073 you have turned default simplifications off with an @kbd{m O}
22074 command. @xref{Simplification Modes}.
22075
22076 It is often more convenient to type @kbd{=}, which is like @kbd{a v}
22077 but which also substitutes stored values for variables in the formula.
22078 Use @kbd{a v} if you want the variables to ignore their stored values.
22079
22080 If you give a numeric prefix argument of 2 to @kbd{a v}, it simplifies
22081 as if in Algebraic Simplification mode. This is equivalent to typing
22082 @kbd{a s}; @pxref{Simplifying Formulas}. If you give a numeric prefix
22083 of 3 or more, it uses Extended Simplification mode (@kbd{a e}).
22084
22085 If you give a negative prefix argument @mathit{-1}, @mathit{-2}, or @mathit{-3},
22086 it simplifies in the corresponding mode but only works on the top-level
22087 function call of the formula. For example, @samp{(2 + 3) * (2 + 3)} will
22088 simplify to @samp{(2 + 3)^2}, without simplifying the sub-formulas
22089 @samp{2 + 3}. As another example, typing @kbd{V R +} to sum the vector
22090 @samp{[1, 2, 3, 4]} produces the formula @samp{reduce(add, [1, 2, 3, 4])}
22091 in No-Simplify mode. Using @kbd{a v} will evaluate this all the way to
22092 10; using @kbd{C-u - a v} will evaluate it only to @samp{1 + 2 + 3 + 4}.
22093 (@xref{Reducing and Mapping}.)
22094
22095 @tindex evalv
22096 @tindex evalvn
22097 The @kbd{=} command corresponds to the @code{evalv} function, and
22098 the related @kbd{N} command, which is like @kbd{=} but temporarily
22099 disables Symbolic mode (@kbd{m s}) during the evaluation, corresponds
22100 to the @code{evalvn} function. (These commands interpret their prefix
22101 arguments differently than @kbd{a v}; @kbd{=} treats the prefix as
22102 the number of stack elements to evaluate at once, and @kbd{N} treats
22103 it as a temporary different working precision.)
22104
22105 The @code{evalvn} function can take an alternate working precision
22106 as an optional second argument. This argument can be either an
22107 integer, to set the precision absolutely, or a vector containing
22108 a single integer, to adjust the precision relative to the current
22109 precision. Note that @code{evalvn} with a larger than current
22110 precision will do the calculation at this higher precision, but the
22111 result will as usual be rounded back down to the current precision
22112 afterward. For example, @samp{evalvn(pi - 3.1415)} at a precision
22113 of 12 will return @samp{9.265359e-5}; @samp{evalvn(pi - 3.1415, 30)}
22114 will return @samp{9.26535897932e-5} (computing a 25-digit result which
22115 is then rounded down to 12); and @samp{evalvn(pi - 3.1415, [-2])}
22116 will return @samp{9.2654e-5}.
22117
22118 @kindex a "
22119 @pindex calc-expand-formula
22120 The @kbd{a "} (@code{calc-expand-formula}) command expands functions
22121 into their defining formulas wherever possible. For example,
22122 @samp{deg(x^2)} is changed to @samp{180 x^2 / pi}. Most functions,
22123 like @code{sin} and @code{gcd}, are not defined by simple formulas
22124 and so are unaffected by this command. One important class of
22125 functions which @emph{can} be expanded is the user-defined functions
22126 created by the @kbd{Z F} command. @xref{Algebraic Definitions}.
22127 Other functions which @kbd{a "} can expand include the probability
22128 distribution functions, most of the financial functions, and the
22129 hyperbolic and inverse hyperbolic functions. A numeric prefix argument
22130 affects @kbd{a "} in the same way as it does @kbd{a v}: A positive
22131 argument expands all functions in the formula and then simplifies in
22132 various ways; a negative argument expands and simplifies only the
22133 top-level function call.
22134
22135 @kindex a M
22136 @pindex calc-map-equation
22137 @tindex mapeq
22138 The @kbd{a M} (@code{calc-map-equation}) [@code{mapeq}] command applies
22139 a given function or operator to one or more equations. It is analogous
22140 to @kbd{V M}, which operates on vectors instead of equations.
22141 @pxref{Reducing and Mapping}. For example, @kbd{a M S} changes
22142 @samp{x = y+1} to @samp{sin(x) = sin(y+1)}, and @kbd{a M +} with
22143 @samp{x = y+1} and @expr{6} on the stack produces @samp{x+6 = y+7}.
22144 With two equations on the stack, @kbd{a M +} would add the lefthand
22145 sides together and the righthand sides together to get the two
22146 respective sides of a new equation.
22147
22148 Mapping also works on inequalities. Mapping two similar inequalities
22149 produces another inequality of the same type. Mapping an inequality
22150 with an equation produces an inequality of the same type. Mapping a
22151 @samp{<=} with a @samp{<} or @samp{!=} (not-equal) produces a @samp{<}.
22152 If inequalities with opposite direction (e.g., @samp{<} and @samp{>})
22153 are mapped, the direction of the second inequality is reversed to
22154 match the first: Using @kbd{a M +} on @samp{a < b} and @samp{a > 2}
22155 reverses the latter to get @samp{2 < a}, which then allows the
22156 combination @samp{a + 2 < b + a}, which the @kbd{a s} command can
22157 then simplify to get @samp{2 < b}.
22158
22159 Using @kbd{a M *}, @kbd{a M /}, @kbd{a M n}, or @kbd{a M &} to negate
22160 or invert an inequality will reverse the direction of the inequality.
22161 Other adjustments to inequalities are @emph{not} done automatically;
22162 @kbd{a M S} will change @w{@samp{x < y}} to @samp{sin(x) < sin(y)} even
22163 though this is not true for all values of the variables.
22164
22165 @kindex H a M
22166 @tindex mapeqp
22167 With the Hyperbolic flag, @kbd{H a M} [@code{mapeqp}] does a plain
22168 mapping operation without reversing the direction of any inequalities.
22169 Thus, @kbd{H a M &} would change @kbd{x > 2} to @kbd{1/x > 0.5}.
22170 (This change is mathematically incorrect, but perhaps you were
22171 fixing an inequality which was already incorrect.)
22172
22173 @kindex I a M
22174 @tindex mapeqr
22175 With the Inverse flag, @kbd{I a M} [@code{mapeqr}] always reverses
22176 the direction of the inequality. You might use @kbd{I a M C} to
22177 change @samp{x < y} to @samp{cos(x) > cos(y)} if you know you are
22178 working with small positive angles.
22179
22180 @kindex a b
22181 @pindex calc-substitute
22182 @tindex subst
22183 The @kbd{a b} (@code{calc-substitute}) [@code{subst}] command substitutes
22184 all occurrences
22185 of some variable or sub-expression of an expression with a new
22186 sub-expression. For example, substituting @samp{sin(x)} with @samp{cos(y)}
22187 in @samp{2 sin(x)^2 + x sin(x) + sin(2 x)} produces
22188 @samp{2 cos(y)^2 + x cos(y) + @w{sin(2 x)}}.
22189 Note that this is a purely structural substitution; the lone @samp{x} and
22190 the @samp{sin(2 x)} stayed the same because they did not look like
22191 @samp{sin(x)}. @xref{Rewrite Rules}, for a more general method for
22192 doing substitutions.
22193
22194 The @kbd{a b} command normally prompts for two formulas, the old
22195 one and the new one. If you enter a blank line for the first
22196 prompt, all three arguments are taken from the stack (new, then old,
22197 then target expression). If you type an old formula but then enter a
22198 blank line for the new one, the new formula is taken from top-of-stack
22199 and the target from second-to-top. If you answer both prompts, the
22200 target is taken from top-of-stack as usual.
22201
22202 Note that @kbd{a b} has no understanding of commutativity or
22203 associativity. The pattern @samp{x+y} will not match the formula
22204 @samp{y+x}. Also, @samp{y+z} will not match inside the formula @samp{x+y+z}
22205 because the @samp{+} operator is left-associative, so the ``deep
22206 structure'' of that formula is @samp{(x+y) + z}. Use @kbd{d U}
22207 (@code{calc-unformatted-language}) mode to see the true structure of
22208 a formula. The rewrite rule mechanism, discussed later, does not have
22209 these limitations.
22210
22211 As an algebraic function, @code{subst} takes three arguments:
22212 Target expression, old, new. Note that @code{subst} is always
22213 evaluated immediately, even if its arguments are variables, so if
22214 you wish to put a call to @code{subst} onto the stack you must
22215 turn the default simplifications off first (with @kbd{m O}).
22216
22217 @node Simplifying Formulas, Polynomials, Algebraic Manipulation, Algebra
22218 @section Simplifying Formulas
22219
22220 @noindent
22221 @kindex a s
22222 @pindex calc-simplify
22223 @tindex simplify
22224 The @kbd{a s} (@code{calc-simplify}) [@code{simplify}] command applies
22225 various algebraic rules to simplify a formula. This includes rules which
22226 are not part of the default simplifications because they may be too slow
22227 to apply all the time, or may not be desirable all of the time. For
22228 example, non-adjacent terms of sums are combined, as in @samp{a + b + 2 a}
22229 to @samp{b + 3 a}, and some formulas like @samp{sin(arcsin(x))} are
22230 simplified to @samp{x}.
22231
22232 The sections below describe all the various kinds of algebraic
22233 simplifications Calc provides in full detail. None of Calc's
22234 simplification commands are designed to pull rabbits out of hats;
22235 they simply apply certain specific rules to put formulas into
22236 less redundant or more pleasing forms. Serious algebra in Calc
22237 must be done manually, usually with a combination of selections
22238 and rewrite rules. @xref{Rearranging with Selections}.
22239 @xref{Rewrite Rules}.
22240
22241 @xref{Simplification Modes}, for commands to control what level of
22242 simplification occurs automatically. Normally only the ``default
22243 simplifications'' occur.
22244
22245 @menu
22246 * Default Simplifications::
22247 * Algebraic Simplifications::
22248 * Unsafe Simplifications::
22249 * Simplification of Units::
22250 @end menu
22251
22252 @node Default Simplifications, Algebraic Simplifications, Simplifying Formulas, Simplifying Formulas
22253 @subsection Default Simplifications
22254
22255 @noindent
22256 @cindex Default simplifications
22257 This section describes the ``default simplifications,'' those which are
22258 normally applied to all results. For example, if you enter the variable
22259 @expr{x} on the stack twice and push @kbd{+}, Calc's default
22260 simplifications automatically change @expr{x + x} to @expr{2 x}.
22261
22262 The @kbd{m O} command turns off the default simplifications, so that
22263 @expr{x + x} will remain in this form unless you give an explicit
22264 ``simplify'' command like @kbd{=} or @kbd{a v}. @xref{Algebraic
22265 Manipulation}. The @kbd{m D} command turns the default simplifications
22266 back on.
22267
22268 The most basic default simplification is the evaluation of functions.
22269 For example, @expr{2 + 3} is evaluated to @expr{5}, and @expr{@tfn{sqrt}(9)}
22270 is evaluated to @expr{3}. Evaluation does not occur if the arguments
22271 to a function are somehow of the wrong type @expr{@tfn{tan}([2,3,4])}),
22272 range (@expr{@tfn{tan}(90)}), or number (@expr{@tfn{tan}(3,5)}),
22273 or if the function name is not recognized (@expr{@tfn{f}(5)}), or if
22274 Symbolic mode (@pxref{Symbolic Mode}) prevents evaluation
22275 (@expr{@tfn{sqrt}(2)}).
22276
22277 Calc simplifies (evaluates) the arguments to a function before it
22278 simplifies the function itself. Thus @expr{@tfn{sqrt}(5+4)} is
22279 simplified to @expr{@tfn{sqrt}(9)} before the @code{sqrt} function
22280 itself is applied. There are very few exceptions to this rule:
22281 @code{quote}, @code{lambda}, and @code{condition} (the @code{::}
22282 operator) do not evaluate their arguments, @code{if} (the @code{? :}
22283 operator) does not evaluate all of its arguments, and @code{evalto}
22284 does not evaluate its lefthand argument.
22285
22286 Most commands apply the default simplifications to all arguments they
22287 take from the stack, perform a particular operation, then simplify
22288 the result before pushing it back on the stack. In the common special
22289 case of regular arithmetic commands like @kbd{+} and @kbd{Q} [@code{sqrt}],
22290 the arguments are simply popped from the stack and collected into a
22291 suitable function call, which is then simplified (the arguments being
22292 simplified first as part of the process, as described above).
22293
22294 The default simplifications are too numerous to describe completely
22295 here, but this section will describe the ones that apply to the
22296 major arithmetic operators. This list will be rather technical in
22297 nature, and will probably be interesting to you only if you are
22298 a serious user of Calc's algebra facilities.
22299
22300 @tex
22301 \bigskip
22302 @end tex
22303
22304 As well as the simplifications described here, if you have stored
22305 any rewrite rules in the variable @code{EvalRules} then these rules
22306 will also be applied before any built-in default simplifications.
22307 @xref{Automatic Rewrites}, for details.
22308
22309 @tex
22310 \bigskip
22311 @end tex
22312
22313 And now, on with the default simplifications:
22314
22315 Arithmetic operators like @kbd{+} and @kbd{*} always take two
22316 arguments in Calc's internal form. Sums and products of three or
22317 more terms are arranged by the associative law of algebra into
22318 a left-associative form for sums, @expr{((a + b) + c) + d}, and
22319 a right-associative form for products, @expr{a * (b * (c * d))}.
22320 Formulas like @expr{(a + b) + (c + d)} are rearranged to
22321 left-associative form, though this rarely matters since Calc's
22322 algebra commands are designed to hide the inner structure of
22323 sums and products as much as possible. Sums and products in
22324 their proper associative form will be written without parentheses
22325 in the examples below.
22326
22327 Sums and products are @emph{not} rearranged according to the
22328 commutative law (@expr{a + b} to @expr{b + a}) except in a few
22329 special cases described below. Some algebra programs always
22330 rearrange terms into a canonical order, which enables them to
22331 see that @expr{a b + b a} can be simplified to @expr{2 a b}.
22332 Calc assumes you have put the terms into the order you want
22333 and generally leaves that order alone, with the consequence
22334 that formulas like the above will only be simplified if you
22335 explicitly give the @kbd{a s} command. @xref{Algebraic
22336 Simplifications}.
22337
22338 Differences @expr{a - b} are treated like sums @expr{a + (-b)}
22339 for purposes of simplification; one of the default simplifications
22340 is to rewrite @expr{a + (-b)} or @expr{(-b) + a}, where @expr{-b}
22341 represents a ``negative-looking'' term, into @expr{a - b} form.
22342 ``Negative-looking'' means negative numbers, negated formulas like
22343 @expr{-x}, and products or quotients in which either term is
22344 negative-looking.
22345
22346 Other simplifications involving negation are @expr{-(-x)} to @expr{x};
22347 @expr{-(a b)} or @expr{-(a/b)} where either @expr{a} or @expr{b} is
22348 negative-looking, simplified by negating that term, or else where
22349 @expr{a} or @expr{b} is any number, by negating that number;
22350 @expr{-(a + b)} to @expr{-a - b}, and @expr{-(b - a)} to @expr{a - b}.
22351 (This, and rewriting @expr{(-b) + a} to @expr{a - b}, are the only
22352 cases where the order of terms in a sum is changed by the default
22353 simplifications.)
22354
22355 The distributive law is used to simplify sums in some cases:
22356 @expr{a x + b x} to @expr{(a + b) x}, where @expr{a} represents
22357 a number or an implicit 1 or @mathit{-1} (as in @expr{x} or @expr{-x})
22358 and similarly for @expr{b}. Use the @kbd{a c}, @w{@kbd{a f}}, or
22359 @kbd{j M} commands to merge sums with non-numeric coefficients
22360 using the distributive law.
22361
22362 The distributive law is only used for sums of two terms, or
22363 for adjacent terms in a larger sum. Thus @expr{a + b + b + c}
22364 is simplified to @expr{a + 2 b + c}, but @expr{a + b + c + b}
22365 is not simplified. The reason is that comparing all terms of a
22366 sum with one another would require time proportional to the
22367 square of the number of terms; Calc relegates potentially slow
22368 operations like this to commands that have to be invoked
22369 explicitly, like @kbd{a s}.
22370
22371 Finally, @expr{a + 0} and @expr{0 + a} are simplified to @expr{a}.
22372 A consequence of the above rules is that @expr{0 - a} is simplified
22373 to @expr{-a}.
22374
22375 @tex
22376 \bigskip
22377 @end tex
22378
22379 The products @expr{1 a} and @expr{a 1} are simplified to @expr{a};
22380 @expr{(-1) a} and @expr{a (-1)} are simplified to @expr{-a};
22381 @expr{0 a} and @expr{a 0} are simplified to @expr{0}, except that
22382 in Matrix mode where @expr{a} is not provably scalar the result
22383 is the generic zero matrix @samp{idn(0)}, and that if @expr{a} is
22384 infinite the result is @samp{nan}.
22385
22386 Also, @expr{(-a) b} and @expr{a (-b)} are simplified to @expr{-(a b)},
22387 where this occurs for negated formulas but not for regular negative
22388 numbers.
22389
22390 Products are commuted only to move numbers to the front:
22391 @expr{a b 2} is commuted to @expr{2 a b}.
22392
22393 The product @expr{a (b + c)} is distributed over the sum only if
22394 @expr{a} and at least one of @expr{b} and @expr{c} are numbers:
22395 @expr{2 (x + 3)} goes to @expr{2 x + 6}. The formula
22396 @expr{(-a) (b - c)}, where @expr{-a} is a negative number, is
22397 rewritten to @expr{a (c - b)}.
22398
22399 The distributive law of products and powers is used for adjacent
22400 terms of the product: @expr{x^a x^b} goes to
22401 @texline @math{x^{a+b}}
22402 @infoline @expr{x^(a+b)}
22403 where @expr{a} is a number, or an implicit 1 (as in @expr{x}),
22404 or the implicit one-half of @expr{@tfn{sqrt}(x)}, and similarly for
22405 @expr{b}. The result is written using @samp{sqrt} or @samp{1/sqrt}
22406 if the sum of the powers is @expr{1/2} or @expr{-1/2}, respectively.
22407 If the sum of the powers is zero, the product is simplified to
22408 @expr{1} or to @samp{idn(1)} if Matrix mode is enabled.
22409
22410 The product of a negative power times anything but another negative
22411 power is changed to use division:
22412 @texline @math{x^{-2} y}
22413 @infoline @expr{x^(-2) y}
22414 goes to @expr{y / x^2} unless Matrix mode is
22415 in effect and neither @expr{x} nor @expr{y} are scalar (in which
22416 case it is considered unsafe to rearrange the order of the terms).
22417
22418 Finally, @expr{a (b/c)} is rewritten to @expr{(a b)/c}, and also
22419 @expr{(a/b) c} is changed to @expr{(a c)/b} unless in Matrix mode.
22420
22421 @tex
22422 \bigskip
22423 @end tex
22424
22425 Simplifications for quotients are analogous to those for products.
22426 The quotient @expr{0 / x} is simplified to @expr{0}, with the same
22427 exceptions that were noted for @expr{0 x}. Likewise, @expr{x / 1}
22428 and @expr{x / (-1)} are simplified to @expr{x} and @expr{-x},
22429 respectively.
22430
22431 The quotient @expr{x / 0} is left unsimplified or changed to an
22432 infinite quantity, as directed by the current infinite mode.
22433 @xref{Infinite Mode}.
22434
22435 The expression
22436 @texline @math{a / b^{-c}}
22437 @infoline @expr{a / b^(-c)}
22438 is changed to @expr{a b^c}, where @expr{-c} is any negative-looking
22439 power. Also, @expr{1 / b^c} is changed to
22440 @texline @math{b^{-c}}
22441 @infoline @expr{b^(-c)}
22442 for any power @expr{c}.
22443
22444 Also, @expr{(-a) / b} and @expr{a / (-b)} go to @expr{-(a/b)};
22445 @expr{(a/b) / c} goes to @expr{a / (b c)}; and @expr{a / (b/c)}
22446 goes to @expr{(a c) / b} unless Matrix mode prevents this
22447 rearrangement. Similarly, @expr{a / (b:c)} is simplified to
22448 @expr{(c:b) a} for any fraction @expr{b:c}.
22449
22450 The distributive law is applied to @expr{(a + b) / c} only if
22451 @expr{c} and at least one of @expr{a} and @expr{b} are numbers.
22452 Quotients of powers and square roots are distributed just as
22453 described for multiplication.
22454
22455 Quotients of products cancel only in the leading terms of the
22456 numerator and denominator. In other words, @expr{a x b / a y b}
22457 is cancelled to @expr{x b / y b} but not to @expr{x / y}. Once
22458 again this is because full cancellation can be slow; use @kbd{a s}
22459 to cancel all terms of the quotient.
22460
22461 Quotients of negative-looking values are simplified according
22462 to @expr{(-a) / (-b)} to @expr{a / b}, @expr{(-a) / (b - c)}
22463 to @expr{a / (c - b)}, and @expr{(a - b) / (-c)} to @expr{(b - a) / c}.
22464
22465 @tex
22466 \bigskip
22467 @end tex
22468
22469 The formula @expr{x^0} is simplified to @expr{1}, or to @samp{idn(1)}
22470 in Matrix mode. The formula @expr{0^x} is simplified to @expr{0}
22471 unless @expr{x} is a negative number or complex number, in which
22472 case the result is an infinity or an unsimplified formula according
22473 to the current infinite mode. Note that @expr{0^0} is an
22474 indeterminate form, as evidenced by the fact that the simplifications
22475 for @expr{x^0} and @expr{0^x} conflict when @expr{x=0}.
22476
22477 Powers of products or quotients @expr{(a b)^c}, @expr{(a/b)^c}
22478 are distributed to @expr{a^c b^c}, @expr{a^c / b^c} only if @expr{c}
22479 is an integer, or if either @expr{a} or @expr{b} are nonnegative
22480 real numbers. Powers of powers @expr{(a^b)^c} are simplified to
22481 @texline @math{a^{b c}}
22482 @infoline @expr{a^(b c)}
22483 only when @expr{c} is an integer and @expr{b c} also
22484 evaluates to an integer. Without these restrictions these simplifications
22485 would not be safe because of problems with principal values.
22486 (In other words,
22487 @texline @math{((-3)^{1/2})^2}
22488 @infoline @expr{((-3)^1:2)^2}
22489 is safe to simplify, but
22490 @texline @math{((-3)^2)^{1/2}}
22491 @infoline @expr{((-3)^2)^1:2}
22492 is not.) @xref{Declarations}, for ways to inform Calc that your
22493 variables satisfy these requirements.
22494
22495 As a special case of this rule, @expr{@tfn{sqrt}(x)^n} is simplified to
22496 @texline @math{x^{n/2}}
22497 @infoline @expr{x^(n/2)}
22498 only for even integers @expr{n}.
22499
22500 If @expr{a} is known to be real, @expr{b} is an even integer, and
22501 @expr{c} is a half- or quarter-integer, then @expr{(a^b)^c} is
22502 simplified to @expr{@tfn{abs}(a^(b c))}.
22503
22504 Also, @expr{(-a)^b} is simplified to @expr{a^b} if @expr{b} is an
22505 even integer, or to @expr{-(a^b)} if @expr{b} is an odd integer,
22506 for any negative-looking expression @expr{-a}.
22507
22508 Square roots @expr{@tfn{sqrt}(x)} generally act like one-half powers
22509 @texline @math{x^{1:2}}
22510 @infoline @expr{x^1:2}
22511 for the purposes of the above-listed simplifications.
22512
22513 Also, note that
22514 @texline @math{1 / x^{1:2}}
22515 @infoline @expr{1 / x^1:2}
22516 is changed to
22517 @texline @math{x^{-1:2}},
22518 @infoline @expr{x^(-1:2)},
22519 but @expr{1 / @tfn{sqrt}(x)} is left alone.
22520
22521 @tex
22522 \bigskip
22523 @end tex
22524
22525 Generic identity matrices (@pxref{Matrix Mode}) are simplified by the
22526 following rules: @expr{@tfn{idn}(a) + b} to @expr{a + b} if @expr{b}
22527 is provably scalar, or expanded out if @expr{b} is a matrix;
22528 @expr{@tfn{idn}(a) + @tfn{idn}(b)} to @expr{@tfn{idn}(a + b)};
22529 @expr{-@tfn{idn}(a)} to @expr{@tfn{idn}(-a)}; @expr{a @tfn{idn}(b)} to
22530 @expr{@tfn{idn}(a b)} if @expr{a} is provably scalar, or to @expr{a b}
22531 if @expr{a} is provably non-scalar; @expr{@tfn{idn}(a) @tfn{idn}(b)} to
22532 @expr{@tfn{idn}(a b)}; analogous simplifications for quotients involving
22533 @code{idn}; and @expr{@tfn{idn}(a)^n} to @expr{@tfn{idn}(a^n)} where
22534 @expr{n} is an integer.
22535
22536 @tex
22537 \bigskip
22538 @end tex
22539
22540 The @code{floor} function and other integer truncation functions
22541 vanish if the argument is provably integer-valued, so that
22542 @expr{@tfn{floor}(@tfn{round}(x))} simplifies to @expr{@tfn{round}(x)}.
22543 Also, combinations of @code{float}, @code{floor} and its friends,
22544 and @code{ffloor} and its friends, are simplified in appropriate
22545 ways. @xref{Integer Truncation}.
22546
22547 The expression @expr{@tfn{abs}(-x)} changes to @expr{@tfn{abs}(x)}.
22548 The expression @expr{@tfn{abs}(@tfn{abs}(x))} changes to
22549 @expr{@tfn{abs}(x)}; in fact, @expr{@tfn{abs}(x)} changes to @expr{x} or
22550 @expr{-x} if @expr{x} is provably nonnegative or nonpositive
22551 (@pxref{Declarations}).
22552
22553 While most functions do not recognize the variable @code{i} as an
22554 imaginary number, the @code{arg} function does handle the two cases
22555 @expr{@tfn{arg}(@tfn{i})} and @expr{@tfn{arg}(-@tfn{i})} just for convenience.
22556
22557 The expression @expr{@tfn{conj}(@tfn{conj}(x))} simplifies to @expr{x}.
22558 Various other expressions involving @code{conj}, @code{re}, and
22559 @code{im} are simplified, especially if some of the arguments are
22560 provably real or involve the constant @code{i}. For example,
22561 @expr{@tfn{conj}(a + b i)} is changed to
22562 @expr{@tfn{conj}(a) - @tfn{conj}(b) i}, or to @expr{a - b i} if @expr{a}
22563 and @expr{b} are known to be real.
22564
22565 Functions like @code{sin} and @code{arctan} generally don't have
22566 any default simplifications beyond simply evaluating the functions
22567 for suitable numeric arguments and infinity. The @kbd{a s} command
22568 described in the next section does provide some simplifications for
22569 these functions, though.
22570
22571 One important simplification that does occur is that
22572 @expr{@tfn{ln}(@tfn{e})} is simplified to 1, and @expr{@tfn{ln}(@tfn{e}^x)} is
22573 simplified to @expr{x} for any @expr{x}. This occurs even if you have
22574 stored a different value in the Calc variable @samp{e}; but this would
22575 be a bad idea in any case if you were also using natural logarithms!
22576
22577 Among the logical functions, @tfn{(@var{a} <= @var{b})} changes to
22578 @tfn{@var{a} > @var{b}} and so on. Equations and inequalities where both sides
22579 are either negative-looking or zero are simplified by negating both sides
22580 and reversing the inequality. While it might seem reasonable to simplify
22581 @expr{!!x} to @expr{x}, this would not be valid in general because
22582 @expr{!!2} is 1, not 2.
22583
22584 Most other Calc functions have few if any default simplifications
22585 defined, aside of course from evaluation when the arguments are
22586 suitable numbers.
22587
22588 @node Algebraic Simplifications, Unsafe Simplifications, Default Simplifications, Simplifying Formulas
22589 @subsection Algebraic Simplifications
22590
22591 @noindent
22592 @cindex Algebraic simplifications
22593 The @kbd{a s} command makes simplifications that may be too slow to
22594 do all the time, or that may not be desirable all of the time.
22595 If you find these simplifications are worthwhile, you can type
22596 @kbd{m A} to have Calc apply them automatically.
22597
22598 This section describes all simplifications that are performed by
22599 the @kbd{a s} command. Note that these occur in addition to the
22600 default simplifications; even if the default simplifications have
22601 been turned off by an @kbd{m O} command, @kbd{a s} will turn them
22602 back on temporarily while it simplifies the formula.
22603
22604 There is a variable, @code{AlgSimpRules}, in which you can put rewrites
22605 to be applied by @kbd{a s}. Its use is analogous to @code{EvalRules},
22606 but without the special restrictions. Basically, the simplifier does
22607 @samp{@w{a r} AlgSimpRules} with an infinite repeat count on the whole
22608 expression being simplified, then it traverses the expression applying
22609 the built-in rules described below. If the result is different from
22610 the original expression, the process repeats with the default
22611 simplifications (including @code{EvalRules}), then @code{AlgSimpRules},
22612 then the built-in simplifications, and so on.
22613
22614 @tex
22615 \bigskip
22616 @end tex
22617
22618 Sums are simplified in two ways. Constant terms are commuted to the
22619 end of the sum, so that @expr{a + 2 + b} changes to @expr{a + b + 2}.
22620 The only exception is that a constant will not be commuted away
22621 from the first position of a difference, i.e., @expr{2 - x} is not
22622 commuted to @expr{-x + 2}.
22623
22624 Also, terms of sums are combined by the distributive law, as in
22625 @expr{x + y + 2 x} to @expr{y + 3 x}. This always occurs for
22626 adjacent terms, but @kbd{a s} compares all pairs of terms including
22627 non-adjacent ones.
22628
22629 @tex
22630 \bigskip
22631 @end tex
22632
22633 Products are sorted into a canonical order using the commutative
22634 law. For example, @expr{b c a} is commuted to @expr{a b c}.
22635 This allows easier comparison of products; for example, the default
22636 simplifications will not change @expr{x y + y x} to @expr{2 x y},
22637 but @kbd{a s} will; it first rewrites the sum to @expr{x y + x y},
22638 and then the default simplifications are able to recognize a sum
22639 of identical terms.
22640
22641 The canonical ordering used to sort terms of products has the
22642 property that real-valued numbers, interval forms and infinities
22643 come first, and are sorted into increasing order. The @kbd{V S}
22644 command uses the same ordering when sorting a vector.
22645
22646 Sorting of terms of products is inhibited when Matrix mode is
22647 turned on; in this case, Calc will never exchange the order of
22648 two terms unless it knows at least one of the terms is a scalar.
22649
22650 Products of powers are distributed by comparing all pairs of
22651 terms, using the same method that the default simplifications
22652 use for adjacent terms of products.
22653
22654 Even though sums are not sorted, the commutative law is still
22655 taken into account when terms of a product are being compared.
22656 Thus @expr{(x + y) (y + x)} will be simplified to @expr{(x + y)^2}.
22657 A subtle point is that @expr{(x - y) (y - x)} will @emph{not}
22658 be simplified to @expr{-(x - y)^2}; Calc does not notice that
22659 one term can be written as a constant times the other, even if
22660 that constant is @mathit{-1}.
22661
22662 A fraction times any expression, @expr{(a:b) x}, is changed to
22663 a quotient involving integers: @expr{a x / b}. This is not
22664 done for floating-point numbers like @expr{0.5}, however. This
22665 is one reason why you may find it convenient to turn Fraction mode
22666 on while doing algebra; @pxref{Fraction Mode}.
22667
22668 @tex
22669 \bigskip
22670 @end tex
22671
22672 Quotients are simplified by comparing all terms in the numerator
22673 with all terms in the denominator for possible cancellation using
22674 the distributive law. For example, @expr{a x^2 b / c x^3 d} will
22675 cancel @expr{x^2} from both sides to get @expr{a b / c x d}.
22676 (The terms in the denominator will then be rearranged to @expr{c d x}
22677 as described above.) If there is any common integer or fractional
22678 factor in the numerator and denominator, it is cancelled out;
22679 for example, @expr{(4 x + 6) / 8 x} simplifies to @expr{(2 x + 3) / 4 x}.
22680
22681 Non-constant common factors are not found even by @kbd{a s}. To
22682 cancel the factor @expr{a} in @expr{(a x + a) / a^2} you could first
22683 use @kbd{j M} on the product @expr{a x} to Merge the numerator to
22684 @expr{a (1+x)}, which can then be simplified successfully.
22685
22686 @tex
22687 \bigskip
22688 @end tex
22689
22690 Integer powers of the variable @code{i} are simplified according
22691 to the identity @expr{i^2 = -1}. If you store a new value other
22692 than the complex number @expr{(0,1)} in @code{i}, this simplification
22693 will no longer occur. This is done by @kbd{a s} instead of by default
22694 in case someone (unwisely) uses the name @code{i} for a variable
22695 unrelated to complex numbers; it would be unfortunate if Calc
22696 quietly and automatically changed this formula for reasons the
22697 user might not have been thinking of.
22698
22699 Square roots of integer or rational arguments are simplified in
22700 several ways. (Note that these will be left unevaluated only in
22701 Symbolic mode.) First, square integer or rational factors are
22702 pulled out so that @expr{@tfn{sqrt}(8)} is rewritten as
22703 @texline @math{2\,@tfn{sqrt}(2)}.
22704 @infoline @expr{2 sqrt(2)}.
22705 Conceptually speaking this implies factoring the argument into primes
22706 and moving pairs of primes out of the square root, but for reasons of
22707 efficiency Calc only looks for primes up to 29.
22708
22709 Square roots in the denominator of a quotient are moved to the
22710 numerator: @expr{1 / @tfn{sqrt}(3)} changes to @expr{@tfn{sqrt}(3) / 3}.
22711 The same effect occurs for the square root of a fraction:
22712 @expr{@tfn{sqrt}(2:3)} changes to @expr{@tfn{sqrt}(6) / 3}.
22713
22714 @tex
22715 \bigskip
22716 @end tex
22717
22718 The @code{%} (modulo) operator is simplified in several ways
22719 when the modulus @expr{M} is a positive real number. First, if
22720 the argument is of the form @expr{x + n} for some real number
22721 @expr{n}, then @expr{n} is itself reduced modulo @expr{M}. For
22722 example, @samp{(x - 23) % 10} is simplified to @samp{(x + 7) % 10}.
22723
22724 If the argument is multiplied by a constant, and this constant
22725 has a common integer divisor with the modulus, then this factor is
22726 cancelled out. For example, @samp{12 x % 15} is changed to
22727 @samp{3 (4 x % 5)} by factoring out 3. Also, @samp{(12 x + 1) % 15}
22728 is changed to @samp{3 ((4 x + 1:3) % 5)}. While these forms may
22729 not seem ``simpler,'' they allow Calc to discover useful information
22730 about modulo forms in the presence of declarations.
22731
22732 If the modulus is 1, then Calc can use @code{int} declarations to
22733 evaluate the expression. For example, the idiom @samp{x % 2} is
22734 often used to check whether a number is odd or even. As described
22735 above, @w{@samp{2 n % 2}} and @samp{(2 n + 1) % 2} are simplified to
22736 @samp{2 (n % 1)} and @samp{2 ((n + 1:2) % 1)}, respectively; Calc
22737 can simplify these to 0 and 1 (respectively) if @code{n} has been
22738 declared to be an integer.
22739
22740 @tex
22741 \bigskip
22742 @end tex
22743
22744 Trigonometric functions are simplified in several ways. Whenever a
22745 products of two trigonometric functions can be replaced by a single
22746 function, the replacement is made; for example,
22747 @expr{@tfn{tan}(x) @tfn{cos}(x)} is simplified to @expr{@tfn{sin}(x)}.
22748 Reciprocals of trigonometric functions are replaced by their reciprocal
22749 function; for example, @expr{1/@tfn{sec}(x)} is simplified to
22750 @expr{@tfn{cos}(x)}. The corresponding simplifications for the
22751 hyperbolic functions are also handled.
22752
22753 Trigonometric functions of their inverse functions are
22754 simplified. The expression @expr{@tfn{sin}(@tfn{arcsin}(x))} is
22755 simplified to @expr{x}, and similarly for @code{cos} and @code{tan}.
22756 Trigonometric functions of inverses of different trigonometric
22757 functions can also be simplified, as in @expr{@tfn{sin}(@tfn{arccos}(x))}
22758 to @expr{@tfn{sqrt}(1 - x^2)}.
22759
22760 If the argument to @code{sin} is negative-looking, it is simplified to
22761 @expr{-@tfn{sin}(x)}, and similarly for @code{cos} and @code{tan}.
22762 Finally, certain special values of the argument are recognized;
22763 @pxref{Trigonometric and Hyperbolic Functions}.
22764
22765 Hyperbolic functions of their inverses and of negative-looking
22766 arguments are also handled, as are exponentials of inverse
22767 hyperbolic functions.
22768
22769 No simplifications for inverse trigonometric and hyperbolic
22770 functions are known, except for negative arguments of @code{arcsin},
22771 @code{arctan}, @code{arcsinh}, and @code{arctanh}. Note that
22772 @expr{@tfn{arcsin}(@tfn{sin}(x))} can @emph{not} safely change to
22773 @expr{x}, since this only correct within an integer multiple of
22774 @texline @math{2 \pi}
22775 @infoline @expr{2 pi}
22776 radians or 360 degrees. However, @expr{@tfn{arcsinh}(@tfn{sinh}(x))} is
22777 simplified to @expr{x} if @expr{x} is known to be real.
22778
22779 Several simplifications that apply to logarithms and exponentials
22780 are that @expr{@tfn{exp}(@tfn{ln}(x))},
22781 @texline @tfn{e}@math{^{\ln(x)}},
22782 @infoline @expr{e^@tfn{ln}(x)},
22783 and
22784 @texline @math{10^{{\rm log10}(x)}}
22785 @infoline @expr{10^@tfn{log10}(x)}
22786 all reduce to @expr{x}. Also, @expr{@tfn{ln}(@tfn{exp}(x))}, etc., can
22787 reduce to @expr{x} if @expr{x} is provably real. The form
22788 @expr{@tfn{exp}(x)^y} is simplified to @expr{@tfn{exp}(x y)}. If @expr{x}
22789 is a suitable multiple of
22790 @texline @math{\pi i}
22791 @infoline @expr{pi i}
22792 (as described above for the trigonometric functions), then
22793 @expr{@tfn{exp}(x)} or @expr{e^x} will be expanded. Finally,
22794 @expr{@tfn{ln}(x)} is simplified to a form involving @code{pi} and
22795 @code{i} where @expr{x} is provably negative, positive imaginary, or
22796 negative imaginary.
22797
22798 The error functions @code{erf} and @code{erfc} are simplified when
22799 their arguments are negative-looking or are calls to the @code{conj}
22800 function.
22801
22802 @tex
22803 \bigskip
22804 @end tex
22805
22806 Equations and inequalities are simplified by cancelling factors
22807 of products, quotients, or sums on both sides. Inequalities
22808 change sign if a negative multiplicative factor is cancelled.
22809 Non-constant multiplicative factors as in @expr{a b = a c} are
22810 cancelled from equations only if they are provably nonzero (generally
22811 because they were declared so; @pxref{Declarations}). Factors
22812 are cancelled from inequalities only if they are nonzero and their
22813 sign is known.
22814
22815 Simplification also replaces an equation or inequality with
22816 1 or 0 (``true'' or ``false'') if it can through the use of
22817 declarations. If @expr{x} is declared to be an integer greater
22818 than 5, then @expr{x < 3}, @expr{x = 3}, and @expr{x = 7.5} are
22819 all simplified to 0, but @expr{x > 3} is simplified to 1.
22820 By a similar analysis, @expr{abs(x) >= 0} is simplified to 1,
22821 as is @expr{x^2 >= 0} if @expr{x} is known to be real.
22822
22823 @node Unsafe Simplifications, Simplification of Units, Algebraic Simplifications, Simplifying Formulas
22824 @subsection ``Unsafe'' Simplifications
22825
22826 @noindent
22827 @cindex Unsafe simplifications
22828 @cindex Extended simplification
22829 @kindex a e
22830 @pindex calc-simplify-extended
22831 @ignore
22832 @mindex esimpl@idots
22833 @end ignore
22834 @tindex esimplify
22835 The @kbd{a e} (@code{calc-simplify-extended}) [@code{esimplify}] command
22836 is like @kbd{a s}
22837 except that it applies some additional simplifications which are not
22838 ``safe'' in all cases. Use this only if you know the values in your
22839 formula lie in the restricted ranges for which these simplifications
22840 are valid. The symbolic integrator uses @kbd{a e};
22841 one effect of this is that the integrator's results must be used with
22842 caution. Where an integral table will often attach conditions like
22843 ``for positive @expr{a} only,'' Calc (like most other symbolic
22844 integration programs) will simply produce an unqualified result.
22845
22846 Because @kbd{a e}'s simplifications are unsafe, it is sometimes better
22847 to type @kbd{C-u -3 a v}, which does extended simplification only
22848 on the top level of the formula without affecting the sub-formulas.
22849 In fact, @kbd{C-u -3 j v} allows you to target extended simplification
22850 to any specific part of a formula.
22851
22852 The variable @code{ExtSimpRules} contains rewrites to be applied by
22853 the @kbd{a e} command. These are applied in addition to
22854 @code{EvalRules} and @code{AlgSimpRules}. (The @kbd{a r AlgSimpRules}
22855 step described above is simply followed by an @kbd{a r ExtSimpRules} step.)
22856
22857 Following is a complete list of ``unsafe'' simplifications performed
22858 by @kbd{a e}.
22859
22860 @tex
22861 \bigskip
22862 @end tex
22863
22864 Inverse trigonometric or hyperbolic functions, called with their
22865 corresponding non-inverse functions as arguments, are simplified
22866 by @kbd{a e}. For example, @expr{@tfn{arcsin}(@tfn{sin}(x))} changes
22867 to @expr{x}. Also, @expr{@tfn{arcsin}(@tfn{cos}(x))} and
22868 @expr{@tfn{arccos}(@tfn{sin}(x))} both change to @expr{@tfn{pi}/2 - x}.
22869 These simplifications are unsafe because they are valid only for
22870 values of @expr{x} in a certain range; outside that range, values
22871 are folded down to the 360-degree range that the inverse trigonometric
22872 functions always produce.
22873
22874 Powers of powers @expr{(x^a)^b} are simplified to
22875 @texline @math{x^{a b}}
22876 @infoline @expr{x^(a b)}
22877 for all @expr{a} and @expr{b}. These results will be valid only
22878 in a restricted range of @expr{x}; for example, in
22879 @texline @math{(x^2)^{1:2}}
22880 @infoline @expr{(x^2)^1:2}
22881 the powers cancel to get @expr{x}, which is valid for positive values
22882 of @expr{x} but not for negative or complex values.
22883
22884 Similarly, @expr{@tfn{sqrt}(x^a)} and @expr{@tfn{sqrt}(x)^a} are both
22885 simplified (possibly unsafely) to
22886 @texline @math{x^{a/2}}.
22887 @infoline @expr{x^(a/2)}.
22888
22889 Forms like @expr{@tfn{sqrt}(1 - sin(x)^2)} are simplified to, e.g.,
22890 @expr{@tfn{cos}(x)}. Calc has identities of this sort for @code{sin},
22891 @code{cos}, @code{tan}, @code{sinh}, and @code{cosh}.
22892
22893 Arguments of square roots are partially factored to look for
22894 squared terms that can be extracted. For example,
22895 @expr{@tfn{sqrt}(a^2 b^3 + a^3 b^2)} simplifies to
22896 @expr{a b @tfn{sqrt}(a+b)}.
22897
22898 The simplifications of @expr{@tfn{ln}(@tfn{exp}(x))},
22899 @expr{@tfn{ln}(@tfn{e}^x)}, and @expr{@tfn{log10}(10^x)} to @expr{x} are also
22900 unsafe because of problems with principal values (although these
22901 simplifications are safe if @expr{x} is known to be real).
22902
22903 Common factors are cancelled from products on both sides of an
22904 equation, even if those factors may be zero: @expr{a x / b x}
22905 to @expr{a / b}. Such factors are never cancelled from
22906 inequalities: Even @kbd{a e} is not bold enough to reduce
22907 @expr{a x < b x} to @expr{a < b} (or @expr{a > b}, depending
22908 on whether you believe @expr{x} is positive or negative).
22909 The @kbd{a M /} command can be used to divide a factor out of
22910 both sides of an inequality.
22911
22912 @node Simplification of Units, , Unsafe Simplifications, Simplifying Formulas
22913 @subsection Simplification of Units
22914
22915 @noindent
22916 The simplifications described in this section are applied by the
22917 @kbd{u s} (@code{calc-simplify-units}) command. These are in addition
22918 to the regular @kbd{a s} (but not @kbd{a e}) simplifications described
22919 earlier. @xref{Basic Operations on Units}.
22920
22921 The variable @code{UnitSimpRules} contains rewrites to be applied by
22922 the @kbd{u s} command. These are applied in addition to @code{EvalRules}
22923 and @code{AlgSimpRules}.
22924
22925 Scalar mode is automatically put into effect when simplifying units.
22926 @xref{Matrix Mode}.
22927
22928 Sums @expr{a + b} involving units are simplified by extracting the
22929 units of @expr{a} as if by the @kbd{u x} command (call the result
22930 @expr{u_a}), then simplifying the expression @expr{b / u_a}
22931 using @kbd{u b} and @kbd{u s}. If the result has units then the sum
22932 is inconsistent and is left alone. Otherwise, it is rewritten
22933 in terms of the units @expr{u_a}.
22934
22935 If units auto-ranging mode is enabled, products or quotients in
22936 which the first argument is a number which is out of range for the
22937 leading unit are modified accordingly.
22938
22939 When cancelling and combining units in products and quotients,
22940 Calc accounts for unit names that differ only in the prefix letter.
22941 For example, @samp{2 km m} is simplified to @samp{2000 m^2}.
22942 However, compatible but different units like @code{ft} and @code{in}
22943 are not combined in this way.
22944
22945 Quotients @expr{a / b} are simplified in three additional ways. First,
22946 if @expr{b} is a number or a product beginning with a number, Calc
22947 computes the reciprocal of this number and moves it to the numerator.
22948
22949 Second, for each pair of unit names from the numerator and denominator
22950 of a quotient, if the units are compatible (e.g., they are both
22951 units of area) then they are replaced by the ratio between those
22952 units. For example, in @samp{3 s in N / kg cm} the units
22953 @samp{in / cm} will be replaced by @expr{2.54}.
22954
22955 Third, if the units in the quotient exactly cancel out, so that
22956 a @kbd{u b} command on the quotient would produce a dimensionless
22957 number for an answer, then the quotient simplifies to that number.
22958
22959 For powers and square roots, the ``unsafe'' simplifications
22960 @expr{(a b)^c} to @expr{a^c b^c}, @expr{(a/b)^c} to @expr{a^c / b^c},
22961 and @expr{(a^b)^c} to
22962 @texline @math{a^{b c}}
22963 @infoline @expr{a^(b c)}
22964 are done if the powers are real numbers. (These are safe in the context
22965 of units because all numbers involved can reasonably be assumed to be
22966 real.)
22967
22968 Also, if a unit name is raised to a fractional power, and the
22969 base units in that unit name all occur to powers which are a
22970 multiple of the denominator of the power, then the unit name
22971 is expanded out into its base units, which can then be simplified
22972 according to the previous paragraph. For example, @samp{acre^1.5}
22973 is simplified by noting that @expr{1.5 = 3:2}, that @samp{acre}
22974 is defined in terms of @samp{m^2}, and that the 2 in the power of
22975 @code{m} is a multiple of 2 in @expr{3:2}. Thus, @code{acre^1.5} is
22976 replaced by approximately
22977 @texline @math{(4046 m^2)^{1.5}}
22978 @infoline @expr{(4046 m^2)^1.5},
22979 which is then changed to
22980 @texline @math{4046^{1.5} \, (m^2)^{1.5}},
22981 @infoline @expr{4046^1.5 (m^2)^1.5},
22982 then to @expr{257440 m^3}.
22983
22984 The functions @code{float}, @code{frac}, @code{clean}, @code{abs},
22985 as well as @code{floor} and the other integer truncation functions,
22986 applied to unit names or products or quotients involving units, are
22987 simplified. For example, @samp{round(1.6 in)} is changed to
22988 @samp{round(1.6) round(in)}; the lefthand term evaluates to 2,
22989 and the righthand term simplifies to @code{in}.
22990
22991 The functions @code{sin}, @code{cos}, and @code{tan} with arguments
22992 that have angular units like @code{rad} or @code{arcmin} are
22993 simplified by converting to base units (radians), then evaluating
22994 with the angular mode temporarily set to radians.
22995
22996 @node Polynomials, Calculus, Simplifying Formulas, Algebra
22997 @section Polynomials
22998
22999 A @dfn{polynomial} is a sum of terms which are coefficients times
23000 various powers of a ``base'' variable. For example, @expr{2 x^2 + 3 x - 4}
23001 is a polynomial in @expr{x}. Some formulas can be considered
23002 polynomials in several different variables: @expr{1 + 2 x + 3 y + 4 x y^2}
23003 is a polynomial in both @expr{x} and @expr{y}. Polynomial coefficients
23004 are often numbers, but they may in general be any formulas not
23005 involving the base variable.
23006
23007 @kindex a f
23008 @pindex calc-factor
23009 @tindex factor
23010 The @kbd{a f} (@code{calc-factor}) [@code{factor}] command factors a
23011 polynomial into a product of terms. For example, the polynomial
23012 @expr{x^3 + 2 x^2 + x} is factored into @samp{x*(x+1)^2}. As another
23013 example, @expr{a c + b d + b c + a d} is factored into the product
23014 @expr{(a + b) (c + d)}.
23015
23016 Calc currently has three algorithms for factoring. Formulas which are
23017 linear in several variables, such as the second example above, are
23018 merged according to the distributive law. Formulas which are
23019 polynomials in a single variable, with constant integer or fractional
23020 coefficients, are factored into irreducible linear and/or quadratic
23021 terms. The first example above factors into three linear terms
23022 (@expr{x}, @expr{x+1}, and @expr{x+1} again). Finally, formulas
23023 which do not fit the above criteria are handled by the algebraic
23024 rewrite mechanism.
23025
23026 Calc's polynomial factorization algorithm works by using the general
23027 root-finding command (@w{@kbd{a P}}) to solve for the roots of the
23028 polynomial. It then looks for roots which are rational numbers
23029 or complex-conjugate pairs, and converts these into linear and
23030 quadratic terms, respectively. Because it uses floating-point
23031 arithmetic, it may be unable to find terms that involve large
23032 integers (whose number of digits approaches the current precision).
23033 Also, irreducible factors of degree higher than quadratic are not
23034 found, and polynomials in more than one variable are not treated.
23035 (A more robust factorization algorithm may be included in a future
23036 version of Calc.)
23037
23038 @vindex FactorRules
23039 @ignore
23040 @starindex
23041 @end ignore
23042 @tindex thecoefs
23043 @ignore
23044 @starindex
23045 @end ignore
23046 @ignore
23047 @mindex @idots
23048 @end ignore
23049 @tindex thefactors
23050 The rewrite-based factorization method uses rules stored in the variable
23051 @code{FactorRules}. @xref{Rewrite Rules}, for a discussion of the
23052 operation of rewrite rules. The default @code{FactorRules} are able
23053 to factor quadratic forms symbolically into two linear terms,
23054 @expr{(a x + b) (c x + d)}. You can edit these rules to include other
23055 cases if you wish. To use the rules, Calc builds the formula
23056 @samp{thecoefs(x, [a, b, c, ...])} where @code{x} is the polynomial
23057 base variable and @code{a}, @code{b}, etc., are polynomial coefficients
23058 (which may be numbers or formulas). The constant term is written first,
23059 i.e., in the @code{a} position. When the rules complete, they should have
23060 changed the formula into the form @samp{thefactors(x, [f1, f2, f3, ...])}
23061 where each @code{fi} should be a factored term, e.g., @samp{x - ai}.
23062 Calc then multiplies these terms together to get the complete
23063 factored form of the polynomial. If the rules do not change the
23064 @code{thecoefs} call to a @code{thefactors} call, @kbd{a f} leaves the
23065 polynomial alone on the assumption that it is unfactorable. (Note that
23066 the function names @code{thecoefs} and @code{thefactors} are used only
23067 as placeholders; there are no actual Calc functions by those names.)
23068
23069 @kindex H a f
23070 @tindex factors
23071 The @kbd{H a f} [@code{factors}] command also factors a polynomial,
23072 but it returns a list of factors instead of an expression which is the
23073 product of the factors. Each factor is represented by a sub-vector
23074 of the factor, and the power with which it appears. For example,
23075 @expr{x^5 + x^4 - 33 x^3 + 63 x^2} factors to @expr{(x + 7) x^2 (x - 3)^2}
23076 in @kbd{a f}, or to @expr{[ [x, 2], [x+7, 1], [x-3, 2] ]} in @kbd{H a f}.
23077 If there is an overall numeric factor, it always comes first in the list.
23078 The functions @code{factor} and @code{factors} allow a second argument
23079 when written in algebraic form; @samp{factor(x,v)} factors @expr{x} with
23080 respect to the specific variable @expr{v}. The default is to factor with
23081 respect to all the variables that appear in @expr{x}.
23082
23083 @kindex a c
23084 @pindex calc-collect
23085 @tindex collect
23086 The @kbd{a c} (@code{calc-collect}) [@code{collect}] command rearranges a
23087 formula as a
23088 polynomial in a given variable, ordered in decreasing powers of that
23089 variable. For example, given @expr{1 + 2 x + 3 y + 4 x y^2} on
23090 the stack, @kbd{a c x} would produce @expr{(2 + 4 y^2) x + (1 + 3 y)},
23091 and @kbd{a c y} would produce @expr{(4 x) y^2 + 3 y + (1 + 2 x)}.
23092 The polynomial will be expanded out using the distributive law as
23093 necessary: Collecting @expr{x} in @expr{(x - 1)^3} produces
23094 @expr{x^3 - 3 x^2 + 3 x - 1}. Terms not involving @expr{x} will
23095 not be expanded.
23096
23097 The ``variable'' you specify at the prompt can actually be any
23098 expression: @kbd{a c ln(x+1)} will collect together all terms multiplied
23099 by @samp{ln(x+1)} or integer powers thereof. If @samp{x} also appears
23100 in the formula in a context other than @samp{ln(x+1)}, @kbd{a c} will
23101 treat those occurrences as unrelated to @samp{ln(x+1)}, i.e., as constants.
23102
23103 @kindex a x
23104 @pindex calc-expand
23105 @tindex expand
23106 The @kbd{a x} (@code{calc-expand}) [@code{expand}] command expands an
23107 expression by applying the distributive law everywhere. It applies to
23108 products, quotients, and powers involving sums. By default, it fully
23109 distributes all parts of the expression. With a numeric prefix argument,
23110 the distributive law is applied only the specified number of times, then
23111 the partially expanded expression is left on the stack.
23112
23113 The @kbd{a x} and @kbd{j D} commands are somewhat redundant. Use
23114 @kbd{a x} if you want to expand all products of sums in your formula.
23115 Use @kbd{j D} if you want to expand a particular specified term of
23116 the formula. There is an exactly analogous correspondence between
23117 @kbd{a f} and @kbd{j M}. (The @kbd{j D} and @kbd{j M} commands
23118 also know many other kinds of expansions, such as
23119 @samp{exp(a + b) = exp(a) exp(b)}, which @kbd{a x} and @kbd{a f}
23120 do not do.)
23121
23122 Calc's automatic simplifications will sometimes reverse a partial
23123 expansion. For example, the first step in expanding @expr{(x+1)^3} is
23124 to write @expr{(x+1) (x+1)^2}. If @kbd{a x} stops there and tries
23125 to put this formula onto the stack, though, Calc will automatically
23126 simplify it back to @expr{(x+1)^3} form. The solution is to turn
23127 simplification off first (@pxref{Simplification Modes}), or to run
23128 @kbd{a x} without a numeric prefix argument so that it expands all
23129 the way in one step.
23130
23131 @kindex a a
23132 @pindex calc-apart
23133 @tindex apart
23134 The @kbd{a a} (@code{calc-apart}) [@code{apart}] command expands a
23135 rational function by partial fractions. A rational function is the
23136 quotient of two polynomials; @code{apart} pulls this apart into a
23137 sum of rational functions with simple denominators. In algebraic
23138 notation, the @code{apart} function allows a second argument that
23139 specifies which variable to use as the ``base''; by default, Calc
23140 chooses the base variable automatically.
23141
23142 @kindex a n
23143 @pindex calc-normalize-rat
23144 @tindex nrat
23145 The @kbd{a n} (@code{calc-normalize-rat}) [@code{nrat}] command
23146 attempts to arrange a formula into a quotient of two polynomials.
23147 For example, given @expr{1 + (a + b/c) / d}, the result would be
23148 @expr{(b + a c + c d) / c d}. The quotient is reduced, so that
23149 @kbd{a n} will simplify @expr{(x^2 + 2x + 1) / (x^2 - 1)} by dividing
23150 out the common factor @expr{x + 1}, yielding @expr{(x + 1) / (x - 1)}.
23151
23152 @kindex a \
23153 @pindex calc-poly-div
23154 @tindex pdiv
23155 The @kbd{a \} (@code{calc-poly-div}) [@code{pdiv}] command divides
23156 two polynomials @expr{u} and @expr{v}, yielding a new polynomial
23157 @expr{q}. If several variables occur in the inputs, the inputs are
23158 considered multivariate polynomials. (Calc divides by the variable
23159 with the largest power in @expr{u} first, or, in the case of equal
23160 powers, chooses the variables in alphabetical order.) For example,
23161 dividing @expr{x^2 + 3 x + 2} by @expr{x + 2} yields @expr{x + 1}.
23162 The remainder from the division, if any, is reported at the bottom
23163 of the screen and is also placed in the Trail along with the quotient.
23164
23165 Using @code{pdiv} in algebraic notation, you can specify the particular
23166 variable to be used as the base: @code{pdiv(@var{a},@var{b},@var{x})}.
23167 If @code{pdiv} is given only two arguments (as is always the case with
23168 the @kbd{a \} command), then it does a multivariate division as outlined
23169 above.
23170
23171 @kindex a %
23172 @pindex calc-poly-rem
23173 @tindex prem
23174 The @kbd{a %} (@code{calc-poly-rem}) [@code{prem}] command divides
23175 two polynomials and keeps the remainder @expr{r}. The quotient
23176 @expr{q} is discarded. For any formulas @expr{a} and @expr{b}, the
23177 results of @kbd{a \} and @kbd{a %} satisfy @expr{a = q b + r}.
23178 (This is analogous to plain @kbd{\} and @kbd{%}, which compute the
23179 integer quotient and remainder from dividing two numbers.)
23180
23181 @kindex a /
23182 @kindex H a /
23183 @pindex calc-poly-div-rem
23184 @tindex pdivrem
23185 @tindex pdivide
23186 The @kbd{a /} (@code{calc-poly-div-rem}) [@code{pdivrem}] command
23187 divides two polynomials and reports both the quotient and the
23188 remainder as a vector @expr{[q, r]}. The @kbd{H a /} [@code{pdivide}]
23189 command divides two polynomials and constructs the formula
23190 @expr{q + r/b} on the stack. (Naturally if the remainder is zero,
23191 this will immediately simplify to @expr{q}.)
23192
23193 @kindex a g
23194 @pindex calc-poly-gcd
23195 @tindex pgcd
23196 The @kbd{a g} (@code{calc-poly-gcd}) [@code{pgcd}] command computes
23197 the greatest common divisor of two polynomials. (The GCD actually
23198 is unique only to within a constant multiplier; Calc attempts to
23199 choose a GCD which will be unsurprising.) For example, the @kbd{a n}
23200 command uses @kbd{a g} to take the GCD of the numerator and denominator
23201 of a quotient, then divides each by the result using @kbd{a \}. (The
23202 definition of GCD ensures that this division can take place without
23203 leaving a remainder.)
23204
23205 While the polynomials used in operations like @kbd{a /} and @kbd{a g}
23206 often have integer coefficients, this is not required. Calc can also
23207 deal with polynomials over the rationals or floating-point reals.
23208 Polynomials with modulo-form coefficients are also useful in many
23209 applications; if you enter @samp{(x^2 + 3 x - 1) mod 5}, Calc
23210 automatically transforms this into a polynomial over the field of
23211 integers mod 5: @samp{(1 mod 5) x^2 + (3 mod 5) x + (4 mod 5)}.
23212
23213 Congratulations and thanks go to Ove Ewerlid
23214 (@code{ewerlid@@mizar.DoCS.UU.SE}), who contributed many of the
23215 polynomial routines used in the above commands.
23216
23217 @xref{Decomposing Polynomials}, for several useful functions for
23218 extracting the individual coefficients of a polynomial.
23219
23220 @node Calculus, Solving Equations, Polynomials, Algebra
23221 @section Calculus
23222
23223 @noindent
23224 The following calculus commands do not automatically simplify their
23225 inputs or outputs using @code{calc-simplify}. You may find it helps
23226 to do this by hand by typing @kbd{a s} or @kbd{a e}. It may also help
23227 to use @kbd{a x} and/or @kbd{a c} to arrange a result in the most
23228 readable way.
23229
23230 @menu
23231 * Differentiation::
23232 * Integration::
23233 * Customizing the Integrator::
23234 * Numerical Integration::
23235 * Taylor Series::
23236 @end menu
23237
23238 @node Differentiation, Integration, Calculus, Calculus
23239 @subsection Differentiation
23240
23241 @noindent
23242 @kindex a d
23243 @kindex H a d
23244 @pindex calc-derivative
23245 @tindex deriv
23246 @tindex tderiv
23247 The @kbd{a d} (@code{calc-derivative}) [@code{deriv}] command computes
23248 the derivative of the expression on the top of the stack with respect to
23249 some variable, which it will prompt you to enter. Normally, variables
23250 in the formula other than the specified differentiation variable are
23251 considered constant, i.e., @samp{deriv(y,x)} is reduced to zero. With
23252 the Hyperbolic flag, the @code{tderiv} (total derivative) operation is used
23253 instead, in which derivatives of variables are not reduced to zero
23254 unless those variables are known to be ``constant,'' i.e., independent
23255 of any other variables. (The built-in special variables like @code{pi}
23256 are considered constant, as are variables that have been declared
23257 @code{const}; @pxref{Declarations}.)
23258
23259 With a numeric prefix argument @var{n}, this command computes the
23260 @var{n}th derivative.
23261
23262 When working with trigonometric functions, it is best to switch to
23263 Radians mode first (with @w{@kbd{m r}}). The derivative of @samp{sin(x)}
23264 in degrees is @samp{(pi/180) cos(x)}, probably not the expected
23265 answer!
23266
23267 If you use the @code{deriv} function directly in an algebraic formula,
23268 you can write @samp{deriv(f,x,x0)} which represents the derivative
23269 of @expr{f} with respect to @expr{x}, evaluated at the point
23270 @texline @math{x=x_0}.
23271 @infoline @expr{x=x0}.
23272
23273 If the formula being differentiated contains functions which Calc does
23274 not know, the derivatives of those functions are produced by adding
23275 primes (apostrophe characters). For example, @samp{deriv(f(2x), x)}
23276 produces @samp{2 f'(2 x)}, where the function @code{f'} represents the
23277 derivative of @code{f}.
23278
23279 For functions you have defined with the @kbd{Z F} command, Calc expands
23280 the functions according to their defining formulas unless you have
23281 also defined @code{f'} suitably. For example, suppose we define
23282 @samp{sinc(x) = sin(x)/x} using @kbd{Z F}. If we then differentiate
23283 the formula @samp{sinc(2 x)}, the formula will be expanded to
23284 @samp{sin(2 x) / (2 x)} and differentiated. However, if we also
23285 define @samp{sinc'(x) = dsinc(x)}, say, then Calc will write the
23286 result as @samp{2 dsinc(2 x)}. @xref{Algebraic Definitions}.
23287
23288 For multi-argument functions @samp{f(x,y,z)}, the derivative with respect
23289 to the first argument is written @samp{f'(x,y,z)}; derivatives with
23290 respect to the other arguments are @samp{f'2(x,y,z)} and @samp{f'3(x,y,z)}.
23291 Various higher-order derivatives can be formed in the obvious way, e.g.,
23292 @samp{f'@var{}'(x)} (the second derivative of @code{f}) or
23293 @samp{f'@var{}'2'3(x,y,z)} (@code{f} differentiated with respect to each
23294 argument once).
23295
23296 @node Integration, Customizing the Integrator, Differentiation, Calculus
23297 @subsection Integration
23298
23299 @noindent
23300 @kindex a i
23301 @pindex calc-integral
23302 @tindex integ
23303 The @kbd{a i} (@code{calc-integral}) [@code{integ}] command computes the
23304 indefinite integral of the expression on the top of the stack with
23305 respect to a variable. The integrator is not guaranteed to work for
23306 all integrable functions, but it is able to integrate several large
23307 classes of formulas. In particular, any polynomial or rational function
23308 (a polynomial divided by a polynomial) is acceptable. (Rational functions
23309 don't have to be in explicit quotient form, however;
23310 @texline @math{x/(1+x^{-2})}
23311 @infoline @expr{x/(1+x^-2)}
23312 is not strictly a quotient of polynomials, but it is equivalent to
23313 @expr{x^3/(x^2+1)}, which is.) Also, square roots of terms involving
23314 @expr{x} and @expr{x^2} may appear in rational functions being
23315 integrated. Finally, rational functions involving trigonometric or
23316 hyperbolic functions can be integrated.
23317
23318 @ifinfo
23319 If you use the @code{integ} function directly in an algebraic formula,
23320 you can also write @samp{integ(f,x,v)} which expresses the resulting
23321 indefinite integral in terms of variable @code{v} instead of @code{x}.
23322 With four arguments, @samp{integ(f(x),x,a,b)} represents a definite
23323 integral from @code{a} to @code{b}.
23324 @end ifinfo
23325 @tex
23326 If you use the @code{integ} function directly in an algebraic formula,
23327 you can also write @samp{integ(f,x,v)} which expresses the resulting
23328 indefinite integral in terms of variable @code{v} instead of @code{x}.
23329 With four arguments, @samp{integ(f(x),x,a,b)} represents a definite
23330 integral $\int_a^b f(x) \, dx$.
23331 @end tex
23332
23333 Please note that the current implementation of Calc's integrator sometimes
23334 produces results that are significantly more complex than they need to
23335 be. For example, the integral Calc finds for
23336 @texline @math{1/(x+\sqrt{x^2+1})}
23337 @infoline @expr{1/(x+sqrt(x^2+1))}
23338 is several times more complicated than the answer Mathematica
23339 returns for the same input, although the two forms are numerically
23340 equivalent. Also, any indefinite integral should be considered to have
23341 an arbitrary constant of integration added to it, although Calc does not
23342 write an explicit constant of integration in its result. For example,
23343 Calc's solution for
23344 @texline @math{1/(1+\tan x)}
23345 @infoline @expr{1/(1+tan(x))}
23346 differs from the solution given in the @emph{CRC Math Tables} by a
23347 constant factor of
23348 @texline @math{\pi i / 2}
23349 @infoline @expr{pi i / 2},
23350 due to a different choice of constant of integration.
23351
23352 The Calculator remembers all the integrals it has done. If conditions
23353 change in a way that would invalidate the old integrals, say, a switch
23354 from Degrees to Radians mode, then they will be thrown out. If you
23355 suspect this is not happening when it should, use the
23356 @code{calc-flush-caches} command; @pxref{Caches}.
23357
23358 @vindex IntegLimit
23359 Calc normally will pursue integration by substitution or integration by
23360 parts up to 3 nested times before abandoning an approach as fruitless.
23361 If the integrator is taking too long, you can lower this limit by storing
23362 a number (like 2) in the variable @code{IntegLimit}. (The @kbd{s I}
23363 command is a convenient way to edit @code{IntegLimit}.) If this variable
23364 has no stored value or does not contain a nonnegative integer, a limit
23365 of 3 is used. The lower this limit is, the greater the chance that Calc
23366 will be unable to integrate a function it could otherwise handle. Raising
23367 this limit allows the Calculator to solve more integrals, though the time
23368 it takes may grow exponentially. You can monitor the integrator's actions
23369 by creating an Emacs buffer called @code{*Trace*}. If such a buffer
23370 exists, the @kbd{a i} command will write a log of its actions there.
23371
23372 If you want to manipulate integrals in a purely symbolic way, you can
23373 set the integration nesting limit to 0 to prevent all but fast
23374 table-lookup solutions of integrals. You might then wish to define
23375 rewrite rules for integration by parts, various kinds of substitutions,
23376 and so on. @xref{Rewrite Rules}.
23377
23378 @node Customizing the Integrator, Numerical Integration, Integration, Calculus
23379 @subsection Customizing the Integrator
23380
23381 @noindent
23382 @vindex IntegRules
23383 Calc has two built-in rewrite rules called @code{IntegRules} and
23384 @code{IntegAfterRules} which you can edit to define new integration
23385 methods. @xref{Rewrite Rules}. At each step of the integration process,
23386 Calc wraps the current integrand in a call to the fictitious function
23387 @samp{integtry(@var{expr},@var{var})}, where @var{expr} is the
23388 integrand and @var{var} is the integration variable. If your rules
23389 rewrite this to be a plain formula (not a call to @code{integtry}), then
23390 Calc will use this formula as the integral of @var{expr}. For example,
23391 the rule @samp{integtry(mysin(x),x) := -mycos(x)} would define a rule to
23392 integrate a function @code{mysin} that acts like the sine function.
23393 Then, putting @samp{4 mysin(2y+1)} on the stack and typing @kbd{a i y}
23394 will produce the integral @samp{-2 mycos(2y+1)}. Note that Calc has
23395 automatically made various transformations on the integral to allow it
23396 to use your rule; integral tables generally give rules for
23397 @samp{mysin(a x + b)}, but you don't need to use this much generality
23398 in your @code{IntegRules}.
23399
23400 @cindex Exponential integral Ei(x)
23401 @ignore
23402 @starindex
23403 @end ignore
23404 @tindex Ei
23405 As a more serious example, the expression @samp{exp(x)/x} cannot be
23406 integrated in terms of the standard functions, so the ``exponential
23407 integral'' function
23408 @texline @math{{\rm Ei}(x)}
23409 @infoline @expr{Ei(x)}
23410 was invented to describe it.
23411 We can get Calc to do this integral in terms of a made-up @code{Ei}
23412 function by adding the rule @samp{[integtry(exp(x)/x, x) := Ei(x)]}
23413 to @code{IntegRules}. Now entering @samp{exp(2x)/x} on the stack
23414 and typing @kbd{a i x} yields @samp{Ei(2 x)}. This new rule will
23415 work with Calc's various built-in integration methods (such as
23416 integration by substitution) to solve a variety of other problems
23417 involving @code{Ei}: For example, now Calc will also be able to
23418 integrate @samp{exp(exp(x))} and @samp{ln(ln(x))} (to get @samp{Ei(exp(x))}
23419 and @samp{x ln(ln(x)) - Ei(ln(x))}, respectively).
23420
23421 Your rule may do further integration by calling @code{integ}. For
23422 example, @samp{integtry(twice(u),x) := twice(integ(u))} allows Calc
23423 to integrate @samp{twice(sin(x))} to get @samp{twice(-cos(x))}.
23424 Note that @code{integ} was called with only one argument. This notation
23425 is allowed only within @code{IntegRules}; it means ``integrate this
23426 with respect to the same integration variable.'' If Calc is unable
23427 to integrate @code{u}, the integration that invoked @code{IntegRules}
23428 also fails. Thus integrating @samp{twice(f(x))} fails, returning the
23429 unevaluated integral @samp{integ(twice(f(x)), x)}. It is still valid
23430 to call @code{integ} with two or more arguments, however; in this case,
23431 if @code{u} is not integrable, @code{twice} itself will still be
23432 integrated: If the above rule is changed to @samp{... := twice(integ(u,x))},
23433 then integrating @samp{twice(f(x))} will yield @samp{twice(integ(f(x),x))}.
23434
23435 If a rule instead produces the formula @samp{integsubst(@var{sexpr},
23436 @var{svar})}, either replacing the top-level @code{integtry} call or
23437 nested anywhere inside the expression, then Calc will apply the
23438 substitution @samp{@var{u} = @var{sexpr}(@var{svar})} to try to
23439 integrate the original @var{expr}. For example, the rule
23440 @samp{sqrt(a) := integsubst(sqrt(x),x)} says that if Calc ever finds
23441 a square root in the integrand, it should attempt the substitution
23442 @samp{u = sqrt(x)}. (This particular rule is unnecessary because
23443 Calc always tries ``obvious'' substitutions where @var{sexpr} actually
23444 appears in the integrand.) The variable @var{svar} may be the same
23445 as the @var{var} that appeared in the call to @code{integtry}, but
23446 it need not be.
23447
23448 When integrating according to an @code{integsubst}, Calc uses the
23449 equation solver to find the inverse of @var{sexpr} (if the integrand
23450 refers to @var{var} anywhere except in subexpressions that exactly
23451 match @var{sexpr}). It uses the differentiator to find the derivative
23452 of @var{sexpr} and/or its inverse (it has two methods that use one
23453 derivative or the other). You can also specify these items by adding
23454 extra arguments to the @code{integsubst} your rules construct; the
23455 general form is @samp{integsubst(@var{sexpr}, @var{svar}, @var{sinv},
23456 @var{sprime})}, where @var{sinv} is the inverse of @var{sexpr} (still
23457 written as a function of @var{svar}), and @var{sprime} is the
23458 derivative of @var{sexpr} with respect to @var{svar}. If you don't
23459 specify these things, and Calc is not able to work them out on its
23460 own with the information it knows, then your substitution rule will
23461 work only in very specific, simple cases.
23462
23463 Calc applies @code{IntegRules} as if by @kbd{C-u 1 a r IntegRules};
23464 in other words, Calc stops rewriting as soon as any rule in your rule
23465 set succeeds. (If it weren't for this, the @samp{integsubst(sqrt(x),x)}
23466 example above would keep on adding layers of @code{integsubst} calls
23467 forever!)
23468
23469 @vindex IntegSimpRules
23470 Another set of rules, stored in @code{IntegSimpRules}, are applied
23471 every time the integrator uses @kbd{a s} to simplify an intermediate
23472 result. For example, putting the rule @samp{twice(x) := 2 x} into
23473 @code{IntegSimpRules} would tell Calc to convert the @code{twice}
23474 function into a form it knows whenever integration is attempted.
23475
23476 One more way to influence the integrator is to define a function with
23477 the @kbd{Z F} command (@pxref{Algebraic Definitions}). Calc's
23478 integrator automatically expands such functions according to their
23479 defining formulas, even if you originally asked for the function to
23480 be left unevaluated for symbolic arguments. (Certain other Calc
23481 systems, such as the differentiator and the equation solver, also
23482 do this.)
23483
23484 @vindex IntegAfterRules
23485 Sometimes Calc is able to find a solution to your integral, but it
23486 expresses the result in a way that is unnecessarily complicated. If
23487 this happens, you can either use @code{integsubst} as described
23488 above to try to hint at a more direct path to the desired result, or
23489 you can use @code{IntegAfterRules}. This is an extra rule set that
23490 runs after the main integrator returns its result; basically, Calc does
23491 an @kbd{a r IntegAfterRules} on the result before showing it to you.
23492 (It also does an @kbd{a s}, without @code{IntegSimpRules}, after that
23493 to further simplify the result.) For example, Calc's integrator
23494 sometimes produces expressions of the form @samp{ln(1+x) - ln(1-x)};
23495 the default @code{IntegAfterRules} rewrite this into the more readable
23496 form @samp{2 arctanh(x)}. Note that, unlike @code{IntegRules},
23497 @code{IntegSimpRules} and @code{IntegAfterRules} are applied any number
23498 of times until no further changes are possible. Rewriting by
23499 @code{IntegAfterRules} occurs only after the main integrator has
23500 finished, not at every step as for @code{IntegRules} and
23501 @code{IntegSimpRules}.
23502
23503 @node Numerical Integration, Taylor Series, Customizing the Integrator, Calculus
23504 @subsection Numerical Integration
23505
23506 @noindent
23507 @kindex a I
23508 @pindex calc-num-integral
23509 @tindex ninteg
23510 If you want a purely numerical answer to an integration problem, you can
23511 use the @kbd{a I} (@code{calc-num-integral}) [@code{ninteg}] command. This
23512 command prompts for an integration variable, a lower limit, and an
23513 upper limit. Except for the integration variable, all other variables
23514 that appear in the integrand formula must have stored values. (A stored
23515 value, if any, for the integration variable itself is ignored.)
23516
23517 Numerical integration works by evaluating your formula at many points in
23518 the specified interval. Calc uses an ``open Romberg'' method; this means
23519 that it does not evaluate the formula actually at the endpoints (so that
23520 it is safe to integrate @samp{sin(x)/x} from zero, for example). Also,
23521 the Romberg method works especially well when the function being
23522 integrated is fairly smooth. If the function is not smooth, Calc will
23523 have to evaluate it at quite a few points before it can accurately
23524 determine the value of the integral.
23525
23526 Integration is much faster when the current precision is small. It is
23527 best to set the precision to the smallest acceptable number of digits
23528 before you use @kbd{a I}. If Calc appears to be taking too long, press
23529 @kbd{C-g} to halt it and try a lower precision. If Calc still appears
23530 to need hundreds of evaluations, check to make sure your function is
23531 well-behaved in the specified interval.
23532
23533 It is possible for the lower integration limit to be @samp{-inf} (minus
23534 infinity). Likewise, the upper limit may be plus infinity. Calc
23535 internally transforms the integral into an equivalent one with finite
23536 limits. However, integration to or across singularities is not supported:
23537 The integral of @samp{1/sqrt(x)} from 0 to 1 exists (it can be found
23538 by Calc's symbolic integrator, for example), but @kbd{a I} will fail
23539 because the integrand goes to infinity at one of the endpoints.
23540
23541 @node Taylor Series, , Numerical Integration, Calculus
23542 @subsection Taylor Series
23543
23544 @noindent
23545 @kindex a t
23546 @pindex calc-taylor
23547 @tindex taylor
23548 The @kbd{a t} (@code{calc-taylor}) [@code{taylor}] command computes a
23549 power series expansion or Taylor series of a function. You specify the
23550 variable and the desired number of terms. You may give an expression of
23551 the form @samp{@var{var} = @var{a}} or @samp{@var{var} - @var{a}} instead
23552 of just a variable to produce a Taylor expansion about the point @var{a}.
23553 You may specify the number of terms with a numeric prefix argument;
23554 otherwise the command will prompt you for the number of terms. Note that
23555 many series expansions have coefficients of zero for some terms, so you
23556 may appear to get fewer terms than you asked for.
23557
23558 If the @kbd{a i} command is unable to find a symbolic integral for a
23559 function, you can get an approximation by integrating the function's
23560 Taylor series.
23561
23562 @node Solving Equations, Numerical Solutions, Calculus, Algebra
23563 @section Solving Equations
23564
23565 @noindent
23566 @kindex a S
23567 @pindex calc-solve-for
23568 @tindex solve
23569 @cindex Equations, solving
23570 @cindex Solving equations
23571 The @kbd{a S} (@code{calc-solve-for}) [@code{solve}] command rearranges
23572 an equation to solve for a specific variable. An equation is an
23573 expression of the form @expr{L = R}. For example, the command @kbd{a S x}
23574 will rearrange @expr{y = 3x + 6} to the form, @expr{x = y/3 - 2}. If the
23575 input is not an equation, it is treated like an equation of the
23576 form @expr{X = 0}.
23577
23578 This command also works for inequalities, as in @expr{y < 3x + 6}.
23579 Some inequalities cannot be solved where the analogous equation could
23580 be; for example, solving
23581 @texline @math{a < b \, c}
23582 @infoline @expr{a < b c}
23583 for @expr{b} is impossible
23584 without knowing the sign of @expr{c}. In this case, @kbd{a S} will
23585 produce the result
23586 @texline @math{b \mathbin{\hbox{\code{!=}}} a/c}
23587 @infoline @expr{b != a/c}
23588 (using the not-equal-to operator) to signify that the direction of the
23589 inequality is now unknown. The inequality
23590 @texline @math{a \le b \, c}
23591 @infoline @expr{a <= b c}
23592 is not even partially solved. @xref{Declarations}, for a way to tell
23593 Calc that the signs of the variables in a formula are in fact known.
23594
23595 Two useful commands for working with the result of @kbd{a S} are
23596 @kbd{a .} (@pxref{Logical Operations}), which converts @expr{x = y/3 - 2}
23597 to @expr{y/3 - 2}, and @kbd{s l} (@pxref{Let Command}) which evaluates
23598 another formula with @expr{x} set equal to @expr{y/3 - 2}.
23599
23600 @menu
23601 * Multiple Solutions::
23602 * Solving Systems of Equations::
23603 * Decomposing Polynomials::
23604 @end menu
23605
23606 @node Multiple Solutions, Solving Systems of Equations, Solving Equations, Solving Equations
23607 @subsection Multiple Solutions
23608
23609 @noindent
23610 @kindex H a S
23611 @tindex fsolve
23612 Some equations have more than one solution. The Hyperbolic flag
23613 (@code{H a S}) [@code{fsolve}] tells the solver to report the fully
23614 general family of solutions. It will invent variables @code{n1},
23615 @code{n2}, @dots{}, which represent independent arbitrary integers, and
23616 @code{s1}, @code{s2}, @dots{}, which represent independent arbitrary
23617 signs (either @mathit{+1} or @mathit{-1}). If you don't use the Hyperbolic
23618 flag, Calc will use zero in place of all arbitrary integers, and plus
23619 one in place of all arbitrary signs. Note that variables like @code{n1}
23620 and @code{s1} are not given any special interpretation in Calc except by
23621 the equation solver itself. As usual, you can use the @w{@kbd{s l}}
23622 (@code{calc-let}) command to obtain solutions for various actual values
23623 of these variables.
23624
23625 For example, @kbd{' x^2 = y @key{RET} H a S x @key{RET}} solves to
23626 get @samp{x = s1 sqrt(y)}, indicating that the two solutions to the
23627 equation are @samp{sqrt(y)} and @samp{-sqrt(y)}. Another way to
23628 think about it is that the square-root operation is really a
23629 two-valued function; since every Calc function must return a
23630 single result, @code{sqrt} chooses to return the positive result.
23631 Then @kbd{H a S} doctors this result using @code{s1} to indicate
23632 the full set of possible values of the mathematical square-root.
23633
23634 There is a similar phenomenon going the other direction: Suppose
23635 we solve @samp{sqrt(y) = x} for @code{y}. Calc squares both sides
23636 to get @samp{y = x^2}. This is correct, except that it introduces
23637 some dubious solutions. Consider solving @samp{sqrt(y) = -3}:
23638 Calc will report @expr{y = 9} as a valid solution, which is true
23639 in the mathematical sense of square-root, but false (there is no
23640 solution) for the actual Calc positive-valued @code{sqrt}. This
23641 happens for both @kbd{a S} and @kbd{H a S}.
23642
23643 @cindex @code{GenCount} variable
23644 @vindex GenCount
23645 @ignore
23646 @starindex
23647 @end ignore
23648 @tindex an
23649 @ignore
23650 @starindex
23651 @end ignore
23652 @tindex as
23653 If you store a positive integer in the Calc variable @code{GenCount},
23654 then Calc will generate formulas of the form @samp{as(@var{n})} for
23655 arbitrary signs, and @samp{an(@var{n})} for arbitrary integers,
23656 where @var{n} represents successive values taken by incrementing
23657 @code{GenCount} by one. While the normal arbitrary sign and
23658 integer symbols start over at @code{s1} and @code{n1} with each
23659 new Calc command, the @code{GenCount} approach will give each
23660 arbitrary value a name that is unique throughout the entire Calc
23661 session. Also, the arbitrary values are function calls instead
23662 of variables, which is advantageous in some cases. For example,
23663 you can make a rewrite rule that recognizes all arbitrary signs
23664 using a pattern like @samp{as(n)}. The @kbd{s l} command only works
23665 on variables, but you can use the @kbd{a b} (@code{calc-substitute})
23666 command to substitute actual values for function calls like @samp{as(3)}.
23667
23668 The @kbd{s G} (@code{calc-edit-GenCount}) command is a convenient
23669 way to create or edit this variable. Press @kbd{C-c C-c} to finish.
23670
23671 If you have not stored a value in @code{GenCount}, or if the value
23672 in that variable is not a positive integer, the regular
23673 @code{s1}/@code{n1} notation is used.
23674
23675 @kindex I a S
23676 @kindex H I a S
23677 @tindex finv
23678 @tindex ffinv
23679 With the Inverse flag, @kbd{I a S} [@code{finv}] treats the expression
23680 on top of the stack as a function of the specified variable and solves
23681 to find the inverse function, written in terms of the same variable.
23682 For example, @kbd{I a S x} inverts @expr{2x + 6} to @expr{x/2 - 3}.
23683 You can use both Inverse and Hyperbolic [@code{ffinv}] to obtain a
23684 fully general inverse, as described above.
23685
23686 @kindex a P
23687 @pindex calc-poly-roots
23688 @tindex roots
23689 Some equations, specifically polynomials, have a known, finite number
23690 of solutions. The @kbd{a P} (@code{calc-poly-roots}) [@code{roots}]
23691 command uses @kbd{H a S} to solve an equation in general form, then, for
23692 all arbitrary-sign variables like @code{s1}, and all arbitrary-integer
23693 variables like @code{n1} for which @code{n1} only usefully varies over
23694 a finite range, it expands these variables out to all their possible
23695 values. The results are collected into a vector, which is returned.
23696 For example, @samp{roots(x^4 = 1, x)} returns the four solutions
23697 @samp{[1, -1, (0, 1), (0, -1)]}. Generally an @var{n}th degree
23698 polynomial will always have @var{n} roots on the complex plane.
23699 (If you have given a @code{real} declaration for the solution
23700 variable, then only the real-valued solutions, if any, will be
23701 reported; @pxref{Declarations}.)
23702
23703 Note that because @kbd{a P} uses @kbd{H a S}, it is able to deliver
23704 symbolic solutions if the polynomial has symbolic coefficients. Also
23705 note that Calc's solver is not able to get exact symbolic solutions
23706 to all polynomials. Polynomials containing powers up to @expr{x^4}
23707 can always be solved exactly; polynomials of higher degree sometimes
23708 can be: @expr{x^6 + x^3 + 1} is converted to @expr{(x^3)^2 + (x^3) + 1},
23709 which can be solved for @expr{x^3} using the quadratic equation, and then
23710 for @expr{x} by taking cube roots. But in many cases, like
23711 @expr{x^6 + x + 1}, Calc does not know how to rewrite the polynomial
23712 into a form it can solve. The @kbd{a P} command can still deliver a
23713 list of numerical roots, however, provided that Symbolic mode (@kbd{m s})
23714 is not turned on. (If you work with Symbolic mode on, recall that the
23715 @kbd{N} (@code{calc-eval-num}) key is a handy way to reevaluate the
23716 formula on the stack with Symbolic mode temporarily off.) Naturally,
23717 @kbd{a P} can only provide numerical roots if the polynomial coefficients
23718 are all numbers (real or complex).
23719
23720 @node Solving Systems of Equations, Decomposing Polynomials, Multiple Solutions, Solving Equations
23721 @subsection Solving Systems of Equations
23722
23723 @noindent
23724 @cindex Systems of equations, symbolic
23725 You can also use the commands described above to solve systems of
23726 simultaneous equations. Just create a vector of equations, then
23727 specify a vector of variables for which to solve. (You can omit
23728 the surrounding brackets when entering the vector of variables
23729 at the prompt.)
23730
23731 For example, putting @samp{[x + y = a, x - y = b]} on the stack
23732 and typing @kbd{a S x,y @key{RET}} produces the vector of solutions
23733 @samp{[x = a - (a-b)/2, y = (a-b)/2]}. The result vector will
23734 have the same length as the variables vector, and the variables
23735 will be listed in the same order there. Note that the solutions
23736 are not always simplified as far as possible; the solution for
23737 @expr{x} here could be improved by an application of the @kbd{a n}
23738 command.
23739
23740 Calc's algorithm works by trying to eliminate one variable at a
23741 time by solving one of the equations for that variable and then
23742 substituting into the other equations. Calc will try all the
23743 possibilities, but you can speed things up by noting that Calc
23744 first tries to eliminate the first variable with the first
23745 equation, then the second variable with the second equation,
23746 and so on. It also helps to put the simpler (e.g., more linear)
23747 equations toward the front of the list. Calc's algorithm will
23748 solve any system of linear equations, and also many kinds of
23749 nonlinear systems.
23750
23751 @ignore
23752 @starindex
23753 @end ignore
23754 @tindex elim
23755 Normally there will be as many variables as equations. If you
23756 give fewer variables than equations (an ``over-determined'' system
23757 of equations), Calc will find a partial solution. For example,
23758 typing @kbd{a S y @key{RET}} with the above system of equations
23759 would produce @samp{[y = a - x]}. There are now several ways to
23760 express this solution in terms of the original variables; Calc uses
23761 the first one that it finds. You can control the choice by adding
23762 variable specifiers of the form @samp{elim(@var{v})} to the
23763 variables list. This says that @var{v} should be eliminated from
23764 the equations; the variable will not appear at all in the solution.
23765 For example, typing @kbd{a S y,elim(x)} would yield
23766 @samp{[y = a - (b+a)/2]}.
23767
23768 If the variables list contains only @code{elim} specifiers,
23769 Calc simply eliminates those variables from the equations
23770 and then returns the resulting set of equations. For example,
23771 @kbd{a S elim(x)} produces @samp{[a - 2 y = b]}. Every variable
23772 eliminated will reduce the number of equations in the system
23773 by one.
23774
23775 Again, @kbd{a S} gives you one solution to the system of
23776 equations. If there are several solutions, you can use @kbd{H a S}
23777 to get a general family of solutions, or, if there is a finite
23778 number of solutions, you can use @kbd{a P} to get a list. (In
23779 the latter case, the result will take the form of a matrix where
23780 the rows are different solutions and the columns correspond to the
23781 variables you requested.)
23782
23783 Another way to deal with certain kinds of overdetermined systems of
23784 equations is the @kbd{a F} command, which does least-squares fitting
23785 to satisfy the equations. @xref{Curve Fitting}.
23786
23787 @node Decomposing Polynomials, , Solving Systems of Equations, Solving Equations
23788 @subsection Decomposing Polynomials
23789
23790 @noindent
23791 @ignore
23792 @starindex
23793 @end ignore
23794 @tindex poly
23795 The @code{poly} function takes a polynomial and a variable as
23796 arguments, and returns a vector of polynomial coefficients (constant
23797 coefficient first). For example, @samp{poly(x^3 + 2 x, x)} returns
23798 @expr{[0, 2, 0, 1]}. If the input is not a polynomial in @expr{x},
23799 the call to @code{poly} is left in symbolic form. If the input does
23800 not involve the variable @expr{x}, the input is returned in a list
23801 of length one, representing a polynomial with only a constant
23802 coefficient. The call @samp{poly(x, x)} returns the vector @expr{[0, 1]}.
23803 The last element of the returned vector is guaranteed to be nonzero;
23804 note that @samp{poly(0, x)} returns the empty vector @expr{[]}.
23805 Note also that @expr{x} may actually be any formula; for example,
23806 @samp{poly(sin(x)^2 - sin(x) + 3, sin(x))} returns @expr{[3, -1, 1]}.
23807
23808 @cindex Coefficients of polynomial
23809 @cindex Degree of polynomial
23810 To get the @expr{x^k} coefficient of polynomial @expr{p}, use
23811 @samp{poly(p, x)_(k+1)}. To get the degree of polynomial @expr{p},
23812 use @samp{vlen(poly(p, x)) - 1}. For example, @samp{poly((x+1)^4, x)}
23813 returns @samp{[1, 4, 6, 4, 1]}, so @samp{poly((x+1)^4, x)_(2+1)}
23814 gives the @expr{x^2} coefficient of this polynomial, 6.
23815
23816 @ignore
23817 @starindex
23818 @end ignore
23819 @tindex gpoly
23820 One important feature of the solver is its ability to recognize
23821 formulas which are ``essentially'' polynomials. This ability is
23822 made available to the user through the @code{gpoly} function, which
23823 is used just like @code{poly}: @samp{gpoly(@var{expr}, @var{var})}.
23824 If @var{expr} is a polynomial in some term which includes @var{var}, then
23825 this function will return a vector @samp{[@var{x}, @var{c}, @var{a}]}
23826 where @var{x} is the term that depends on @var{var}, @var{c} is a
23827 vector of polynomial coefficients (like the one returned by @code{poly}),
23828 and @var{a} is a multiplier which is usually 1. Basically,
23829 @samp{@var{expr} = @var{a}*(@var{c}_1 + @var{c}_2 @var{x} +
23830 @var{c}_3 @var{x}^2 + ...)}. The last element of @var{c} is
23831 guaranteed to be non-zero, and @var{c} will not equal @samp{[1]}
23832 (i.e., the trivial decomposition @var{expr} = @var{x} is not
23833 considered a polynomial). One side effect is that @samp{gpoly(x, x)}
23834 and @samp{gpoly(6, x)}, both of which might be expected to recognize
23835 their arguments as polynomials, will not because the decomposition
23836 is considered trivial.
23837
23838 For example, @samp{gpoly((x-2)^2, x)} returns @samp{[x, [4, -4, 1], 1]},
23839 since the expanded form of this polynomial is @expr{4 - 4 x + x^2}.
23840
23841 The term @var{x} may itself be a polynomial in @var{var}. This is
23842 done to reduce the size of the @var{c} vector. For example,
23843 @samp{gpoly(x^4 + x^2 - 1, x)} returns @samp{[x^2, [-1, 1, 1], 1]},
23844 since a quadratic polynomial in @expr{x^2} is easier to solve than
23845 a quartic polynomial in @expr{x}.
23846
23847 A few more examples of the kinds of polynomials @code{gpoly} can
23848 discover:
23849
23850 @smallexample
23851 sin(x) - 1 [sin(x), [-1, 1], 1]
23852 x + 1/x - 1 [x, [1, -1, 1], 1/x]
23853 x + 1/x [x^2, [1, 1], 1/x]
23854 x^3 + 2 x [x^2, [2, 1], x]
23855 x + x^2:3 + sqrt(x) [x^1:6, [1, 1, 0, 1], x^1:2]
23856 x^(2a) + 2 x^a + 5 [x^a, [5, 2, 1], 1]
23857 (exp(-x) + exp(x)) / 2 [e^(2 x), [0.5, 0.5], e^-x]
23858 @end smallexample
23859
23860 The @code{poly} and @code{gpoly} functions accept a third integer argument
23861 which specifies the largest degree of polynomial that is acceptable.
23862 If this is @expr{n}, then only @var{c} vectors of length @expr{n+1}
23863 or less will be returned. Otherwise, the @code{poly} or @code{gpoly}
23864 call will remain in symbolic form. For example, the equation solver
23865 can handle quartics and smaller polynomials, so it calls
23866 @samp{gpoly(@var{expr}, @var{var}, 4)} to discover whether @var{expr}
23867 can be treated by its linear, quadratic, cubic, or quartic formulas.
23868
23869 @ignore
23870 @starindex
23871 @end ignore
23872 @tindex pdeg
23873 The @code{pdeg} function computes the degree of a polynomial;
23874 @samp{pdeg(p,x)} is the highest power of @code{x} that appears in
23875 @code{p}. This is the same as @samp{vlen(poly(p,x))-1}, but is
23876 much more efficient. If @code{p} is constant with respect to @code{x},
23877 then @samp{pdeg(p,x) = 0}. If @code{p} is not a polynomial in @code{x}
23878 (e.g., @samp{pdeg(2 cos(x), x)}, the function remains unevaluated.
23879 It is possible to omit the second argument @code{x}, in which case
23880 @samp{pdeg(p)} returns the highest total degree of any term of the
23881 polynomial, counting all variables that appear in @code{p}. Note
23882 that @code{pdeg(c) = pdeg(c,x) = 0} for any nonzero constant @code{c};
23883 the degree of the constant zero is considered to be @code{-inf}
23884 (minus infinity).
23885
23886 @ignore
23887 @starindex
23888 @end ignore
23889 @tindex plead
23890 The @code{plead} function finds the leading term of a polynomial.
23891 Thus @samp{plead(p,x)} is equivalent to @samp{poly(p,x)_vlen(poly(p,x))},
23892 though again more efficient. In particular, @samp{plead((2x+1)^10, x)}
23893 returns 1024 without expanding out the list of coefficients. The
23894 value of @code{plead(p,x)} will be zero only if @expr{p = 0}.
23895
23896 @ignore
23897 @starindex
23898 @end ignore
23899 @tindex pcont
23900 The @code{pcont} function finds the @dfn{content} of a polynomial. This
23901 is the greatest common divisor of all the coefficients of the polynomial.
23902 With two arguments, @code{pcont(p,x)} effectively uses @samp{poly(p,x)}
23903 to get a list of coefficients, then uses @code{pgcd} (the polynomial
23904 GCD function) to combine these into an answer. For example,
23905 @samp{pcont(4 x y^2 + 6 x^2 y, x)} is @samp{2 y}. The content is
23906 basically the ``biggest'' polynomial that can be divided into @code{p}
23907 exactly. The sign of the content is the same as the sign of the leading
23908 coefficient.
23909
23910 With only one argument, @samp{pcont(p)} computes the numerical
23911 content of the polynomial, i.e., the @code{gcd} of the numerical
23912 coefficients of all the terms in the formula. Note that @code{gcd}
23913 is defined on rational numbers as well as integers; it computes
23914 the @code{gcd} of the numerators and the @code{lcm} of the
23915 denominators. Thus @samp{pcont(4:3 x y^2 + 6 x^2 y)} returns 2:3.
23916 Dividing the polynomial by this number will clear all the
23917 denominators, as well as dividing by any common content in the
23918 numerators. The numerical content of a polynomial is negative only
23919 if all the coefficients in the polynomial are negative.
23920
23921 @ignore
23922 @starindex
23923 @end ignore
23924 @tindex pprim
23925 The @code{pprim} function finds the @dfn{primitive part} of a
23926 polynomial, which is simply the polynomial divided (using @code{pdiv}
23927 if necessary) by its content. If the input polynomial has rational
23928 coefficients, the result will have integer coefficients in simplest
23929 terms.
23930
23931 @node Numerical Solutions, Curve Fitting, Solving Equations, Algebra
23932 @section Numerical Solutions
23933
23934 @noindent
23935 Not all equations can be solved symbolically. The commands in this
23936 section use numerical algorithms that can find a solution to a specific
23937 instance of an equation to any desired accuracy. Note that the
23938 numerical commands are slower than their algebraic cousins; it is a
23939 good idea to try @kbd{a S} before resorting to these commands.
23940
23941 (@xref{Curve Fitting}, for some other, more specialized, operations
23942 on numerical data.)
23943
23944 @menu
23945 * Root Finding::
23946 * Minimization::
23947 * Numerical Systems of Equations::
23948 @end menu
23949
23950 @node Root Finding, Minimization, Numerical Solutions, Numerical Solutions
23951 @subsection Root Finding
23952
23953 @noindent
23954 @kindex a R
23955 @pindex calc-find-root
23956 @tindex root
23957 @cindex Newton's method
23958 @cindex Roots of equations
23959 @cindex Numerical root-finding
23960 The @kbd{a R} (@code{calc-find-root}) [@code{root}] command finds a
23961 numerical solution (or @dfn{root}) of an equation. (This command treats
23962 inequalities the same as equations. If the input is any other kind
23963 of formula, it is interpreted as an equation of the form @expr{X = 0}.)
23964
23965 The @kbd{a R} command requires an initial guess on the top of the
23966 stack, and a formula in the second-to-top position. It prompts for a
23967 solution variable, which must appear in the formula. All other variables
23968 that appear in the formula must have assigned values, i.e., when
23969 a value is assigned to the solution variable and the formula is
23970 evaluated with @kbd{=}, it should evaluate to a number. Any assigned
23971 value for the solution variable itself is ignored and unaffected by
23972 this command.
23973
23974 When the command completes, the initial guess is replaced on the stack
23975 by a vector of two numbers: The value of the solution variable that
23976 solves the equation, and the difference between the lefthand and
23977 righthand sides of the equation at that value. Ordinarily, the second
23978 number will be zero or very nearly zero. (Note that Calc uses a
23979 slightly higher precision while finding the root, and thus the second
23980 number may be slightly different from the value you would compute from
23981 the equation yourself.)
23982
23983 The @kbd{v h} (@code{calc-head}) command is a handy way to extract
23984 the first element of the result vector, discarding the error term.
23985
23986 The initial guess can be a real number, in which case Calc searches
23987 for a real solution near that number, or a complex number, in which
23988 case Calc searches the whole complex plane near that number for a
23989 solution, or it can be an interval form which restricts the search
23990 to real numbers inside that interval.
23991
23992 Calc tries to use @kbd{a d} to take the derivative of the equation.
23993 If this succeeds, it uses Newton's method. If the equation is not
23994 differentiable Calc uses a bisection method. (If Newton's method
23995 appears to be going astray, Calc switches over to bisection if it
23996 can, or otherwise gives up. In this case it may help to try again
23997 with a slightly different initial guess.) If the initial guess is a
23998 complex number, the function must be differentiable.
23999
24000 If the formula (or the difference between the sides of an equation)
24001 is negative at one end of the interval you specify and positive at
24002 the other end, the root finder is guaranteed to find a root.
24003 Otherwise, Calc subdivides the interval into small parts looking for
24004 positive and negative values to bracket the root. When your guess is
24005 an interval, Calc will not look outside that interval for a root.
24006
24007 @kindex H a R
24008 @tindex wroot
24009 The @kbd{H a R} [@code{wroot}] command is similar to @kbd{a R}, except
24010 that if the initial guess is an interval for which the function has
24011 the same sign at both ends, then rather than subdividing the interval
24012 Calc attempts to widen it to enclose a root. Use this mode if
24013 you are not sure if the function has a root in your interval.
24014
24015 If the function is not differentiable, and you give a simple number
24016 instead of an interval as your initial guess, Calc uses this widening
24017 process even if you did not type the Hyperbolic flag. (If the function
24018 @emph{is} differentiable, Calc uses Newton's method which does not
24019 require a bounding interval in order to work.)
24020
24021 If Calc leaves the @code{root} or @code{wroot} function in symbolic
24022 form on the stack, it will normally display an explanation for why
24023 no root was found. If you miss this explanation, press @kbd{w}
24024 (@code{calc-why}) to get it back.
24025
24026 @node Minimization, Numerical Systems of Equations, Root Finding, Numerical Solutions
24027 @subsection Minimization
24028
24029 @noindent
24030 @kindex a N
24031 @kindex H a N
24032 @kindex a X
24033 @kindex H a X
24034 @pindex calc-find-minimum
24035 @pindex calc-find-maximum
24036 @tindex minimize
24037 @tindex maximize
24038 @cindex Minimization, numerical
24039 The @kbd{a N} (@code{calc-find-minimum}) [@code{minimize}] command
24040 finds a minimum value for a formula. It is very similar in operation
24041 to @kbd{a R} (@code{calc-find-root}): You give the formula and an initial
24042 guess on the stack, and are prompted for the name of a variable. The guess
24043 may be either a number near the desired minimum, or an interval enclosing
24044 the desired minimum. The function returns a vector containing the
24045 value of the variable which minimizes the formula's value, along
24046 with the minimum value itself.
24047
24048 Note that this command looks for a @emph{local} minimum. Many functions
24049 have more than one minimum; some, like
24050 @texline @math{x \sin x},
24051 @infoline @expr{x sin(x)},
24052 have infinitely many. In fact, there is no easy way to define the
24053 ``global'' minimum of
24054 @texline @math{x \sin x}
24055 @infoline @expr{x sin(x)}
24056 but Calc can still locate any particular local minimum
24057 for you. Calc basically goes downhill from the initial guess until it
24058 finds a point at which the function's value is greater both to the left
24059 and to the right. Calc does not use derivatives when minimizing a function.
24060
24061 If your initial guess is an interval and it looks like the minimum
24062 occurs at one or the other endpoint of the interval, Calc will return
24063 that endpoint only if that endpoint is closed; thus, minimizing @expr{17 x}
24064 over @expr{[2..3]} will return @expr{[2, 38]}, but minimizing over
24065 @expr{(2..3]} would report no minimum found. In general, you should
24066 use closed intervals to find literally the minimum value in that
24067 range of @expr{x}, or open intervals to find the local minimum, if
24068 any, that happens to lie in that range.
24069
24070 Most functions are smooth and flat near their minimum values. Because
24071 of this flatness, if the current precision is, say, 12 digits, the
24072 variable can only be determined meaningfully to about six digits. Thus
24073 you should set the precision to twice as many digits as you need in your
24074 answer.
24075
24076 @ignore
24077 @mindex wmin@idots
24078 @end ignore
24079 @tindex wminimize
24080 @ignore
24081 @mindex wmax@idots
24082 @end ignore
24083 @tindex wmaximize
24084 The @kbd{H a N} [@code{wminimize}] command, analogously to @kbd{H a R},
24085 expands the guess interval to enclose a minimum rather than requiring
24086 that the minimum lie inside the interval you supply.
24087
24088 The @kbd{a X} (@code{calc-find-maximum}) [@code{maximize}] and
24089 @kbd{H a X} [@code{wmaximize}] commands effectively minimize the
24090 negative of the formula you supply.
24091
24092 The formula must evaluate to a real number at all points inside the
24093 interval (or near the initial guess if the guess is a number). If
24094 the initial guess is a complex number the variable will be minimized
24095 over the complex numbers; if it is real or an interval it will
24096 be minimized over the reals.
24097
24098 @node Numerical Systems of Equations, , Minimization, Numerical Solutions
24099 @subsection Systems of Equations
24100
24101 @noindent
24102 @cindex Systems of equations, numerical
24103 The @kbd{a R} command can also solve systems of equations. In this
24104 case, the equation should instead be a vector of equations, the
24105 guess should instead be a vector of numbers (intervals are not
24106 supported), and the variable should be a vector of variables. You
24107 can omit the brackets while entering the list of variables. Each
24108 equation must be differentiable by each variable for this mode to
24109 work. The result will be a vector of two vectors: The variable
24110 values that solved the system of equations, and the differences
24111 between the sides of the equations with those variable values.
24112 There must be the same number of equations as variables. Since
24113 only plain numbers are allowed as guesses, the Hyperbolic flag has
24114 no effect when solving a system of equations.
24115
24116 It is also possible to minimize over many variables with @kbd{a N}
24117 (or maximize with @kbd{a X}). Once again the variable name should
24118 be replaced by a vector of variables, and the initial guess should
24119 be an equal-sized vector of initial guesses. But, unlike the case of
24120 multidimensional @kbd{a R}, the formula being minimized should
24121 still be a single formula, @emph{not} a vector. Beware that
24122 multidimensional minimization is currently @emph{very} slow.
24123
24124 @node Curve Fitting, Summations, Numerical Solutions, Algebra
24125 @section Curve Fitting
24126
24127 @noindent
24128 The @kbd{a F} command fits a set of data to a @dfn{model formula},
24129 such as @expr{y = m x + b} where @expr{m} and @expr{b} are parameters
24130 to be determined. For a typical set of measured data there will be
24131 no single @expr{m} and @expr{b} that exactly fit the data; in this
24132 case, Calc chooses values of the parameters that provide the closest
24133 possible fit.
24134
24135 @menu
24136 * Linear Fits::
24137 * Polynomial and Multilinear Fits::
24138 * Error Estimates for Fits::
24139 * Standard Nonlinear Models::
24140 * Curve Fitting Details::
24141 * Interpolation::
24142 @end menu
24143
24144 @node Linear Fits, Polynomial and Multilinear Fits, Curve Fitting, Curve Fitting
24145 @subsection Linear Fits
24146
24147 @noindent
24148 @kindex a F
24149 @pindex calc-curve-fit
24150 @tindex fit
24151 @cindex Linear regression
24152 @cindex Least-squares fits
24153 The @kbd{a F} (@code{calc-curve-fit}) [@code{fit}] command attempts
24154 to fit a set of data (@expr{x} and @expr{y} vectors of numbers) to a
24155 straight line, polynomial, or other function of @expr{x}. For the
24156 moment we will consider only the case of fitting to a line, and we
24157 will ignore the issue of whether or not the model was in fact a good
24158 fit for the data.
24159
24160 In a standard linear least-squares fit, we have a set of @expr{(x,y)}
24161 data points that we wish to fit to the model @expr{y = m x + b}
24162 by adjusting the parameters @expr{m} and @expr{b} to make the @expr{y}
24163 values calculated from the formula be as close as possible to the actual
24164 @expr{y} values in the data set. (In a polynomial fit, the model is
24165 instead, say, @expr{y = a x^3 + b x^2 + c x + d}. In a multilinear fit,
24166 we have data points of the form @expr{(x_1,x_2,x_3,y)} and our model is
24167 @expr{y = a x_1 + b x_2 + c x_3 + d}. These will be discussed later.)
24168
24169 In the model formula, variables like @expr{x} and @expr{x_2} are called
24170 the @dfn{independent variables}, and @expr{y} is the @dfn{dependent
24171 variable}. Variables like @expr{m}, @expr{a}, and @expr{b} are called
24172 the @dfn{parameters} of the model.
24173
24174 The @kbd{a F} command takes the data set to be fitted from the stack.
24175 By default, it expects the data in the form of a matrix. For example,
24176 for a linear or polynomial fit, this would be a
24177 @texline @math{2\times N}
24178 @infoline 2xN
24179 matrix where the first row is a list of @expr{x} values and the second
24180 row has the corresponding @expr{y} values. For the multilinear fit
24181 shown above, the matrix would have four rows (@expr{x_1}, @expr{x_2},
24182 @expr{x_3}, and @expr{y}, respectively).
24183
24184 If you happen to have an
24185 @texline @math{N\times2}
24186 @infoline Nx2
24187 matrix instead of a
24188 @texline @math{2\times N}
24189 @infoline 2xN
24190 matrix, just press @kbd{v t} first to transpose the matrix.
24191
24192 After you type @kbd{a F}, Calc prompts you to select a model. For a
24193 linear fit, press the digit @kbd{1}.
24194
24195 Calc then prompts for you to name the variables. By default it chooses
24196 high letters like @expr{x} and @expr{y} for independent variables and
24197 low letters like @expr{a} and @expr{b} for parameters. (The dependent
24198 variable doesn't need a name.) The two kinds of variables are separated
24199 by a semicolon. Since you generally care more about the names of the
24200 independent variables than of the parameters, Calc also allows you to
24201 name only those and let the parameters use default names.
24202
24203 For example, suppose the data matrix
24204
24205 @ifinfo
24206 @example
24207 @group
24208 [ [ 1, 2, 3, 4, 5 ]
24209 [ 5, 7, 9, 11, 13 ] ]
24210 @end group
24211 @end example
24212 @end ifinfo
24213 @tex
24214 \turnoffactive
24215 \turnoffactive
24216 \beforedisplay
24217 $$ \pmatrix{ 1 & 2 & 3 & 4 & 5 \cr
24218 5 & 7 & 9 & 11 & 13 }
24219 $$
24220 \afterdisplay
24221 @end tex
24222
24223 @noindent
24224 is on the stack and we wish to do a simple linear fit. Type
24225 @kbd{a F}, then @kbd{1} for the model, then @key{RET} to use
24226 the default names. The result will be the formula @expr{3 + 2 x}
24227 on the stack. Calc has created the model expression @kbd{a + b x},
24228 then found the optimal values of @expr{a} and @expr{b} to fit the
24229 data. (In this case, it was able to find an exact fit.) Calc then
24230 substituted those values for @expr{a} and @expr{b} in the model
24231 formula.
24232
24233 The @kbd{a F} command puts two entries in the trail. One is, as
24234 always, a copy of the result that went to the stack; the other is
24235 a vector of the actual parameter values, written as equations:
24236 @expr{[a = 3, b = 2]}, in case you'd rather read them in a list
24237 than pick them out of the formula. (You can type @kbd{t y}
24238 to move this vector to the stack; see @ref{Trail Commands}.
24239
24240 Specifying a different independent variable name will affect the
24241 resulting formula: @kbd{a F 1 k @key{RET}} produces @kbd{3 + 2 k}.
24242 Changing the parameter names (say, @kbd{a F 1 k;b,m @key{RET}}) will affect
24243 the equations that go into the trail.
24244
24245 @tex
24246 \bigskip
24247 @end tex
24248
24249 To see what happens when the fit is not exact, we could change
24250 the number 13 in the data matrix to 14 and try the fit again.
24251 The result is:
24252
24253 @example
24254 2.6 + 2.2 x
24255 @end example
24256
24257 Evaluating this formula, say with @kbd{v x 5 @key{RET} @key{TAB} V M $ @key{RET}}, shows
24258 a reasonably close match to the y-values in the data.
24259
24260 @example
24261 [4.8, 7., 9.2, 11.4, 13.6]
24262 @end example
24263
24264 Since there is no line which passes through all the @var{n} data points,
24265 Calc has chosen a line that best approximates the data points using
24266 the method of least squares. The idea is to define the @dfn{chi-square}
24267 error measure
24268
24269 @ifinfo
24270 @example
24271 chi^2 = sum((y_i - (a + b x_i))^2, i, 1, N)
24272 @end example
24273 @end ifinfo
24274 @tex
24275 \turnoffactive
24276 \beforedisplay
24277 $$ \chi^2 = \sum_{i=1}^N (y_i - (a + b x_i))^2 $$
24278 \afterdisplay
24279 @end tex
24280
24281 @noindent
24282 which is clearly zero if @expr{a + b x} exactly fits all data points,
24283 and increases as various @expr{a + b x_i} values fail to match the
24284 corresponding @expr{y_i} values. There are several reasons why the
24285 summand is squared, one of them being to ensure that
24286 @texline @math{\chi^2 \ge 0}.
24287 @infoline @expr{chi^2 >= 0}.
24288 Least-squares fitting simply chooses the values of @expr{a} and @expr{b}
24289 for which the error
24290 @texline @math{\chi^2}
24291 @infoline @expr{chi^2}
24292 is as small as possible.
24293
24294 Other kinds of models do the same thing but with a different model
24295 formula in place of @expr{a + b x_i}.
24296
24297 @tex
24298 \bigskip
24299 @end tex
24300
24301 A numeric prefix argument causes the @kbd{a F} command to take the
24302 data in some other form than one big matrix. A positive argument @var{n}
24303 will take @var{N} items from the stack, corresponding to the @var{n} rows
24304 of a data matrix. In the linear case, @var{n} must be 2 since there
24305 is always one independent variable and one dependent variable.
24306
24307 A prefix of zero or plain @kbd{C-u} is a compromise; Calc takes two
24308 items from the stack, an @var{n}-row matrix of @expr{x} values, and a
24309 vector of @expr{y} values. If there is only one independent variable,
24310 the @expr{x} values can be either a one-row matrix or a plain vector,
24311 in which case the @kbd{C-u} prefix is the same as a @w{@kbd{C-u 2}} prefix.
24312
24313 @node Polynomial and Multilinear Fits, Error Estimates for Fits, Linear Fits, Curve Fitting
24314 @subsection Polynomial and Multilinear Fits
24315
24316 @noindent
24317 To fit the data to higher-order polynomials, just type one of the
24318 digits @kbd{2} through @kbd{9} when prompted for a model. For example,
24319 we could fit the original data matrix from the previous section
24320 (with 13, not 14) to a parabola instead of a line by typing
24321 @kbd{a F 2 @key{RET}}.
24322
24323 @example
24324 2.00000000001 x - 1.5e-12 x^2 + 2.99999999999
24325 @end example
24326
24327 Note that since the constant and linear terms are enough to fit the
24328 data exactly, it's no surprise that Calc chose a tiny contribution
24329 for @expr{x^2}. (The fact that it's not exactly zero is due only
24330 to roundoff error. Since our data are exact integers, we could get
24331 an exact answer by typing @kbd{m f} first to get Fraction mode.
24332 Then the @expr{x^2} term would vanish altogether. Usually, though,
24333 the data being fitted will be approximate floats so Fraction mode
24334 won't help.)
24335
24336 Doing the @kbd{a F 2} fit on the data set with 14 instead of 13
24337 gives a much larger @expr{x^2} contribution, as Calc bends the
24338 line slightly to improve the fit.
24339
24340 @example
24341 0.142857142855 x^2 + 1.34285714287 x + 3.59999999998
24342 @end example
24343
24344 An important result from the theory of polynomial fitting is that it
24345 is always possible to fit @var{n} data points exactly using a polynomial
24346 of degree @mathit{@var{n}-1}, sometimes called an @dfn{interpolating polynomial}.
24347 Using the modified (14) data matrix, a model number of 4 gives
24348 a polynomial that exactly matches all five data points:
24349
24350 @example
24351 0.04167 x^4 - 0.4167 x^3 + 1.458 x^2 - 0.08333 x + 4.
24352 @end example
24353
24354 The actual coefficients we get with a precision of 12, like
24355 @expr{0.0416666663588}, clearly suffer from loss of precision.
24356 It is a good idea to increase the working precision to several
24357 digits beyond what you need when you do a fitting operation.
24358 Or, if your data are exact, use Fraction mode to get exact
24359 results.
24360
24361 You can type @kbd{i} instead of a digit at the model prompt to fit
24362 the data exactly to a polynomial. This just counts the number of
24363 columns of the data matrix to choose the degree of the polynomial
24364 automatically.
24365
24366 Fitting data ``exactly'' to high-degree polynomials is not always
24367 a good idea, though. High-degree polynomials have a tendency to
24368 wiggle uncontrollably in between the fitting data points. Also,
24369 if the exact-fit polynomial is going to be used to interpolate or
24370 extrapolate the data, it is numerically better to use the @kbd{a p}
24371 command described below. @xref{Interpolation}.
24372
24373 @tex
24374 \bigskip
24375 @end tex
24376
24377 Another generalization of the linear model is to assume the
24378 @expr{y} values are a sum of linear contributions from several
24379 @expr{x} values. This is a @dfn{multilinear} fit, and it is also
24380 selected by the @kbd{1} digit key. (Calc decides whether the fit
24381 is linear or multilinear by counting the rows in the data matrix.)
24382
24383 Given the data matrix,
24384
24385 @example
24386 @group
24387 [ [ 1, 2, 3, 4, 5 ]
24388 [ 7, 2, 3, 5, 2 ]
24389 [ 14.5, 15, 18.5, 22.5, 24 ] ]
24390 @end group
24391 @end example
24392
24393 @noindent
24394 the command @kbd{a F 1 @key{RET}} will call the first row @expr{x} and the
24395 second row @expr{y}, and will fit the values in the third row to the
24396 model @expr{a + b x + c y}.
24397
24398 @example
24399 8. + 3. x + 0.5 y
24400 @end example
24401
24402 Calc can do multilinear fits with any number of independent variables
24403 (i.e., with any number of data rows).
24404
24405 @tex
24406 \bigskip
24407 @end tex
24408
24409 Yet another variation is @dfn{homogeneous} linear models, in which
24410 the constant term is known to be zero. In the linear case, this
24411 means the model formula is simply @expr{a x}; in the multilinear
24412 case, the model might be @expr{a x + b y + c z}; and in the polynomial
24413 case, the model could be @expr{a x + b x^2 + c x^3}. You can get
24414 a homogeneous linear or multilinear model by pressing the letter
24415 @kbd{h} followed by a regular model key, like @kbd{1} or @kbd{2}.
24416
24417 It is certainly possible to have other constrained linear models,
24418 like @expr{2.3 + a x} or @expr{a - 4 x}. While there is no single
24419 key to select models like these, a later section shows how to enter
24420 any desired model by hand. In the first case, for example, you
24421 would enter @kbd{a F ' 2.3 + a x}.
24422
24423 Another class of models that will work but must be entered by hand
24424 are multinomial fits, e.g., @expr{a + b x + c y + d x^2 + e y^2 + f x y}.
24425
24426 @node Error Estimates for Fits, Standard Nonlinear Models, Polynomial and Multilinear Fits, Curve Fitting
24427 @subsection Error Estimates for Fits
24428
24429 @noindent
24430 @kindex H a F
24431 @tindex efit
24432 With the Hyperbolic flag, @kbd{H a F} [@code{efit}] performs the same
24433 fitting operation as @kbd{a F}, but reports the coefficients as error
24434 forms instead of plain numbers. Fitting our two data matrices (first
24435 with 13, then with 14) to a line with @kbd{H a F} gives the results,
24436
24437 @example
24438 3. + 2. x
24439 2.6 +/- 0.382970843103 + 2.2 +/- 0.115470053838 x
24440 @end example
24441
24442 In the first case the estimated errors are zero because the linear
24443 fit is perfect. In the second case, the errors are nonzero but
24444 moderately small, because the data are still very close to linear.
24445
24446 It is also possible for the @emph{input} to a fitting operation to
24447 contain error forms. The data values must either all include errors
24448 or all be plain numbers. Error forms can go anywhere but generally
24449 go on the numbers in the last row of the data matrix. If the last
24450 row contains error forms
24451 @texline `@var{y_i}@w{ @tfn{+/-} }@math{\sigma_i}',
24452 @infoline `@var{y_i}@w{ @tfn{+/-} }@var{sigma_i}',
24453 then the
24454 @texline @math{\chi^2}
24455 @infoline @expr{chi^2}
24456 statistic is now,
24457
24458 @ifinfo
24459 @example
24460 chi^2 = sum(((y_i - (a + b x_i)) / sigma_i)^2, i, 1, N)
24461 @end example
24462 @end ifinfo
24463 @tex
24464 \turnoffactive
24465 \beforedisplay
24466 $$ \chi^2 = \sum_{i=1}^N \left(y_i - (a + b x_i) \over \sigma_i\right)^2 $$
24467 \afterdisplay
24468 @end tex
24469
24470 @noindent
24471 so that data points with larger error estimates contribute less to
24472 the fitting operation.
24473
24474 If there are error forms on other rows of the data matrix, all the
24475 errors for a given data point are combined; the square root of the
24476 sum of the squares of the errors forms the
24477 @texline @math{\sigma_i}
24478 @infoline @expr{sigma_i}
24479 used for the data point.
24480
24481 Both @kbd{a F} and @kbd{H a F} can accept error forms in the input
24482 matrix, although if you are concerned about error analysis you will
24483 probably use @kbd{H a F} so that the output also contains error
24484 estimates.
24485
24486 If the input contains error forms but all the
24487 @texline @math{\sigma_i}
24488 @infoline @expr{sigma_i}
24489 values are the same, it is easy to see that the resulting fitted model
24490 will be the same as if the input did not have error forms at all
24491 @texline (@math{\chi^2}
24492 @infoline (@expr{chi^2}
24493 is simply scaled uniformly by
24494 @texline @math{1 / \sigma^2},
24495 @infoline @expr{1 / sigma^2},
24496 which doesn't affect where it has a minimum). But there @emph{will} be
24497 a difference in the estimated errors of the coefficients reported by
24498 @kbd{H a F}.
24499
24500 Consult any text on statistical modeling of data for a discussion
24501 of where these error estimates come from and how they should be
24502 interpreted.
24503
24504 @tex
24505 \bigskip
24506 @end tex
24507
24508 @kindex I a F
24509 @tindex xfit
24510 With the Inverse flag, @kbd{I a F} [@code{xfit}] produces even more
24511 information. The result is a vector of six items:
24512
24513 @enumerate
24514 @item
24515 The model formula with error forms for its coefficients or
24516 parameters. This is the result that @kbd{H a F} would have
24517 produced.
24518
24519 @item
24520 A vector of ``raw'' parameter values for the model. These are the
24521 polynomial coefficients or other parameters as plain numbers, in the
24522 same order as the parameters appeared in the final prompt of the
24523 @kbd{I a F} command. For polynomials of degree @expr{d}, this vector
24524 will have length @expr{M = d+1} with the constant term first.
24525
24526 @item
24527 The covariance matrix @expr{C} computed from the fit. This is
24528 an @var{m}x@var{m} symmetric matrix; the diagonal elements
24529 @texline @math{C_{jj}}
24530 @infoline @expr{C_j_j}
24531 are the variances
24532 @texline @math{\sigma_j^2}
24533 @infoline @expr{sigma_j^2}
24534 of the parameters. The other elements are covariances
24535 @texline @math{\sigma_{ij}^2}
24536 @infoline @expr{sigma_i_j^2}
24537 that describe the correlation between pairs of parameters. (A related
24538 set of numbers, the @dfn{linear correlation coefficients}
24539 @texline @math{r_{ij}},
24540 @infoline @expr{r_i_j},
24541 are defined as
24542 @texline @math{\sigma_{ij}^2 / \sigma_i \, \sigma_j}.)
24543 @infoline @expr{sigma_i_j^2 / sigma_i sigma_j}.)
24544
24545 @item
24546 A vector of @expr{M} ``parameter filter'' functions whose
24547 meanings are described below. If no filters are necessary this
24548 will instead be an empty vector; this is always the case for the
24549 polynomial and multilinear fits described so far.
24550
24551 @item
24552 The value of
24553 @texline @math{\chi^2}
24554 @infoline @expr{chi^2}
24555 for the fit, calculated by the formulas shown above. This gives a
24556 measure of the quality of the fit; statisticians consider
24557 @texline @math{\chi^2 \approx N - M}
24558 @infoline @expr{chi^2 = N - M}
24559 to indicate a moderately good fit (where again @expr{N} is the number of
24560 data points and @expr{M} is the number of parameters).
24561
24562 @item
24563 A measure of goodness of fit expressed as a probability @expr{Q}.
24564 This is computed from the @code{utpc} probability distribution
24565 function using
24566 @texline @math{\chi^2}
24567 @infoline @expr{chi^2}
24568 with @expr{N - M} degrees of freedom. A
24569 value of 0.5 implies a good fit; some texts recommend that often
24570 @expr{Q = 0.1} or even 0.001 can signify an acceptable fit. In
24571 particular,
24572 @texline @math{\chi^2}
24573 @infoline @expr{chi^2}
24574 statistics assume the errors in your inputs
24575 follow a normal (Gaussian) distribution; if they don't, you may
24576 have to accept smaller values of @expr{Q}.
24577
24578 The @expr{Q} value is computed only if the input included error
24579 estimates. Otherwise, Calc will report the symbol @code{nan}
24580 for @expr{Q}. The reason is that in this case the
24581 @texline @math{\chi^2}
24582 @infoline @expr{chi^2}
24583 value has effectively been used to estimate the original errors
24584 in the input, and thus there is no redundant information left
24585 over to use for a confidence test.
24586 @end enumerate
24587
24588 @node Standard Nonlinear Models, Curve Fitting Details, Error Estimates for Fits, Curve Fitting
24589 @subsection Standard Nonlinear Models
24590
24591 @noindent
24592 The @kbd{a F} command also accepts other kinds of models besides
24593 lines and polynomials. Some common models have quick single-key
24594 abbreviations; others must be entered by hand as algebraic formulas.
24595
24596 Here is a complete list of the standard models recognized by @kbd{a F}:
24597
24598 @table @kbd
24599 @item 1
24600 Linear or multilinear. @mathit{a + b x + c y + d z}.
24601 @item 2-9
24602 Polynomials. @mathit{a + b x + c x^2 + d x^3}.
24603 @item e
24604 Exponential. @mathit{a} @tfn{exp}@mathit{(b x)} @tfn{exp}@mathit{(c y)}.
24605 @item E
24606 Base-10 exponential. @mathit{a} @tfn{10^}@mathit{(b x)} @tfn{10^}@mathit{(c y)}.
24607 @item x
24608 Exponential (alternate notation). @tfn{exp}@mathit{(a + b x + c y)}.
24609 @item X
24610 Base-10 exponential (alternate). @tfn{10^}@mathit{(a + b x + c y)}.
24611 @item l
24612 Logarithmic. @mathit{a + b} @tfn{ln}@mathit{(x) + c} @tfn{ln}@mathit{(y)}.
24613 @item L
24614 Base-10 logarithmic. @mathit{a + b} @tfn{log10}@mathit{(x) + c} @tfn{log10}@mathit{(y)}.
24615 @item ^
24616 General exponential. @mathit{a b^x c^y}.
24617 @item p
24618 Power law. @mathit{a x^b y^c}.
24619 @item q
24620 Quadratic. @mathit{a + b (x-c)^2 + d (x-e)^2}.
24621 @item g
24622 Gaussian.
24623 @texline @math{{a \over b \sqrt{2 \pi}} \exp\left( -{1 \over 2} \left( x - c \over b \right)^2 \right)}.
24624 @infoline @mathit{(a / b sqrt(2 pi)) exp(-0.5*((x-c)/b)^2)}.
24625 @end table
24626
24627 All of these models are used in the usual way; just press the appropriate
24628 letter at the model prompt, and choose variable names if you wish. The
24629 result will be a formula as shown in the above table, with the best-fit
24630 values of the parameters substituted. (You may find it easier to read
24631 the parameter values from the vector that is placed in the trail.)
24632
24633 All models except Gaussian and polynomials can generalize as shown to any
24634 number of independent variables. Also, all the built-in models have an
24635 additive or multiplicative parameter shown as @expr{a} in the above table
24636 which can be replaced by zero or one, as appropriate, by typing @kbd{h}
24637 before the model key.
24638
24639 Note that many of these models are essentially equivalent, but express
24640 the parameters slightly differently. For example, @expr{a b^x} and
24641 the other two exponential models are all algebraic rearrangements of
24642 each other. Also, the ``quadratic'' model is just a degree-2 polynomial
24643 with the parameters expressed differently. Use whichever form best
24644 matches the problem.
24645
24646 The HP-28/48 calculators support four different models for curve
24647 fitting, called @code{LIN}, @code{LOG}, @code{EXP}, and @code{PWR}.
24648 These correspond to Calc models @samp{a + b x}, @samp{a + b ln(x)},
24649 @samp{a exp(b x)}, and @samp{a x^b}, respectively. In each case,
24650 @expr{a} is what the HP-48 identifies as the ``intercept,'' and
24651 @expr{b} is what it calls the ``slope.''
24652
24653 @tex
24654 \bigskip
24655 @end tex
24656
24657 If the model you want doesn't appear on this list, press @kbd{'}
24658 (the apostrophe key) at the model prompt to enter any algebraic
24659 formula, such as @kbd{m x - b}, as the model. (Not all models
24660 will work, though---see the next section for details.)
24661
24662 The model can also be an equation like @expr{y = m x + b}.
24663 In this case, Calc thinks of all the rows of the data matrix on
24664 equal terms; this model effectively has two parameters
24665 (@expr{m} and @expr{b}) and two independent variables (@expr{x}
24666 and @expr{y}), with no ``dependent'' variables. Model equations
24667 do not need to take this @expr{y =} form. For example, the
24668 implicit line equation @expr{a x + b y = 1} works fine as a
24669 model.
24670
24671 When you enter a model, Calc makes an alphabetical list of all
24672 the variables that appear in the model. These are used for the
24673 default parameters, independent variables, and dependent variable
24674 (in that order). If you enter a plain formula (not an equation),
24675 Calc assumes the dependent variable does not appear in the formula
24676 and thus does not need a name.
24677
24678 For example, if the model formula has the variables @expr{a,mu,sigma,t,x},
24679 and the data matrix has three rows (meaning two independent variables),
24680 Calc will use @expr{a,mu,sigma} as the default parameters, and the
24681 data rows will be named @expr{t} and @expr{x}, respectively. If you
24682 enter an equation instead of a plain formula, Calc will use @expr{a,mu}
24683 as the parameters, and @expr{sigma,t,x} as the three independent
24684 variables.
24685
24686 You can, of course, override these choices by entering something
24687 different at the prompt. If you leave some variables out of the list,
24688 those variables must have stored values and those stored values will
24689 be used as constants in the model. (Stored values for the parameters
24690 and independent variables are ignored by the @kbd{a F} command.)
24691 If you list only independent variables, all the remaining variables
24692 in the model formula will become parameters.
24693
24694 If there are @kbd{$} signs in the model you type, they will stand
24695 for parameters and all other variables (in alphabetical order)
24696 will be independent. Use @kbd{$} for one parameter, @kbd{$$} for
24697 another, and so on. Thus @kbd{$ x + $$} is another way to describe
24698 a linear model.
24699
24700 If you type a @kbd{$} instead of @kbd{'} at the model prompt itself,
24701 Calc will take the model formula from the stack. (The data must then
24702 appear at the second stack level.) The same conventions are used to
24703 choose which variables in the formula are independent by default and
24704 which are parameters.
24705
24706 Models taken from the stack can also be expressed as vectors of
24707 two or three elements, @expr{[@var{model}, @var{vars}]} or
24708 @expr{[@var{model}, @var{vars}, @var{params}]}. Each of @var{vars}
24709 and @var{params} may be either a variable or a vector of variables.
24710 (If @var{params} is omitted, all variables in @var{model} except
24711 those listed as @var{vars} are parameters.)
24712
24713 When you enter a model manually with @kbd{'}, Calc puts a 3-vector
24714 describing the model in the trail so you can get it back if you wish.
24715
24716 @tex
24717 \bigskip
24718 @end tex
24719
24720 @vindex Model1
24721 @vindex Model2
24722 Finally, you can store a model in one of the Calc variables
24723 @code{Model1} or @code{Model2}, then use this model by typing
24724 @kbd{a F u} or @kbd{a F U} (respectively). The value stored in
24725 the variable can be any of the formats that @kbd{a F $} would
24726 accept for a model on the stack.
24727
24728 @tex
24729 \bigskip
24730 @end tex
24731
24732 Calc uses the principal values of inverse functions like @code{ln}
24733 and @code{arcsin} when doing fits. For example, when you enter
24734 the model @samp{y = sin(a t + b)} Calc actually uses the easier
24735 form @samp{arcsin(y) = a t + b}. The @code{arcsin} function always
24736 returns results in the range from @mathit{-90} to 90 degrees (or the
24737 equivalent range in radians). Suppose you had data that you
24738 believed to represent roughly three oscillations of a sine wave,
24739 so that the argument of the sine might go from zero to
24740 @texline @math{3\times360}
24741 @infoline @mathit{3*360}
24742 degrees.
24743 The above model would appear to be a good way to determine the
24744 true frequency and phase of the sine wave, but in practice it
24745 would fail utterly. The righthand side of the actual model
24746 @samp{arcsin(y) = a t + b} will grow smoothly with @expr{t}, but
24747 the lefthand side will bounce back and forth between @mathit{-90} and 90.
24748 No values of @expr{a} and @expr{b} can make the two sides match,
24749 even approximately.
24750
24751 There is no good solution to this problem at present. You could
24752 restrict your data to small enough ranges so that the above problem
24753 doesn't occur (i.e., not straddling any peaks in the sine wave).
24754 Or, in this case, you could use a totally different method such as
24755 Fourier analysis, which is beyond the scope of the @kbd{a F} command.
24756 (Unfortunately, Calc does not currently have any facilities for
24757 taking Fourier and related transforms.)
24758
24759 @node Curve Fitting Details, Interpolation, Standard Nonlinear Models, Curve Fitting
24760 @subsection Curve Fitting Details
24761
24762 @noindent
24763 Calc's internal least-squares fitter can only handle multilinear
24764 models. More precisely, it can handle any model of the form
24765 @expr{a f(x,y,z) + b g(x,y,z) + c h(x,y,z)}, where @expr{a,b,c}
24766 are the parameters and @expr{x,y,z} are the independent variables
24767 (of course there can be any number of each, not just three).
24768
24769 In a simple multilinear or polynomial fit, it is easy to see how
24770 to convert the model into this form. For example, if the model
24771 is @expr{a + b x + c x^2}, then @expr{f(x) = 1}, @expr{g(x) = x},
24772 and @expr{h(x) = x^2} are suitable functions.
24773
24774 For other models, Calc uses a variety of algebraic manipulations
24775 to try to put the problem into the form
24776
24777 @smallexample
24778 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)
24779 @end smallexample
24780
24781 @noindent
24782 where @expr{Y,A,B,C,F,G,H} are arbitrary functions. It computes
24783 @expr{Y}, @expr{F}, @expr{G}, and @expr{H} for all the data points,
24784 does a standard linear fit to find the values of @expr{A}, @expr{B},
24785 and @expr{C}, then uses the equation solver to solve for @expr{a,b,c}
24786 in terms of @expr{A,B,C}.
24787
24788 A remarkable number of models can be cast into this general form.
24789 We'll look at two examples here to see how it works. The power-law
24790 model @expr{y = a x^b} with two independent variables and two parameters
24791 can be rewritten as follows:
24792
24793 @example
24794 y = a x^b
24795 y = a exp(b ln(x))
24796 y = exp(ln(a) + b ln(x))
24797 ln(y) = ln(a) + b ln(x)
24798 @end example
24799
24800 @noindent
24801 which matches the desired form with
24802 @texline @math{Y = \ln(y)},
24803 @infoline @expr{Y = ln(y)},
24804 @texline @math{A = \ln(a)},
24805 @infoline @expr{A = ln(a)},
24806 @expr{F = 1}, @expr{B = b}, and
24807 @texline @math{G = \ln(x)}.
24808 @infoline @expr{G = ln(x)}.
24809 Calc thus computes the logarithms of your @expr{y} and @expr{x} values,
24810 does a linear fit for @expr{A} and @expr{B}, then solves to get
24811 @texline @math{a = \exp(A)}
24812 @infoline @expr{a = exp(A)}
24813 and @expr{b = B}.
24814
24815 Another interesting example is the ``quadratic'' model, which can
24816 be handled by expanding according to the distributive law.
24817
24818 @example
24819 y = a + b*(x - c)^2
24820 y = a + b c^2 - 2 b c x + b x^2
24821 @end example
24822
24823 @noindent
24824 which matches with @expr{Y = y}, @expr{A = a + b c^2}, @expr{F = 1},
24825 @expr{B = -2 b c}, @expr{G = x} (the @mathit{-2} factor could just as easily
24826 have been put into @expr{G} instead of @expr{B}), @expr{C = b}, and
24827 @expr{H = x^2}.
24828
24829 The Gaussian model looks quite complicated, but a closer examination
24830 shows that it's actually similar to the quadratic model but with an
24831 exponential that can be brought to the top and moved into @expr{Y}.
24832
24833 An example of a model that cannot be put into general linear
24834 form is a Gaussian with a constant background added on, i.e.,
24835 @expr{d} + the regular Gaussian formula. If you have a model like
24836 this, your best bet is to replace enough of your parameters with
24837 constants to make the model linearizable, then adjust the constants
24838 manually by doing a series of fits. You can compare the fits by
24839 graphing them, by examining the goodness-of-fit measures returned by
24840 @kbd{I a F}, or by some other method suitable to your application.
24841 Note that some models can be linearized in several ways. The
24842 Gaussian-plus-@var{d} model can be linearized by setting @expr{d}
24843 (the background) to a constant, or by setting @expr{b} (the standard
24844 deviation) and @expr{c} (the mean) to constants.
24845
24846 To fit a model with constants substituted for some parameters, just
24847 store suitable values in those parameter variables, then omit them
24848 from the list of parameters when you answer the variables prompt.
24849
24850 @tex
24851 \bigskip
24852 @end tex
24853
24854 A last desperate step would be to use the general-purpose
24855 @code{minimize} function rather than @code{fit}. After all, both
24856 functions solve the problem of minimizing an expression (the
24857 @texline @math{\chi^2}
24858 @infoline @expr{chi^2}
24859 sum) by adjusting certain parameters in the expression. The @kbd{a F}
24860 command is able to use a vastly more efficient algorithm due to its
24861 special knowledge about linear chi-square sums, but the @kbd{a N}
24862 command can do the same thing by brute force.
24863
24864 A compromise would be to pick out a few parameters without which the
24865 fit is linearizable, and use @code{minimize} on a call to @code{fit}
24866 which efficiently takes care of the rest of the parameters. The thing
24867 to be minimized would be the value of
24868 @texline @math{\chi^2}
24869 @infoline @expr{chi^2}
24870 returned as the fifth result of the @code{xfit} function:
24871
24872 @smallexample
24873 minimize(xfit(gaus(a,b,c,d,x), x, [a,b,c], data)_5, d, guess)
24874 @end smallexample
24875
24876 @noindent
24877 where @code{gaus} represents the Gaussian model with background,
24878 @code{data} represents the data matrix, and @code{guess} represents
24879 the initial guess for @expr{d} that @code{minimize} requires.
24880 This operation will only be, shall we say, extraordinarily slow
24881 rather than astronomically slow (as would be the case if @code{minimize}
24882 were used by itself to solve the problem).
24883
24884 @tex
24885 \bigskip
24886 @end tex
24887
24888 The @kbd{I a F} [@code{xfit}] command is somewhat trickier when
24889 nonlinear models are used. The second item in the result is the
24890 vector of ``raw'' parameters @expr{A}, @expr{B}, @expr{C}. The
24891 covariance matrix is written in terms of those raw parameters.
24892 The fifth item is a vector of @dfn{filter} expressions. This
24893 is the empty vector @samp{[]} if the raw parameters were the same
24894 as the requested parameters, i.e., if @expr{A = a}, @expr{B = b},
24895 and so on (which is always true if the model is already linear
24896 in the parameters as written, e.g., for polynomial fits). If the
24897 parameters had to be rearranged, the fifth item is instead a vector
24898 of one formula per parameter in the original model. The raw
24899 parameters are expressed in these ``filter'' formulas as
24900 @samp{fitdummy(1)} for @expr{A}, @samp{fitdummy(2)} for @expr{B},
24901 and so on.
24902
24903 When Calc needs to modify the model to return the result, it replaces
24904 @samp{fitdummy(1)} in all the filters with the first item in the raw
24905 parameters list, and so on for the other raw parameters, then
24906 evaluates the resulting filter formulas to get the actual parameter
24907 values to be substituted into the original model. In the case of
24908 @kbd{H a F} and @kbd{I a F} where the parameters must be error forms,
24909 Calc uses the square roots of the diagonal entries of the covariance
24910 matrix as error values for the raw parameters, then lets Calc's
24911 standard error-form arithmetic take it from there.
24912
24913 If you use @kbd{I a F} with a nonlinear model, be sure to remember
24914 that the covariance matrix is in terms of the raw parameters,
24915 @emph{not} the actual requested parameters. It's up to you to
24916 figure out how to interpret the covariances in the presence of
24917 nontrivial filter functions.
24918
24919 Things are also complicated when the input contains error forms.
24920 Suppose there are three independent and dependent variables, @expr{x},
24921 @expr{y}, and @expr{z}, one or more of which are error forms in the
24922 data. Calc combines all the error values by taking the square root
24923 of the sum of the squares of the errors. It then changes @expr{x}
24924 and @expr{y} to be plain numbers, and makes @expr{z} into an error
24925 form with this combined error. The @expr{Y(x,y,z)} part of the
24926 linearized model is evaluated, and the result should be an error
24927 form. The error part of that result is used for
24928 @texline @math{\sigma_i}
24929 @infoline @expr{sigma_i}
24930 for the data point. If for some reason @expr{Y(x,y,z)} does not return
24931 an error form, the combined error from @expr{z} is used directly for
24932 @texline @math{\sigma_i}.
24933 @infoline @expr{sigma_i}.
24934 Finally, @expr{z} is also stripped of its error
24935 for use in computing @expr{F(x,y,z)}, @expr{G(x,y,z)} and so on;
24936 the righthand side of the linearized model is computed in regular
24937 arithmetic with no error forms.
24938
24939 (While these rules may seem complicated, they are designed to do
24940 the most reasonable thing in the typical case that @expr{Y(x,y,z)}
24941 depends only on the dependent variable @expr{z}, and in fact is
24942 often simply equal to @expr{z}. For common cases like polynomials
24943 and multilinear models, the combined error is simply used as the
24944 @texline @math{\sigma}
24945 @infoline @expr{sigma}
24946 for the data point with no further ado.)
24947
24948 @tex
24949 \bigskip
24950 @end tex
24951
24952 @vindex FitRules
24953 It may be the case that the model you wish to use is linearizable,
24954 but Calc's built-in rules are unable to figure it out. Calc uses
24955 its algebraic rewrite mechanism to linearize a model. The rewrite
24956 rules are kept in the variable @code{FitRules}. You can edit this
24957 variable using the @kbd{s e FitRules} command; in fact, there is
24958 a special @kbd{s F} command just for editing @code{FitRules}.
24959 @xref{Operations on Variables}.
24960
24961 @xref{Rewrite Rules}, for a discussion of rewrite rules.
24962
24963 @ignore
24964 @starindex
24965 @end ignore
24966 @tindex fitvar
24967 @ignore
24968 @starindex
24969 @end ignore
24970 @ignore
24971 @mindex @idots
24972 @end ignore
24973 @tindex fitparam
24974 @ignore
24975 @starindex
24976 @end ignore
24977 @ignore
24978 @mindex @null
24979 @end ignore
24980 @tindex fitmodel
24981 @ignore
24982 @starindex
24983 @end ignore
24984 @ignore
24985 @mindex @null
24986 @end ignore
24987 @tindex fitsystem
24988 @ignore
24989 @starindex
24990 @end ignore
24991 @ignore
24992 @mindex @null
24993 @end ignore
24994 @tindex fitdummy
24995 Calc uses @code{FitRules} as follows. First, it converts the model
24996 to an equation if necessary and encloses the model equation in a
24997 call to the function @code{fitmodel} (which is not actually a defined
24998 function in Calc; it is only used as a placeholder by the rewrite rules).
24999 Parameter variables are renamed to function calls @samp{fitparam(1)},
25000 @samp{fitparam(2)}, and so on, and independent variables are renamed
25001 to @samp{fitvar(1)}, @samp{fitvar(2)}, etc. The dependent variable
25002 is the highest-numbered @code{fitvar}. For example, the power law
25003 model @expr{a x^b} is converted to @expr{y = a x^b}, then to
25004
25005 @smallexample
25006 @group
25007 fitmodel(fitvar(2) = fitparam(1) fitvar(1)^fitparam(2))
25008 @end group
25009 @end smallexample
25010
25011 Calc then applies the rewrites as if by @samp{C-u 0 a r FitRules}.
25012 (The zero prefix means that rewriting should continue until no further
25013 changes are possible.)
25014
25015 When rewriting is complete, the @code{fitmodel} call should have
25016 been replaced by a @code{fitsystem} call that looks like this:
25017
25018 @example
25019 fitsystem(@var{Y}, @var{FGH}, @var{abc})
25020 @end example
25021
25022 @noindent
25023 where @var{Y} is a formula that describes the function @expr{Y(x,y,z)},
25024 @var{FGH} is the vector of formulas @expr{[F(x,y,z), G(x,y,z), H(x,y,z)]},
25025 and @var{abc} is the vector of parameter filters which refer to the
25026 raw parameters as @samp{fitdummy(1)} for @expr{A}, @samp{fitdummy(2)}
25027 for @expr{B}, etc. While the number of raw parameters (the length of
25028 the @var{FGH} vector) is usually the same as the number of original
25029 parameters (the length of the @var{abc} vector), this is not required.
25030
25031 The power law model eventually boils down to
25032
25033 @smallexample
25034 @group
25035 fitsystem(ln(fitvar(2)),
25036 [1, ln(fitvar(1))],
25037 [exp(fitdummy(1)), fitdummy(2)])
25038 @end group
25039 @end smallexample
25040
25041 The actual implementation of @code{FitRules} is complicated; it
25042 proceeds in four phases. First, common rearrangements are done
25043 to try to bring linear terms together and to isolate functions like
25044 @code{exp} and @code{ln} either all the way ``out'' (so that they
25045 can be put into @var{Y}) or all the way ``in'' (so that they can
25046 be put into @var{abc} or @var{FGH}). In particular, all
25047 non-constant powers are converted to logs-and-exponentials form,
25048 and the distributive law is used to expand products of sums.
25049 Quotients are rewritten to use the @samp{fitinv} function, where
25050 @samp{fitinv(x)} represents @expr{1/x} while the @code{FitRules}
25051 are operating. (The use of @code{fitinv} makes recognition of
25052 linear-looking forms easier.) If you modify @code{FitRules}, you
25053 will probably only need to modify the rules for this phase.
25054
25055 Phase two, whose rules can actually also apply during phases one
25056 and three, first rewrites @code{fitmodel} to a two-argument
25057 form @samp{fitmodel(@var{Y}, @var{model})}, where @var{Y} is
25058 initially zero and @var{model} has been changed from @expr{a=b}
25059 to @expr{a-b} form. It then tries to peel off invertible functions
25060 from the outside of @var{model} and put them into @var{Y} instead,
25061 calling the equation solver to invert the functions. Finally, when
25062 this is no longer possible, the @code{fitmodel} is changed to a
25063 four-argument @code{fitsystem}, where the fourth argument is
25064 @var{model} and the @var{FGH} and @var{abc} vectors are initially
25065 empty. (The last vector is really @var{ABC}, corresponding to
25066 raw parameters, for now.)
25067
25068 Phase three converts a sum of items in the @var{model} to a sum
25069 of @samp{fitpart(@var{a}, @var{b}, @var{c})} terms which represent
25070 terms @samp{@var{a}*@var{b}*@var{c}} of the sum, where @var{a}
25071 is all factors that do not involve any variables, @var{b} is all
25072 factors that involve only parameters, and @var{c} is the factors
25073 that involve only independent variables. (If this decomposition
25074 is not possible, the rule set will not complete and Calc will
25075 complain that the model is too complex.) Then @code{fitpart}s
25076 with equal @var{b} or @var{c} components are merged back together
25077 using the distributive law in order to minimize the number of
25078 raw parameters needed.
25079
25080 Phase four moves the @code{fitpart} terms into the @var{FGH} and
25081 @var{ABC} vectors. Also, some of the algebraic expansions that
25082 were done in phase 1 are undone now to make the formulas more
25083 computationally efficient. Finally, it calls the solver one more
25084 time to convert the @var{ABC} vector to an @var{abc} vector, and
25085 removes the fourth @var{model} argument (which by now will be zero)
25086 to obtain the three-argument @code{fitsystem} that the linear
25087 least-squares solver wants to see.
25088
25089 @ignore
25090 @starindex
25091 @end ignore
25092 @ignore
25093 @mindex hasfit@idots
25094 @end ignore
25095 @tindex hasfitparams
25096 @ignore
25097 @starindex
25098 @end ignore
25099 @ignore
25100 @mindex @null
25101 @end ignore
25102 @tindex hasfitvars
25103 Two functions which are useful in connection with @code{FitRules}
25104 are @samp{hasfitparams(x)} and @samp{hasfitvars(x)}, which check
25105 whether @expr{x} refers to any parameters or independent variables,
25106 respectively. Specifically, these functions return ``true'' if the
25107 argument contains any @code{fitparam} (or @code{fitvar}) function
25108 calls, and ``false'' otherwise. (Recall that ``true'' means a
25109 nonzero number, and ``false'' means zero. The actual nonzero number
25110 returned is the largest @var{n} from all the @samp{fitparam(@var{n})}s
25111 or @samp{fitvar(@var{n})}s, respectively, that appear in the formula.)
25112
25113 @tex
25114 \bigskip
25115 @end tex
25116
25117 The @code{fit} function in algebraic notation normally takes four
25118 arguments, @samp{fit(@var{model}, @var{vars}, @var{params}, @var{data})},
25119 where @var{model} is the model formula as it would be typed after
25120 @kbd{a F '}, @var{vars} is the independent variable or a vector of
25121 independent variables, @var{params} likewise gives the parameter(s),
25122 and @var{data} is the data matrix. Note that the length of @var{vars}
25123 must be equal to the number of rows in @var{data} if @var{model} is
25124 an equation, or one less than the number of rows if @var{model} is
25125 a plain formula. (Actually, a name for the dependent variable is
25126 allowed but will be ignored in the plain-formula case.)
25127
25128 If @var{params} is omitted, the parameters are all variables in
25129 @var{model} except those that appear in @var{vars}. If @var{vars}
25130 is also omitted, Calc sorts all the variables that appear in
25131 @var{model} alphabetically and uses the higher ones for @var{vars}
25132 and the lower ones for @var{params}.
25133
25134 Alternatively, @samp{fit(@var{modelvec}, @var{data})} is allowed
25135 where @var{modelvec} is a 2- or 3-vector describing the model
25136 and variables, as discussed previously.
25137
25138 If Calc is unable to do the fit, the @code{fit} function is left
25139 in symbolic form, ordinarily with an explanatory message. The
25140 message will be ``Model expression is too complex'' if the
25141 linearizer was unable to put the model into the required form.
25142
25143 The @code{efit} (corresponding to @kbd{H a F}) and @code{xfit}
25144 (for @kbd{I a F}) functions are completely analogous.
25145
25146 @node Interpolation, , Curve Fitting Details, Curve Fitting
25147 @subsection Polynomial Interpolation
25148
25149 @kindex a p
25150 @pindex calc-poly-interp
25151 @tindex polint
25152 The @kbd{a p} (@code{calc-poly-interp}) [@code{polint}] command does
25153 a polynomial interpolation at a particular @expr{x} value. It takes
25154 two arguments from the stack: A data matrix of the sort used by
25155 @kbd{a F}, and a single number which represents the desired @expr{x}
25156 value. Calc effectively does an exact polynomial fit as if by @kbd{a F i},
25157 then substitutes the @expr{x} value into the result in order to get an
25158 approximate @expr{y} value based on the fit. (Calc does not actually
25159 use @kbd{a F i}, however; it uses a direct method which is both more
25160 efficient and more numerically stable.)
25161
25162 The result of @kbd{a p} is actually a vector of two values: The @expr{y}
25163 value approximation, and an error measure @expr{dy} that reflects Calc's
25164 estimation of the probable error of the approximation at that value of
25165 @expr{x}. If the input @expr{x} is equal to any of the @expr{x} values
25166 in the data matrix, the output @expr{y} will be the corresponding @expr{y}
25167 value from the matrix, and the output @expr{dy} will be exactly zero.
25168
25169 A prefix argument of 2 causes @kbd{a p} to take separate x- and
25170 y-vectors from the stack instead of one data matrix.
25171
25172 If @expr{x} is a vector of numbers, @kbd{a p} will return a matrix of
25173 interpolated results for each of those @expr{x} values. (The matrix will
25174 have two columns, the @expr{y} values and the @expr{dy} values.)
25175 If @expr{x} is a formula instead of a number, the @code{polint} function
25176 remains in symbolic form; use the @kbd{a "} command to expand it out to
25177 a formula that describes the fit in symbolic terms.
25178
25179 In all cases, the @kbd{a p} command leaves the data vectors or matrix
25180 on the stack. Only the @expr{x} value is replaced by the result.
25181
25182 @kindex H a p
25183 @tindex ratint
25184 The @kbd{H a p} [@code{ratint}] command does a rational function
25185 interpolation. It is used exactly like @kbd{a p}, except that it
25186 uses as its model the quotient of two polynomials. If there are
25187 @expr{N} data points, the numerator and denominator polynomials will
25188 each have degree @expr{N/2} (if @expr{N} is odd, the denominator will
25189 have degree one higher than the numerator).
25190
25191 Rational approximations have the advantage that they can accurately
25192 describe functions that have poles (points at which the function's value
25193 goes to infinity, so that the denominator polynomial of the approximation
25194 goes to zero). If @expr{x} corresponds to a pole of the fitted rational
25195 function, then the result will be a division by zero. If Infinite mode
25196 is enabled, the result will be @samp{[uinf, uinf]}.
25197
25198 There is no way to get the actual coefficients of the rational function
25199 used by @kbd{H a p}. (The algorithm never generates these coefficients
25200 explicitly, and quotients of polynomials are beyond @w{@kbd{a F}}'s
25201 capabilities to fit.)
25202
25203 @node Summations, Logical Operations, Curve Fitting, Algebra
25204 @section Summations
25205
25206 @noindent
25207 @cindex Summation of a series
25208 @kindex a +
25209 @pindex calc-summation
25210 @tindex sum
25211 The @kbd{a +} (@code{calc-summation}) [@code{sum}] command computes
25212 the sum of a formula over a certain range of index values. The formula
25213 is taken from the top of the stack; the command prompts for the
25214 name of the summation index variable, the lower limit of the
25215 sum (any formula), and the upper limit of the sum. If you
25216 enter a blank line at any of these prompts, that prompt and
25217 any later ones are answered by reading additional elements from
25218 the stack. Thus, @kbd{' k^2 @key{RET} ' k @key{RET} 1 @key{RET} 5 @key{RET} a + @key{RET}}
25219 produces the result 55.
25220 @tex
25221 \turnoffactive
25222 $$ \sum_{k=1}^5 k^2 = 55 $$
25223 @end tex
25224
25225 The choice of index variable is arbitrary, but it's best not to
25226 use a variable with a stored value. In particular, while
25227 @code{i} is often a favorite index variable, it should be avoided
25228 in Calc because @code{i} has the imaginary constant @expr{(0, 1)}
25229 as a value. If you pressed @kbd{=} on a sum over @code{i}, it would
25230 be changed to a nonsensical sum over the ``variable'' @expr{(0, 1)}!
25231 If you really want to use @code{i} as an index variable, use
25232 @w{@kbd{s u i @key{RET}}} first to ``unstore'' this variable.
25233 (@xref{Storing Variables}.)
25234
25235 A numeric prefix argument steps the index by that amount rather
25236 than by one. Thus @kbd{' a_k @key{RET} C-u -2 a + k @key{RET} 10 @key{RET} 0 @key{RET}}
25237 yields @samp{a_10 + a_8 + a_6 + a_4 + a_2 + a_0}. A prefix
25238 argument of plain @kbd{C-u} causes @kbd{a +} to prompt for the
25239 step value, in which case you can enter any formula or enter
25240 a blank line to take the step value from the stack. With the
25241 @kbd{C-u} prefix, @kbd{a +} can take up to five arguments from
25242 the stack: The formula, the variable, the lower limit, the
25243 upper limit, and (at the top of the stack), the step value.
25244
25245 Calc knows how to do certain sums in closed form. For example,
25246 @samp{sum(6 k^2, k, 1, n) = @w{2 n^3} + 3 n^2 + n}. In particular,
25247 this is possible if the formula being summed is polynomial or
25248 exponential in the index variable. Sums of logarithms are
25249 transformed into logarithms of products. Sums of trigonometric
25250 and hyperbolic functions are transformed to sums of exponentials
25251 and then done in closed form. Also, of course, sums in which the
25252 lower and upper limits are both numbers can always be evaluated
25253 just by grinding them out, although Calc will use closed forms
25254 whenever it can for the sake of efficiency.
25255
25256 The notation for sums in algebraic formulas is
25257 @samp{sum(@var{expr}, @var{var}, @var{low}, @var{high}, @var{step})}.
25258 If @var{step} is omitted, it defaults to one. If @var{high} is
25259 omitted, @var{low} is actually the upper limit and the lower limit
25260 is one. If @var{low} is also omitted, the limits are @samp{-inf}
25261 and @samp{inf}, respectively.
25262
25263 Infinite sums can sometimes be evaluated: @samp{sum(.5^k, k, 1, inf)}
25264 returns @expr{1}. This is done by evaluating the sum in closed
25265 form (to @samp{1. - 0.5^n} in this case), then evaluating this
25266 formula with @code{n} set to @code{inf}. Calc's usual rules
25267 for ``infinite'' arithmetic can find the answer from there. If
25268 infinite arithmetic yields a @samp{nan}, or if the sum cannot be
25269 solved in closed form, Calc leaves the @code{sum} function in
25270 symbolic form. @xref{Infinities}.
25271
25272 As a special feature, if the limits are infinite (or omitted, as
25273 described above) but the formula includes vectors subscripted by
25274 expressions that involve the iteration variable, Calc narrows
25275 the limits to include only the range of integers which result in
25276 valid subscripts for the vector. For example, the sum
25277 @samp{sum(k [a,b,c,d,e,f,g]_(2k),k)} evaluates to @samp{b + 2 d + 3 f}.
25278
25279 The limits of a sum do not need to be integers. For example,
25280 @samp{sum(a_k, k, 0, 2 n, n)} produces @samp{a_0 + a_n + a_(2 n)}.
25281 Calc computes the number of iterations using the formula
25282 @samp{1 + (@var{high} - @var{low}) / @var{step}}, which must,
25283 after simplification as if by @kbd{a s}, evaluate to an integer.
25284
25285 If the number of iterations according to the above formula does
25286 not come out to an integer, the sum is invalid and will be left
25287 in symbolic form. However, closed forms are still supplied, and
25288 you are on your honor not to misuse the resulting formulas by
25289 substituting mismatched bounds into them. For example,
25290 @samp{sum(k, k, 1, 10, 2)} is invalid, but Calc will go ahead and
25291 evaluate the closed form solution for the limits 1 and 10 to get
25292 the rather dubious answer, 29.25.
25293
25294 If the lower limit is greater than the upper limit (assuming a
25295 positive step size), the result is generally zero. However,
25296 Calc only guarantees a zero result when the upper limit is
25297 exactly one step less than the lower limit, i.e., if the number
25298 of iterations is @mathit{-1}. Thus @samp{sum(f(k), k, n, n-1)} is zero
25299 but the sum from @samp{n} to @samp{n-2} may report a nonzero value
25300 if Calc used a closed form solution.
25301
25302 Calc's logical predicates like @expr{a < b} return 1 for ``true''
25303 and 0 for ``false.'' @xref{Logical Operations}. This can be
25304 used to advantage for building conditional sums. For example,
25305 @samp{sum(prime(k)*k^2, k, 1, 20)} is the sum of the squares of all
25306 prime numbers from 1 to 20; the @code{prime} predicate returns 1 if
25307 its argument is prime and 0 otherwise. You can read this expression
25308 as ``the sum of @expr{k^2}, where @expr{k} is prime.'' Indeed,
25309 @samp{sum(prime(k)*k^2, k)} would represent the sum of @emph{all} primes
25310 squared, since the limits default to plus and minus infinity, but
25311 there are no such sums that Calc's built-in rules can do in
25312 closed form.
25313
25314 As another example, @samp{sum((k != k_0) * f(k), k, 1, n)} is the
25315 sum of @expr{f(k)} for all @expr{k} from 1 to @expr{n}, excluding
25316 one value @expr{k_0}. Slightly more tricky is the summand
25317 @samp{(k != k_0) / (k - k_0)}, which is an attempt to describe
25318 the sum of all @expr{1/(k-k_0)} except at @expr{k = k_0}, where
25319 this would be a division by zero. But at @expr{k = k_0}, this
25320 formula works out to the indeterminate form @expr{0 / 0}, which
25321 Calc will not assume is zero. Better would be to use
25322 @samp{(k != k_0) ? 1/(k-k_0) : 0}; the @samp{? :} operator does
25323 an ``if-then-else'' test: This expression says, ``if
25324 @texline @math{k \ne k_0},
25325 @infoline @expr{k != k_0},
25326 then @expr{1/(k-k_0)}, else zero.'' Now the formula @expr{1/(k-k_0)}
25327 will not even be evaluated by Calc when @expr{k = k_0}.
25328
25329 @cindex Alternating sums
25330 @kindex a -
25331 @pindex calc-alt-summation
25332 @tindex asum
25333 The @kbd{a -} (@code{calc-alt-summation}) [@code{asum}] command
25334 computes an alternating sum. Successive terms of the sequence
25335 are given alternating signs, with the first term (corresponding
25336 to the lower index value) being positive. Alternating sums
25337 are converted to normal sums with an extra term of the form
25338 @samp{(-1)^(k-@var{low})}. This formula is adjusted appropriately
25339 if the step value is other than one. For example, the Taylor
25340 series for the sine function is @samp{asum(x^k / k!, k, 1, inf, 2)}.
25341 (Calc cannot evaluate this infinite series, but it can approximate
25342 it if you replace @code{inf} with any particular odd number.)
25343 Calc converts this series to a regular sum with a step of one,
25344 namely @samp{sum((-1)^k x^(2k+1) / (2k+1)!, k, 0, inf)}.
25345
25346 @cindex Product of a sequence
25347 @kindex a *
25348 @pindex calc-product
25349 @tindex prod
25350 The @kbd{a *} (@code{calc-product}) [@code{prod}] command is
25351 the analogous way to take a product of many terms. Calc also knows
25352 some closed forms for products, such as @samp{prod(k, k, 1, n) = n!}.
25353 Conditional products can be written @samp{prod(k^prime(k), k, 1, n)}
25354 or @samp{prod(prime(k) ? k : 1, k, 1, n)}.
25355
25356 @kindex a T
25357 @pindex calc-tabulate
25358 @tindex table
25359 The @kbd{a T} (@code{calc-tabulate}) [@code{table}] command
25360 evaluates a formula at a series of iterated index values, just
25361 like @code{sum} and @code{prod}, but its result is simply a
25362 vector of the results. For example, @samp{table(a_i, i, 1, 7, 2)}
25363 produces @samp{[a_1, a_3, a_5, a_7]}.
25364
25365 @node Logical Operations, Rewrite Rules, Summations, Algebra
25366 @section Logical Operations
25367
25368 @noindent
25369 The following commands and algebraic functions return true/false values,
25370 where 1 represents ``true'' and 0 represents ``false.'' In cases where
25371 a truth value is required (such as for the condition part of a rewrite
25372 rule, or as the condition for a @w{@kbd{Z [ Z ]}} control structure), any
25373 nonzero value is accepted to mean ``true.'' (Specifically, anything
25374 for which @code{dnonzero} returns 1 is ``true,'' and anything for
25375 which @code{dnonzero} returns 0 or cannot decide is assumed ``false.''
25376 Note that this means that @w{@kbd{Z [ Z ]}} will execute the ``then''
25377 portion if its condition is provably true, but it will execute the
25378 ``else'' portion for any condition like @expr{a = b} that is not
25379 provably true, even if it might be true. Algebraic functions that
25380 have conditions as arguments, like @code{? :} and @code{&&}, remain
25381 unevaluated if the condition is neither provably true nor provably
25382 false. @xref{Declarations}.)
25383
25384 @kindex a =
25385 @pindex calc-equal-to
25386 @tindex eq
25387 @tindex =
25388 @tindex ==
25389 The @kbd{a =} (@code{calc-equal-to}) command, or @samp{eq(a,b)} function
25390 (which can also be written @samp{a = b} or @samp{a == b} in an algebraic
25391 formula) is true if @expr{a} and @expr{b} are equal, either because they
25392 are identical expressions, or because they are numbers which are
25393 numerically equal. (Thus the integer 1 is considered equal to the float
25394 1.0.) If the equality of @expr{a} and @expr{b} cannot be determined,
25395 the comparison is left in symbolic form. Note that as a command, this
25396 operation pops two values from the stack and pushes back either a 1 or
25397 a 0, or a formula @samp{a = b} if the values' equality cannot be determined.
25398
25399 Many Calc commands use @samp{=} formulas to represent @dfn{equations}.
25400 For example, the @kbd{a S} (@code{calc-solve-for}) command rearranges
25401 an equation to solve for a given variable. The @kbd{a M}
25402 (@code{calc-map-equation}) command can be used to apply any
25403 function to both sides of an equation; for example, @kbd{2 a M *}
25404 multiplies both sides of the equation by two. Note that just
25405 @kbd{2 *} would not do the same thing; it would produce the formula
25406 @samp{2 (a = b)} which represents 2 if the equality is true or
25407 zero if not.
25408
25409 The @code{eq} function with more than two arguments (e.g., @kbd{C-u 3 a =}
25410 or @samp{a = b = c}) tests if all of its arguments are equal. In
25411 algebraic notation, the @samp{=} operator is unusual in that it is
25412 neither left- nor right-associative: @samp{a = b = c} is not the
25413 same as @samp{(a = b) = c} or @samp{a = (b = c)} (which each compare
25414 one variable with the 1 or 0 that results from comparing two other
25415 variables).
25416
25417 @kindex a #
25418 @pindex calc-not-equal-to
25419 @tindex neq
25420 @tindex !=
25421 The @kbd{a #} (@code{calc-not-equal-to}) command, or @samp{neq(a,b)} or
25422 @samp{a != b} function, is true if @expr{a} and @expr{b} are not equal.
25423 This also works with more than two arguments; @samp{a != b != c != d}
25424 tests that all four of @expr{a}, @expr{b}, @expr{c}, and @expr{d} are
25425 distinct numbers.
25426
25427 @kindex a <
25428 @tindex lt
25429 @ignore
25430 @mindex @idots
25431 @end ignore
25432 @kindex a >
25433 @ignore
25434 @mindex @null
25435 @end ignore
25436 @kindex a [
25437 @ignore
25438 @mindex @null
25439 @end ignore
25440 @kindex a ]
25441 @pindex calc-less-than
25442 @pindex calc-greater-than
25443 @pindex calc-less-equal
25444 @pindex calc-greater-equal
25445 @ignore
25446 @mindex @null
25447 @end ignore
25448 @tindex gt
25449 @ignore
25450 @mindex @null
25451 @end ignore
25452 @tindex leq
25453 @ignore
25454 @mindex @null
25455 @end ignore
25456 @tindex geq
25457 @ignore
25458 @mindex @null
25459 @end ignore
25460 @tindex <
25461 @ignore
25462 @mindex @null
25463 @end ignore
25464 @tindex >
25465 @ignore
25466 @mindex @null
25467 @end ignore
25468 @tindex <=
25469 @ignore
25470 @mindex @null
25471 @end ignore
25472 @tindex >=
25473 The @kbd{a <} (@code{calc-less-than}) [@samp{lt(a,b)} or @samp{a < b}]
25474 operation is true if @expr{a} is less than @expr{b}. Similar functions
25475 are @kbd{a >} (@code{calc-greater-than}) [@samp{gt(a,b)} or @samp{a > b}],
25476 @kbd{a [} (@code{calc-less-equal}) [@samp{leq(a,b)} or @samp{a <= b}], and
25477 @kbd{a ]} (@code{calc-greater-equal}) [@samp{geq(a,b)} or @samp{a >= b}].
25478
25479 While the inequality functions like @code{lt} do not accept more
25480 than two arguments, the syntax @w{@samp{a <= b < c}} is translated to an
25481 equivalent expression involving intervals: @samp{b in [a .. c)}.
25482 (See the description of @code{in} below.) All four combinations
25483 of @samp{<} and @samp{<=} are allowed, or any of the four combinations
25484 of @samp{>} and @samp{>=}. Four-argument constructions like
25485 @samp{a < b < c < d}, and mixtures like @w{@samp{a < b = c}} that
25486 involve both equalities and inequalities, are not allowed.
25487
25488 @kindex a .
25489 @pindex calc-remove-equal
25490 @tindex rmeq
25491 The @kbd{a .} (@code{calc-remove-equal}) [@code{rmeq}] command extracts
25492 the righthand side of the equation or inequality on the top of the
25493 stack. It also works elementwise on vectors. For example, if
25494 @samp{[x = 2.34, y = z / 2]} is on the stack, then @kbd{a .} produces
25495 @samp{[2.34, z / 2]}. As a special case, if the righthand side is a
25496 variable and the lefthand side is a number (as in @samp{2.34 = x}), then
25497 Calc keeps the lefthand side instead. Finally, this command works with
25498 assignments @samp{x := 2.34} as well as equations, always taking the
25499 the righthand side, and for @samp{=>} (evaluates-to) operators, always
25500 taking the lefthand side.
25501
25502 @kindex a &
25503 @pindex calc-logical-and
25504 @tindex land
25505 @tindex &&
25506 The @kbd{a &} (@code{calc-logical-and}) [@samp{land(a,b)} or @samp{a && b}]
25507 function is true if both of its arguments are true, i.e., are
25508 non-zero numbers. In this case, the result will be either @expr{a} or
25509 @expr{b}, chosen arbitrarily. If either argument is zero, the result is
25510 zero. Otherwise, the formula is left in symbolic form.
25511
25512 @kindex a |
25513 @pindex calc-logical-or
25514 @tindex lor
25515 @tindex ||
25516 The @kbd{a |} (@code{calc-logical-or}) [@samp{lor(a,b)} or @samp{a || b}]
25517 function is true if either or both of its arguments are true (nonzero).
25518 The result is whichever argument was nonzero, choosing arbitrarily if both
25519 are nonzero. If both @expr{a} and @expr{b} are zero, the result is
25520 zero.
25521
25522 @kindex a !
25523 @pindex calc-logical-not
25524 @tindex lnot
25525 @tindex !
25526 The @kbd{a !} (@code{calc-logical-not}) [@samp{lnot(a)} or @samp{!@: a}]
25527 function is true if @expr{a} is false (zero), or false if @expr{a} is
25528 true (nonzero). It is left in symbolic form if @expr{a} is not a
25529 number.
25530
25531 @kindex a :
25532 @pindex calc-logical-if
25533 @tindex if
25534 @ignore
25535 @mindex ? :
25536 @end ignore
25537 @tindex ?
25538 @ignore
25539 @mindex @null
25540 @end ignore
25541 @tindex :
25542 @cindex Arguments, not evaluated
25543 The @kbd{a :} (@code{calc-logical-if}) [@samp{if(a,b,c)} or @samp{a ? b :@: c}]
25544 function is equal to either @expr{b} or @expr{c} if @expr{a} is a nonzero
25545 number or zero, respectively. If @expr{a} is not a number, the test is
25546 left in symbolic form and neither @expr{b} nor @expr{c} is evaluated in
25547 any way. In algebraic formulas, this is one of the few Calc functions
25548 whose arguments are not automatically evaluated when the function itself
25549 is evaluated. The others are @code{lambda}, @code{quote}, and
25550 @code{condition}.
25551
25552 One minor surprise to watch out for is that the formula @samp{a?3:4}
25553 will not work because the @samp{3:4} is parsed as a fraction instead of
25554 as three separate symbols. Type something like @samp{a ? 3 : 4} or
25555 @samp{a?(3):4} instead.
25556
25557 As a special case, if @expr{a} evaluates to a vector, then both @expr{b}
25558 and @expr{c} are evaluated; the result is a vector of the same length
25559 as @expr{a} whose elements are chosen from corresponding elements of
25560 @expr{b} and @expr{c} according to whether each element of @expr{a}
25561 is zero or nonzero. Each of @expr{b} and @expr{c} must be either a
25562 vector of the same length as @expr{a}, or a non-vector which is matched
25563 with all elements of @expr{a}.
25564
25565 @kindex a @{
25566 @pindex calc-in-set
25567 @tindex in
25568 The @kbd{a @{} (@code{calc-in-set}) [@samp{in(a,b)}] function is true if
25569 the number @expr{a} is in the set of numbers represented by @expr{b}.
25570 If @expr{b} is an interval form, @expr{a} must be one of the values
25571 encompassed by the interval. If @expr{b} is a vector, @expr{a} must be
25572 equal to one of the elements of the vector. (If any vector elements are
25573 intervals, @expr{a} must be in any of the intervals.) If @expr{b} is a
25574 plain number, @expr{a} must be numerically equal to @expr{b}.
25575 @xref{Set Operations}, for a group of commands that manipulate sets
25576 of this sort.
25577
25578 @ignore
25579 @starindex
25580 @end ignore
25581 @tindex typeof
25582 The @samp{typeof(a)} function produces an integer or variable which
25583 characterizes @expr{a}. If @expr{a} is a number, vector, or variable,
25584 the result will be one of the following numbers:
25585
25586 @example
25587 1 Integer
25588 2 Fraction
25589 3 Floating-point number
25590 4 HMS form
25591 5 Rectangular complex number
25592 6 Polar complex number
25593 7 Error form
25594 8 Interval form
25595 9 Modulo form
25596 10 Date-only form
25597 11 Date/time form
25598 12 Infinity (inf, uinf, or nan)
25599 100 Variable
25600 101 Vector (but not a matrix)
25601 102 Matrix
25602 @end example
25603
25604 Otherwise, @expr{a} is a formula, and the result is a variable which
25605 represents the name of the top-level function call.
25606
25607 @ignore
25608 @starindex
25609 @end ignore
25610 @tindex integer
25611 @ignore
25612 @starindex
25613 @end ignore
25614 @tindex real
25615 @ignore
25616 @starindex
25617 @end ignore
25618 @tindex constant
25619 The @samp{integer(a)} function returns true if @expr{a} is an integer.
25620 The @samp{real(a)} function
25621 is true if @expr{a} is a real number, either integer, fraction, or
25622 float. The @samp{constant(a)} function returns true if @expr{a} is
25623 any of the objects for which @code{typeof} would produce an integer
25624 code result except for variables, and provided that the components of
25625 an object like a vector or error form are themselves constant.
25626 Note that infinities do not satisfy any of these tests, nor do
25627 special constants like @code{pi} and @code{e}.
25628
25629 @xref{Declarations}, for a set of similar functions that recognize
25630 formulas as well as actual numbers. For example, @samp{dint(floor(x))}
25631 is true because @samp{floor(x)} is provably integer-valued, but
25632 @samp{integer(floor(x))} does not because @samp{floor(x)} is not
25633 literally an integer constant.
25634
25635 @ignore
25636 @starindex
25637 @end ignore
25638 @tindex refers
25639 The @samp{refers(a,b)} function is true if the variable (or sub-expression)
25640 @expr{b} appears in @expr{a}, or false otherwise. Unlike the other
25641 tests described here, this function returns a definite ``no'' answer
25642 even if its arguments are still in symbolic form. The only case where
25643 @code{refers} will be left unevaluated is if @expr{a} is a plain
25644 variable (different from @expr{b}).
25645
25646 @ignore
25647 @starindex
25648 @end ignore
25649 @tindex negative
25650 The @samp{negative(a)} function returns true if @expr{a} ``looks'' negative,
25651 because it is a negative number, because it is of the form @expr{-x},
25652 or because it is a product or quotient with a term that looks negative.
25653 This is most useful in rewrite rules. Beware that @samp{negative(a)}
25654 evaluates to 1 or 0 for @emph{any} argument @expr{a}, so it can only
25655 be stored in a formula if the default simplifications are turned off
25656 first with @kbd{m O} (or if it appears in an unevaluated context such
25657 as a rewrite rule condition).
25658
25659 @ignore
25660 @starindex
25661 @end ignore
25662 @tindex variable
25663 The @samp{variable(a)} function is true if @expr{a} is a variable,
25664 or false if not. If @expr{a} is a function call, this test is left
25665 in symbolic form. Built-in variables like @code{pi} and @code{inf}
25666 are considered variables like any others by this test.
25667
25668 @ignore
25669 @starindex
25670 @end ignore
25671 @tindex nonvar
25672 The @samp{nonvar(a)} function is true if @expr{a} is a non-variable.
25673 If its argument is a variable it is left unsimplified; it never
25674 actually returns zero. However, since Calc's condition-testing
25675 commands consider ``false'' anything not provably true, this is
25676 often good enough.
25677
25678 @ignore
25679 @starindex
25680 @end ignore
25681 @tindex lin
25682 @ignore
25683 @starindex
25684 @end ignore
25685 @tindex linnt
25686 @ignore
25687 @starindex
25688 @end ignore
25689 @tindex islin
25690 @ignore
25691 @starindex
25692 @end ignore
25693 @tindex islinnt
25694 @cindex Linearity testing
25695 The functions @code{lin}, @code{linnt}, @code{islin}, and @code{islinnt}
25696 check if an expression is ``linear,'' i.e., can be written in the form
25697 @expr{a + b x} for some constants @expr{a} and @expr{b}, and some
25698 variable or subformula @expr{x}. The function @samp{islin(f,x)} checks
25699 if formula @expr{f} is linear in @expr{x}, returning 1 if so. For
25700 example, @samp{islin(x,x)}, @samp{islin(-x,x)}, @samp{islin(3,x)}, and
25701 @samp{islin(x y / 3 - 2, x)} all return 1. The @samp{lin(f,x)} function
25702 is similar, except that instead of returning 1 it returns the vector
25703 @expr{[a, b, x]}. For the above examples, this vector would be
25704 @expr{[0, 1, x]}, @expr{[0, -1, x]}, @expr{[3, 0, x]}, and
25705 @expr{[-2, y/3, x]}, respectively. Both @code{lin} and @code{islin}
25706 generally remain unevaluated for expressions which are not linear,
25707 e.g., @samp{lin(2 x^2, x)} and @samp{lin(sin(x), x)}. The second
25708 argument can also be a formula; @samp{islin(2 + 3 sin(x), sin(x))}
25709 returns true.
25710
25711 The @code{linnt} and @code{islinnt} functions perform a similar check,
25712 but require a ``non-trivial'' linear form, which means that the
25713 @expr{b} coefficient must be non-zero. For example, @samp{lin(2,x)}
25714 returns @expr{[2, 0, x]} and @samp{lin(y,x)} returns @expr{[y, 0, x]},
25715 but @samp{linnt(2,x)} and @samp{linnt(y,x)} are left unevaluated
25716 (in other words, these formulas are considered to be only ``trivially''
25717 linear in @expr{x}).
25718
25719 All four linearity-testing functions allow you to omit the second
25720 argument, in which case the input may be linear in any non-constant
25721 formula. Here, the @expr{a=0}, @expr{b=1} case is also considered
25722 trivial, and only constant values for @expr{a} and @expr{b} are
25723 recognized. Thus, @samp{lin(2 x y)} returns @expr{[0, 2, x y]},
25724 @samp{lin(2 - x y)} returns @expr{[2, -1, x y]}, and @samp{lin(x y)}
25725 returns @expr{[0, 1, x y]}. The @code{linnt} function would allow the
25726 first two cases but not the third. Also, neither @code{lin} nor
25727 @code{linnt} accept plain constants as linear in the one-argument
25728 case: @samp{islin(2,x)} is true, but @samp{islin(2)} is false.
25729
25730 @ignore
25731 @starindex
25732 @end ignore
25733 @tindex istrue
25734 The @samp{istrue(a)} function returns 1 if @expr{a} is a nonzero
25735 number or provably nonzero formula, or 0 if @expr{a} is anything else.
25736 Calls to @code{istrue} can only be manipulated if @kbd{m O} mode is
25737 used to make sure they are not evaluated prematurely. (Note that
25738 declarations are used when deciding whether a formula is true;
25739 @code{istrue} returns 1 when @code{dnonzero} would return 1, and
25740 it returns 0 when @code{dnonzero} would return 0 or leave itself
25741 in symbolic form.)
25742
25743 @node Rewrite Rules, , Logical Operations, Algebra
25744 @section Rewrite Rules
25745
25746 @noindent
25747 @cindex Rewrite rules
25748 @cindex Transformations
25749 @cindex Pattern matching
25750 @kindex a r
25751 @pindex calc-rewrite
25752 @tindex rewrite
25753 The @kbd{a r} (@code{calc-rewrite}) [@code{rewrite}] command makes
25754 substitutions in a formula according to a specified pattern or patterns
25755 known as @dfn{rewrite rules}. Whereas @kbd{a b} (@code{calc-substitute})
25756 matches literally, so that substituting @samp{sin(x)} with @samp{cos(x)}
25757 matches only the @code{sin} function applied to the variable @code{x},
25758 rewrite rules match general kinds of formulas; rewriting using the rule
25759 @samp{sin(x) := cos(x)} matches @code{sin} of any argument and replaces
25760 it with @code{cos} of that same argument. The only significance of the
25761 name @code{x} is that the same name is used on both sides of the rule.
25762
25763 Rewrite rules rearrange formulas already in Calc's memory.
25764 @xref{Syntax Tables}, to read about @dfn{syntax rules}, which are
25765 similar to algebraic rewrite rules but operate when new algebraic
25766 entries are being parsed, converting strings of characters into
25767 Calc formulas.
25768
25769 @menu
25770 * Entering Rewrite Rules::
25771 * Basic Rewrite Rules::
25772 * Conditional Rewrite Rules::
25773 * Algebraic Properties of Rewrite Rules::
25774 * Other Features of Rewrite Rules::
25775 * Composing Patterns in Rewrite Rules::
25776 * Nested Formulas with Rewrite Rules::
25777 * Multi-Phase Rewrite Rules::
25778 * Selections with Rewrite Rules::
25779 * Matching Commands::
25780 * Automatic Rewrites::
25781 * Debugging Rewrites::
25782 * Examples of Rewrite Rules::
25783 @end menu
25784
25785 @node Entering Rewrite Rules, Basic Rewrite Rules, Rewrite Rules, Rewrite Rules
25786 @subsection Entering Rewrite Rules
25787
25788 @noindent
25789 Rewrite rules normally use the ``assignment'' operator
25790 @samp{@var{old} := @var{new}}.
25791 This operator is equivalent to the function call @samp{assign(old, new)}.
25792 The @code{assign} function is undefined by itself in Calc, so an
25793 assignment formula such as a rewrite rule will be left alone by ordinary
25794 Calc commands. But certain commands, like the rewrite system, interpret
25795 assignments in special ways.
25796
25797 For example, the rule @samp{sin(x)^2 := 1-cos(x)^2} says to replace
25798 every occurrence of the sine of something, squared, with one minus the
25799 square of the cosine of that same thing. All by itself as a formula
25800 on the stack it does nothing, but when given to the @kbd{a r} command
25801 it turns that command into a sine-squared-to-cosine-squared converter.
25802
25803 To specify a set of rules to be applied all at once, make a vector of
25804 rules.
25805
25806 When @kbd{a r} prompts you to enter the rewrite rules, you can answer
25807 in several ways:
25808
25809 @enumerate
25810 @item
25811 With a rule: @kbd{f(x) := g(x) @key{RET}}.
25812 @item
25813 With a vector of rules: @kbd{[f1(x) := g1(x), f2(x) := g2(x)] @key{RET}}.
25814 (You can omit the enclosing square brackets if you wish.)
25815 @item
25816 With the name of a variable that contains the rule or rules vector:
25817 @kbd{myrules @key{RET}}.
25818 @item
25819 With any formula except a rule, a vector, or a variable name; this
25820 will be interpreted as the @var{old} half of a rewrite rule,
25821 and you will be prompted a second time for the @var{new} half:
25822 @kbd{f(x) @key{RET} g(x) @key{RET}}.
25823 @item
25824 With a blank line, in which case the rule, rules vector, or variable
25825 will be taken from the top of the stack (and the formula to be
25826 rewritten will come from the second-to-top position).
25827 @end enumerate
25828
25829 If you enter the rules directly (as opposed to using rules stored
25830 in a variable), those rules will be put into the Trail so that you
25831 can retrieve them later. @xref{Trail Commands}.
25832
25833 It is most convenient to store rules you use often in a variable and
25834 invoke them by giving the variable name. The @kbd{s e}
25835 (@code{calc-edit-variable}) command is an easy way to create or edit a
25836 rule set stored in a variable. You may also wish to use @kbd{s p}
25837 (@code{calc-permanent-variable}) to save your rules permanently;
25838 @pxref{Operations on Variables}.
25839
25840 Rewrite rules are compiled into a special internal form for faster
25841 matching. If you enter a rule set directly it must be recompiled
25842 every time. If you store the rules in a variable and refer to them
25843 through that variable, they will be compiled once and saved away
25844 along with the variable for later reference. This is another good
25845 reason to store your rules in a variable.
25846
25847 Calc also accepts an obsolete notation for rules, as vectors
25848 @samp{[@var{old}, @var{new}]}. But because it is easily confused with a
25849 vector of two rules, the use of this notation is no longer recommended.
25850
25851 @node Basic Rewrite Rules, Conditional Rewrite Rules, Entering Rewrite Rules, Rewrite Rules
25852 @subsection Basic Rewrite Rules
25853
25854 @noindent
25855 To match a particular formula @expr{x} with a particular rewrite rule
25856 @samp{@var{old} := @var{new}}, Calc compares the structure of @expr{x} with
25857 the structure of @var{old}. Variables that appear in @var{old} are
25858 treated as @dfn{meta-variables}; the corresponding positions in @expr{x}
25859 may contain any sub-formulas. For example, the pattern @samp{f(x,y)}
25860 would match the expression @samp{f(12, a+1)} with the meta-variable
25861 @samp{x} corresponding to 12 and with @samp{y} corresponding to
25862 @samp{a+1}. However, this pattern would not match @samp{f(12)} or
25863 @samp{g(12, a+1)}, since there is no assignment of the meta-variables
25864 that will make the pattern match these expressions. Notice that if
25865 the pattern is a single meta-variable, it will match any expression.
25866
25867 If a given meta-variable appears more than once in @var{old}, the
25868 corresponding sub-formulas of @expr{x} must be identical. Thus
25869 the pattern @samp{f(x,x)} would match @samp{f(12, 12)} and
25870 @samp{f(a+1, a+1)} but not @samp{f(12, a+1)} or @samp{f(a+b, b+a)}.
25871 (@xref{Conditional Rewrite Rules}, for a way to match the latter.)
25872
25873 Things other than variables must match exactly between the pattern
25874 and the target formula. To match a particular variable exactly, use
25875 the pseudo-function @samp{quote(v)} in the pattern. For example, the
25876 pattern @samp{x+quote(y)} matches @samp{x+y}, @samp{2+y}, or
25877 @samp{sin(a)+y}.
25878
25879 The special variable names @samp{e}, @samp{pi}, @samp{i}, @samp{phi},
25880 @samp{gamma}, @samp{inf}, @samp{uinf}, and @samp{nan} always match
25881 literally. Thus the pattern @samp{sin(d + e + f)} acts exactly like
25882 @samp{sin(d + quote(e) + f)}.
25883
25884 If the @var{old} pattern is found to match a given formula, that
25885 formula is replaced by @var{new}, where any occurrences in @var{new}
25886 of meta-variables from the pattern are replaced with the sub-formulas
25887 that they matched. Thus, applying the rule @samp{f(x,y) := g(y+x,x)}
25888 to @samp{f(12, a+1)} would produce @samp{g(a+13, 12)}.
25889
25890 The normal @kbd{a r} command applies rewrite rules over and over
25891 throughout the target formula until no further changes are possible
25892 (up to a limit of 100 times). Use @kbd{C-u 1 a r} to make only one
25893 change at a time.
25894
25895 @node Conditional Rewrite Rules, Algebraic Properties of Rewrite Rules, Basic Rewrite Rules, Rewrite Rules
25896 @subsection Conditional Rewrite Rules
25897
25898 @noindent
25899 A rewrite rule can also be @dfn{conditional}, written in the form
25900 @samp{@var{old} := @var{new} :: @var{cond}}. (There is also the obsolete
25901 form @samp{[@var{old}, @var{new}, @var{cond}]}.) If a @var{cond} part
25902 is present in the
25903 rule, this is an additional condition that must be satisfied before
25904 the rule is accepted. Once @var{old} has been successfully matched
25905 to the target expression, @var{cond} is evaluated (with all the
25906 meta-variables substituted for the values they matched) and simplified
25907 with @kbd{a s} (@code{calc-simplify}). If the result is a nonzero
25908 number or any other object known to be nonzero (@pxref{Declarations}),
25909 the rule is accepted. If the result is zero or if it is a symbolic
25910 formula that is not known to be nonzero, the rule is rejected.
25911 @xref{Logical Operations}, for a number of functions that return
25912 1 or 0 according to the results of various tests.
25913
25914 For example, the formula @samp{n > 0} simplifies to 1 or 0 if @expr{n}
25915 is replaced by a positive or nonpositive number, respectively (or if
25916 @expr{n} has been declared to be positive or nonpositive). Thus,
25917 the rule @samp{f(x,y) := g(y+x,x) :: x+y > 0} would apply to
25918 @samp{f(0, 4)} but not to @samp{f(-3, 2)} or @samp{f(12, a+1)}
25919 (assuming no outstanding declarations for @expr{a}). In the case of
25920 @samp{f(-3, 2)}, the condition can be shown not to be satisfied; in
25921 the case of @samp{f(12, a+1)}, the condition merely cannot be shown
25922 to be satisfied, but that is enough to reject the rule.
25923
25924 While Calc will use declarations to reason about variables in the
25925 formula being rewritten, declarations do not apply to meta-variables.
25926 For example, the rule @samp{f(a) := g(a+1)} will match for any values
25927 of @samp{a}, such as complex numbers, vectors, or formulas, even if
25928 @samp{a} has been declared to be real or scalar. If you want the
25929 meta-variable @samp{a} to match only literal real numbers, use
25930 @samp{f(a) := g(a+1) :: real(a)}. If you want @samp{a} to match only
25931 reals and formulas which are provably real, use @samp{dreal(a)} as
25932 the condition.
25933
25934 The @samp{::} operator is a shorthand for the @code{condition}
25935 function; @samp{@var{old} := @var{new} :: @var{cond}} is equivalent to
25936 the formula @samp{condition(assign(@var{old}, @var{new}), @var{cond})}.
25937
25938 If you have several conditions, you can use @samp{... :: c1 :: c2 :: c3}
25939 or @samp{... :: c1 && c2 && c3}. The two are entirely equivalent.
25940
25941 It is also possible to embed conditions inside the pattern:
25942 @samp{f(x :: x>0, y) := g(y+x, x)}. This is purely a notational
25943 convenience, though; where a condition appears in a rule has no
25944 effect on when it is tested. The rewrite-rule compiler automatically
25945 decides when it is best to test each condition while a rule is being
25946 matched.
25947
25948 Certain conditions are handled as special cases by the rewrite rule
25949 system and are tested very efficiently: Where @expr{x} is any
25950 meta-variable, these conditions are @samp{integer(x)}, @samp{real(x)},
25951 @samp{constant(x)}, @samp{negative(x)}, @samp{x >= y} where @expr{y}
25952 is either a constant or another meta-variable and @samp{>=} may be
25953 replaced by any of the six relational operators, and @samp{x % a = b}
25954 where @expr{a} and @expr{b} are constants. Other conditions, like
25955 @samp{x >= y+1} or @samp{dreal(x)}, will be less efficient to check
25956 since Calc must bring the whole evaluator and simplifier into play.
25957
25958 An interesting property of @samp{::} is that neither of its arguments
25959 will be touched by Calc's default simplifications. This is important
25960 because conditions often are expressions that cannot safely be
25961 evaluated early. For example, the @code{typeof} function never
25962 remains in symbolic form; entering @samp{typeof(a)} will put the
25963 number 100 (the type code for variables like @samp{a}) on the stack.
25964 But putting the condition @samp{... :: typeof(a) = 6} on the stack
25965 is safe since @samp{::} prevents the @code{typeof} from being
25966 evaluated until the condition is actually used by the rewrite system.
25967
25968 Since @samp{::} protects its lefthand side, too, you can use a dummy
25969 condition to protect a rule that must itself not evaluate early.
25970 For example, it's not safe to put @samp{a(f,x) := apply(f, [x])} on
25971 the stack because it will immediately evaluate to @samp{a(f,x) := f(x)},
25972 where the meta-variable-ness of @code{f} on the righthand side has been
25973 lost. But @samp{a(f,x) := apply(f, [x]) :: 1} is safe, and of course
25974 the condition @samp{1} is always true (nonzero) so it has no effect on
25975 the functioning of the rule. (The rewrite compiler will ensure that
25976 it doesn't even impact the speed of matching the rule.)
25977
25978 @node Algebraic Properties of Rewrite Rules, Other Features of Rewrite Rules, Conditional Rewrite Rules, Rewrite Rules
25979 @subsection Algebraic Properties of Rewrite Rules
25980
25981 @noindent
25982 The rewrite mechanism understands the algebraic properties of functions
25983 like @samp{+} and @samp{*}. In particular, pattern matching takes
25984 the associativity and commutativity of the following functions into
25985 account:
25986
25987 @smallexample
25988 + - * = != && || and or xor vint vunion vxor gcd lcm max min beta
25989 @end smallexample
25990
25991 For example, the rewrite rule:
25992
25993 @example
25994 a x + b x := (a + b) x
25995 @end example
25996
25997 @noindent
25998 will match formulas of the form,
25999
26000 @example
26001 a x + b x, x a + x b, a x + x b, x a + b x
26002 @end example
26003
26004 Rewrites also understand the relationship between the @samp{+} and @samp{-}
26005 operators. The above rewrite rule will also match the formulas,
26006
26007 @example
26008 a x - b x, x a - x b, a x - x b, x a - b x
26009 @end example
26010
26011 @noindent
26012 by matching @samp{b} in the pattern to @samp{-b} from the formula.
26013
26014 Applied to a sum of many terms like @samp{r + a x + s + b x + t}, this
26015 pattern will check all pairs of terms for possible matches. The rewrite
26016 will take whichever suitable pair it discovers first.
26017
26018 In general, a pattern using an associative operator like @samp{a + b}
26019 will try @var{2 n} different ways to match a sum of @var{n} terms
26020 like @samp{x + y + z - w}. First, @samp{a} is matched against each
26021 of @samp{x}, @samp{y}, @samp{z}, and @samp{-w} in turn, with @samp{b}
26022 being matched to the remainders @samp{y + z - w}, @samp{x + z - w}, etc.
26023 If none of these succeed, then @samp{b} is matched against each of the
26024 four terms with @samp{a} matching the remainder. Half-and-half matches,
26025 like @samp{(x + y) + (z - w)}, are not tried.
26026
26027 Note that @samp{*} is not commutative when applied to matrices, but
26028 rewrite rules pretend that it is. If you type @kbd{m v} to enable
26029 Matrix mode (@pxref{Matrix Mode}), rewrite rules will match @samp{*}
26030 literally, ignoring its usual commutativity property. (In the
26031 current implementation, the associativity also vanishes---it is as
26032 if the pattern had been enclosed in a @code{plain} marker; see below.)
26033 If you are applying rewrites to formulas with matrices, it's best to
26034 enable Matrix mode first to prevent algebraically incorrect rewrites
26035 from occurring.
26036
26037 The pattern @samp{-x} will actually match any expression. For example,
26038 the rule
26039
26040 @example
26041 f(-x) := -f(x)
26042 @end example
26043
26044 @noindent
26045 will rewrite @samp{f(a)} to @samp{-f(-a)}. To avoid this, either use
26046 a @code{plain} marker as described below, or add a @samp{negative(x)}
26047 condition. The @code{negative} function is true if its argument
26048 ``looks'' negative, for example, because it is a negative number or
26049 because it is a formula like @samp{-x}. The new rule using this
26050 condition is:
26051
26052 @example
26053 f(x) := -f(-x) :: negative(x) @r{or, equivalently,}
26054 f(-x) := -f(x) :: negative(-x)
26055 @end example
26056
26057 In the same way, the pattern @samp{x - y} will match the sum @samp{a + b}
26058 by matching @samp{y} to @samp{-b}.
26059
26060 The pattern @samp{a b} will also match the formula @samp{x/y} if
26061 @samp{y} is a number. Thus the rule @samp{a x + @w{b x} := (a+b) x}
26062 will also convert @samp{a x + x / 2} to @samp{(a + 0.5) x} (or
26063 @samp{(a + 1:2) x}, depending on the current fraction mode).
26064
26065 Calc will @emph{not} take other liberties with @samp{*}, @samp{/}, and
26066 @samp{^}. For example, the pattern @samp{f(a b)} will not match
26067 @samp{f(x^2)}, and @samp{f(a + b)} will not match @samp{f(2 x)}, even
26068 though conceivably these patterns could match with @samp{a = b = x}.
26069 Nor will @samp{f(a b)} match @samp{f(x / y)} if @samp{y} is not a
26070 constant, even though it could be considered to match with @samp{a = x}
26071 and @samp{b = 1/y}. The reasons are partly for efficiency, and partly
26072 because while few mathematical operations are substantively different
26073 for addition and subtraction, often it is preferable to treat the cases
26074 of multiplication, division, and integer powers separately.
26075
26076 Even more subtle is the rule set
26077
26078 @example
26079 [ f(a) + f(b) := f(a + b), -f(a) := f(-a) ]
26080 @end example
26081
26082 @noindent
26083 attempting to match @samp{f(x) - f(y)}. You might think that Calc
26084 will view this subtraction as @samp{f(x) + (-f(y))} and then apply
26085 the above two rules in turn, but actually this will not work because
26086 Calc only does this when considering rules for @samp{+} (like the
26087 first rule in this set). So it will see first that @samp{f(x) + (-f(y))}
26088 does not match @samp{f(a) + f(b)} for any assignments of the
26089 meta-variables, and then it will see that @samp{f(x) - f(y)} does
26090 not match @samp{-f(a)} for any assignment of @samp{a}. Because Calc
26091 tries only one rule at a time, it will not be able to rewrite
26092 @samp{f(x) - f(y)} with this rule set. An explicit @samp{f(a) - f(b)}
26093 rule will have to be added.
26094
26095 Another thing patterns will @emph{not} do is break up complex numbers.
26096 The pattern @samp{myconj(a + @w{b i)} := a - b i} will work for formulas
26097 involving the special constant @samp{i} (such as @samp{3 - 4 i}), but
26098 it will not match actual complex numbers like @samp{(3, -4)}. A version
26099 of the above rule for complex numbers would be
26100
26101 @example
26102 myconj(a) := re(a) - im(a) (0,1) :: im(a) != 0
26103 @end example
26104
26105 @noindent
26106 (Because the @code{re} and @code{im} functions understand the properties
26107 of the special constant @samp{i}, this rule will also work for
26108 @samp{3 - 4 i}. In fact, this particular rule would probably be better
26109 without the @samp{im(a) != 0} condition, since if @samp{im(a) = 0} the
26110 righthand side of the rule will still give the correct answer for the
26111 conjugate of a real number.)
26112
26113 It is also possible to specify optional arguments in patterns. The rule
26114
26115 @example
26116 opt(a) x + opt(b) (x^opt(c) + opt(d)) := f(a, b, c, d)
26117 @end example
26118
26119 @noindent
26120 will match the formula
26121
26122 @example
26123 5 (x^2 - 4) + 3 x
26124 @end example
26125
26126 @noindent
26127 in a fairly straightforward manner, but it will also match reduced
26128 formulas like
26129
26130 @example
26131 x + x^2, 2(x + 1) - x, x + x
26132 @end example
26133
26134 @noindent
26135 producing, respectively,
26136
26137 @example
26138 f(1, 1, 2, 0), f(-1, 2, 1, 1), f(1, 1, 1, 0)
26139 @end example
26140
26141 (The latter two formulas can be entered only if default simplifications
26142 have been turned off with @kbd{m O}.)
26143
26144 The default value for a term of a sum is zero. The default value
26145 for a part of a product, for a power, or for the denominator of a
26146 quotient, is one. Also, @samp{-x} matches the pattern @samp{opt(a) b}
26147 with @samp{a = -1}.
26148
26149 In particular, the distributive-law rule can be refined to
26150
26151 @example
26152 opt(a) x + opt(b) x := (a + b) x
26153 @end example
26154
26155 @noindent
26156 so that it will convert, e.g., @samp{a x - x}, to @samp{(a - 1) x}.
26157
26158 The pattern @samp{opt(a) + opt(b) x} matches almost any formulas which
26159 are linear in @samp{x}. You can also use the @code{lin} and @code{islin}
26160 functions with rewrite conditions to test for this; @pxref{Logical
26161 Operations}. These functions are not as convenient to use in rewrite
26162 rules, but they recognize more kinds of formulas as linear:
26163 @samp{x/z} is considered linear with @expr{b = 1/z} by @code{lin},
26164 but it will not match the above pattern because that pattern calls
26165 for a multiplication, not a division.
26166
26167 As another example, the obvious rule to replace @samp{sin(x)^2 + cos(x)^2}
26168 by 1,
26169
26170 @example
26171 sin(x)^2 + cos(x)^2 := 1
26172 @end example
26173
26174 @noindent
26175 misses many cases because the sine and cosine may both be multiplied by
26176 an equal factor. Here's a more successful rule:
26177
26178 @example
26179 opt(a) sin(x)^2 + opt(a) cos(x)^2 := a
26180 @end example
26181
26182 Note that this rule will @emph{not} match @samp{sin(x)^2 + 6 cos(x)^2}
26183 because one @expr{a} would have ``matched'' 1 while the other matched 6.
26184
26185 Calc automatically converts a rule like
26186
26187 @example
26188 f(x-1, x) := g(x)
26189 @end example
26190
26191 @noindent
26192 into the form
26193
26194 @example
26195 f(temp, x) := g(x) :: temp = x-1
26196 @end example
26197
26198 @noindent
26199 (where @code{temp} stands for a new, invented meta-variable that
26200 doesn't actually have a name). This modified rule will successfully
26201 match @samp{f(6, 7)}, binding @samp{temp} and @samp{x} to 6 and 7,
26202 respectively, then verifying that they differ by one even though
26203 @samp{6} does not superficially look like @samp{x-1}.
26204
26205 However, Calc does not solve equations to interpret a rule. The
26206 following rule,
26207
26208 @example
26209 f(x-1, x+1) := g(x)
26210 @end example
26211
26212 @noindent
26213 will not work. That is, it will match @samp{f(a - 1 + b, a + 1 + b)}
26214 but not @samp{f(6, 8)}. Calc always interprets at least one occurrence
26215 of a variable by literal matching. If the variable appears ``isolated''
26216 then Calc is smart enough to use it for literal matching. But in this
26217 last example, Calc is forced to rewrite the rule to @samp{f(x-1, temp)
26218 := g(x) :: temp = x+1} where the @samp{x-1} term must correspond to an
26219 actual ``something-minus-one'' in the target formula.
26220
26221 A successful way to write this would be @samp{f(x, x+2) := g(x+1)}.
26222 You could make this resemble the original form more closely by using
26223 @code{let} notation, which is described in the next section:
26224
26225 @example
26226 f(xm1, x+1) := g(x) :: let(x := xm1+1)
26227 @end example
26228
26229 Calc does this rewriting or ``conditionalizing'' for any sub-pattern
26230 which involves only the functions in the following list, operating
26231 only on constants and meta-variables which have already been matched
26232 elsewhere in the pattern. When matching a function call, Calc is
26233 careful to match arguments which are plain variables before arguments
26234 which are calls to any of the functions below, so that a pattern like
26235 @samp{f(x-1, x)} can be conditionalized even though the isolated
26236 @samp{x} comes after the @samp{x-1}.
26237
26238 @smallexample
26239 + - * / \ % ^ abs sign round rounde roundu trunc floor ceil
26240 max min re im conj arg
26241 @end smallexample
26242
26243 You can suppress all of the special treatments described in this
26244 section by surrounding a function call with a @code{plain} marker.
26245 This marker causes the function call which is its argument to be
26246 matched literally, without regard to commutativity, associativity,
26247 negation, or conditionalization. When you use @code{plain}, the
26248 ``deep structure'' of the formula being matched can show through.
26249 For example,
26250
26251 @example
26252 plain(a - a b) := f(a, b)
26253 @end example
26254
26255 @noindent
26256 will match only literal subtractions. However, the @code{plain}
26257 marker does not affect its arguments' arguments. In this case,
26258 commutativity and associativity is still considered while matching
26259 the @w{@samp{a b}} sub-pattern, so the whole pattern will match
26260 @samp{x - y x} as well as @samp{x - x y}. We could go still
26261 further and use
26262
26263 @example
26264 plain(a - plain(a b)) := f(a, b)
26265 @end example
26266
26267 @noindent
26268 which would do a completely strict match for the pattern.
26269
26270 By contrast, the @code{quote} marker means that not only the
26271 function name but also the arguments must be literally the same.
26272 The above pattern will match @samp{x - x y} but
26273
26274 @example
26275 quote(a - a b) := f(a, b)
26276 @end example
26277
26278 @noindent
26279 will match only the single formula @samp{a - a b}. Also,
26280
26281 @example
26282 quote(a - quote(a b)) := f(a, b)
26283 @end example
26284
26285 @noindent
26286 will match only @samp{a - quote(a b)}---probably not the desired
26287 effect!
26288
26289 A certain amount of algebra is also done when substituting the
26290 meta-variables on the righthand side of a rule. For example,
26291 in the rule
26292
26293 @example
26294 a + f(b) := f(a + b)
26295 @end example
26296
26297 @noindent
26298 matching @samp{f(x) - y} would produce @samp{f((-y) + x)} if
26299 taken literally, but the rewrite mechanism will simplify the
26300 righthand side to @samp{f(x - y)} automatically. (Of course,
26301 the default simplifications would do this anyway, so this
26302 special simplification is only noticeable if you have turned the
26303 default simplifications off.) This rewriting is done only when
26304 a meta-variable expands to a ``negative-looking'' expression.
26305 If this simplification is not desirable, you can use a @code{plain}
26306 marker on the righthand side:
26307
26308 @example
26309 a + f(b) := f(plain(a + b))
26310 @end example
26311
26312 @noindent
26313 In this example, we are still allowing the pattern-matcher to
26314 use all the algebra it can muster, but the righthand side will
26315 always simplify to a literal addition like @samp{f((-y) + x)}.
26316
26317 @node Other Features of Rewrite Rules, Composing Patterns in Rewrite Rules, Algebraic Properties of Rewrite Rules, Rewrite Rules
26318 @subsection Other Features of Rewrite Rules
26319
26320 @noindent
26321 Certain ``function names'' serve as markers in rewrite rules.
26322 Here is a complete list of these markers. First are listed the
26323 markers that work inside a pattern; then come the markers that
26324 work in the righthand side of a rule.
26325
26326 @ignore
26327 @starindex
26328 @end ignore
26329 @tindex import
26330 One kind of marker, @samp{import(x)}, takes the place of a whole
26331 rule. Here @expr{x} is the name of a variable containing another
26332 rule set; those rules are ``spliced into'' the rule set that
26333 imports them. For example, if @samp{[f(a+b) := f(a) + f(b),
26334 f(a b) := a f(b) :: real(a)]} is stored in variable @samp{linearF},
26335 then the rule set @samp{[f(0) := 0, import(linearF)]} will apply
26336 all three rules. It is possible to modify the imported rules
26337 slightly: @samp{import(x, v1, x1, v2, x2, @dots{})} imports
26338 the rule set @expr{x} with all occurrences of
26339 @texline @math{v_1},
26340 @infoline @expr{v1},
26341 as either a variable name or a function name, replaced with
26342 @texline @math{x_1}
26343 @infoline @expr{x1}
26344 and so on. (If
26345 @texline @math{v_1}
26346 @infoline @expr{v1}
26347 is used as a function name, then
26348 @texline @math{x_1}
26349 @infoline @expr{x1}
26350 must be either a function name itself or a @w{@samp{< >}} nameless
26351 function; @pxref{Specifying Operators}.) For example, @samp{[g(0) := 0,
26352 import(linearF, f, g)]} applies the linearity rules to the function
26353 @samp{g} instead of @samp{f}. Imports can be nested, but the
26354 import-with-renaming feature may fail to rename sub-imports properly.
26355
26356 The special functions allowed in patterns are:
26357
26358 @table @samp
26359 @item quote(x)
26360 @ignore
26361 @starindex
26362 @end ignore
26363 @tindex quote
26364 This pattern matches exactly @expr{x}; variable names in @expr{x} are
26365 not interpreted as meta-variables. The only flexibility is that
26366 numbers are compared for numeric equality, so that the pattern
26367 @samp{f(quote(12))} will match both @samp{f(12)} and @samp{f(12.0)}.
26368 (Numbers are always treated this way by the rewrite mechanism:
26369 The rule @samp{f(x,x) := g(x)} will match @samp{f(12, 12.0)}.
26370 The rewrite may produce either @samp{g(12)} or @samp{g(12.0)}
26371 as a result in this case.)
26372
26373 @item plain(x)
26374 @ignore
26375 @starindex
26376 @end ignore
26377 @tindex plain
26378 Here @expr{x} must be a function call @samp{f(x1,x2,@dots{})}. This
26379 pattern matches a call to function @expr{f} with the specified
26380 argument patterns. No special knowledge of the properties of the
26381 function @expr{f} is used in this case; @samp{+} is not commutative or
26382 associative. Unlike @code{quote}, the arguments @samp{x1,x2,@dots{}}
26383 are treated as patterns. If you wish them to be treated ``plainly''
26384 as well, you must enclose them with more @code{plain} markers:
26385 @samp{plain(plain(@w{-a}) + plain(b c))}.
26386
26387 @item opt(x,def)
26388 @ignore
26389 @starindex
26390 @end ignore
26391 @tindex opt
26392 Here @expr{x} must be a variable name. This must appear as an
26393 argument to a function or an element of a vector; it specifies that
26394 the argument or element is optional.
26395 As an argument to @samp{+}, @samp{-}, @samp{*}, @samp{&&}, or @samp{||},
26396 or as the second argument to @samp{/} or @samp{^}, the value @var{def}
26397 may be omitted. The pattern @samp{x + opt(y)} matches a sum by
26398 binding one summand to @expr{x} and the other to @expr{y}, and it
26399 matches anything else by binding the whole expression to @expr{x} and
26400 zero to @expr{y}. The other operators above work similarly.
26401
26402 For general miscellaneous functions, the default value @code{def}
26403 must be specified. Optional arguments are dropped starting with
26404 the rightmost one during matching. For example, the pattern
26405 @samp{f(opt(a,0), b, opt(c,b))} will match @samp{f(b)}, @samp{f(a,b)},
26406 or @samp{f(a,b,c)}. Default values of zero and @expr{b} are
26407 supplied in this example for the omitted arguments. Note that
26408 the literal variable @expr{b} will be the default in the latter
26409 case, @emph{not} the value that matched the meta-variable @expr{b}.
26410 In other words, the default @var{def} is effectively quoted.
26411
26412 @item condition(x,c)
26413 @ignore
26414 @starindex
26415 @end ignore
26416 @tindex condition
26417 @tindex ::
26418 This matches the pattern @expr{x}, with the attached condition
26419 @expr{c}. It is the same as @samp{x :: c}.
26420
26421 @item pand(x,y)
26422 @ignore
26423 @starindex
26424 @end ignore
26425 @tindex pand
26426 @tindex &&&
26427 This matches anything that matches both pattern @expr{x} and
26428 pattern @expr{y}. It is the same as @samp{x &&& y}.
26429 @pxref{Composing Patterns in Rewrite Rules}.
26430
26431 @item por(x,y)
26432 @ignore
26433 @starindex
26434 @end ignore
26435 @tindex por
26436 @tindex |||
26437 This matches anything that matches either pattern @expr{x} or
26438 pattern @expr{y}. It is the same as @w{@samp{x ||| y}}.
26439
26440 @item pnot(x)
26441 @ignore
26442 @starindex
26443 @end ignore
26444 @tindex pnot
26445 @tindex !!!
26446 This matches anything that does not match pattern @expr{x}.
26447 It is the same as @samp{!!! x}.
26448
26449 @item cons(h,t)
26450 @ignore
26451 @mindex cons
26452 @end ignore
26453 @tindex cons (rewrites)
26454 This matches any vector of one or more elements. The first
26455 element is matched to @expr{h}; a vector of the remaining
26456 elements is matched to @expr{t}. Note that vectors of fixed
26457 length can also be matched as actual vectors: The rule
26458 @samp{cons(a,cons(b,[])) := cons(a+b,[])} is equivalent
26459 to the rule @samp{[a,b] := [a+b]}.
26460
26461 @item rcons(t,h)
26462 @ignore
26463 @mindex rcons
26464 @end ignore
26465 @tindex rcons (rewrites)
26466 This is like @code{cons}, except that the @emph{last} element
26467 is matched to @expr{h}, with the remaining elements matched
26468 to @expr{t}.
26469
26470 @item apply(f,args)
26471 @ignore
26472 @mindex apply
26473 @end ignore
26474 @tindex apply (rewrites)
26475 This matches any function call. The name of the function, in
26476 the form of a variable, is matched to @expr{f}. The arguments
26477 of the function, as a vector of zero or more objects, are
26478 matched to @samp{args}. Constants, variables, and vectors
26479 do @emph{not} match an @code{apply} pattern. For example,
26480 @samp{apply(f,x)} matches any function call, @samp{apply(quote(f),x)}
26481 matches any call to the function @samp{f}, @samp{apply(f,[a,b])}
26482 matches any function call with exactly two arguments, and
26483 @samp{apply(quote(f), cons(a,cons(b,x)))} matches any call
26484 to the function @samp{f} with two or more arguments. Another
26485 way to implement the latter, if the rest of the rule does not
26486 need to refer to the first two arguments of @samp{f} by name,
26487 would be @samp{apply(quote(f), x :: vlen(x) >= 2)}.
26488 Here's a more interesting sample use of @code{apply}:
26489
26490 @example
26491 apply(f,[x+n]) := n + apply(f,[x])
26492 :: in(f, [floor,ceil,round,trunc]) :: integer(n)
26493 @end example
26494
26495 Note, however, that this will be slower to match than a rule
26496 set with four separate rules. The reason is that Calc sorts
26497 the rules of a rule set according to top-level function name;
26498 if the top-level function is @code{apply}, Calc must try the
26499 rule for every single formula and sub-formula. If the top-level
26500 function in the pattern is, say, @code{floor}, then Calc invokes
26501 the rule only for sub-formulas which are calls to @code{floor}.
26502
26503 Formulas normally written with operators like @code{+} are still
26504 considered function calls: @code{apply(f,x)} matches @samp{a+b}
26505 with @samp{f = add}, @samp{x = [a,b]}.
26506
26507 You must use @code{apply} for meta-variables with function names
26508 on both sides of a rewrite rule: @samp{apply(f, [x]) := f(x+1)}
26509 is @emph{not} correct, because it rewrites @samp{spam(6)} into
26510 @samp{f(7)}. The righthand side should be @samp{apply(f, [x+1])}.
26511 Also note that you will have to use No-Simplify mode (@kbd{m O})
26512 when entering this rule so that the @code{apply} isn't
26513 evaluated immediately to get the new rule @samp{f(x) := f(x+1)}.
26514 Or, use @kbd{s e} to enter the rule without going through the stack,
26515 or enter the rule as @samp{apply(f, [x]) := apply(f, [x+1]) @w{:: 1}}.
26516 @xref{Conditional Rewrite Rules}.
26517
26518 @item select(x)
26519 @ignore
26520 @starindex
26521 @end ignore
26522 @tindex select
26523 This is used for applying rules to formulas with selections;
26524 @pxref{Selections with Rewrite Rules}.
26525 @end table
26526
26527 Special functions for the righthand sides of rules are:
26528
26529 @table @samp
26530 @item quote(x)
26531 The notation @samp{quote(x)} is changed to @samp{x} when the
26532 righthand side is used. As far as the rewrite rule is concerned,
26533 @code{quote} is invisible. However, @code{quote} has the special
26534 property in Calc that its argument is not evaluated. Thus,
26535 while it will not work to put the rule @samp{t(a) := typeof(a)}
26536 on the stack because @samp{typeof(a)} is evaluated immediately
26537 to produce @samp{t(a) := 100}, you can use @code{quote} to
26538 protect the righthand side: @samp{t(a) := quote(typeof(a))}.
26539 (@xref{Conditional Rewrite Rules}, for another trick for
26540 protecting rules from evaluation.)
26541
26542 @item plain(x)
26543 Special properties of and simplifications for the function call
26544 @expr{x} are not used. One interesting case where @code{plain}
26545 is useful is the rule, @samp{q(x) := quote(x)}, trying to expand a
26546 shorthand notation for the @code{quote} function. This rule will
26547 not work as shown; instead of replacing @samp{q(foo)} with
26548 @samp{quote(foo)}, it will replace it with @samp{foo}! The correct
26549 rule would be @samp{q(x) := plain(quote(x))}.
26550
26551 @item cons(h,t)
26552 Where @expr{t} is a vector, this is converted into an expanded
26553 vector during rewrite processing. Note that @code{cons} is a regular
26554 Calc function which normally does this anyway; the only way @code{cons}
26555 is treated specially by rewrites is that @code{cons} on the righthand
26556 side of a rule will be evaluated even if default simplifications
26557 have been turned off.
26558
26559 @item rcons(t,h)
26560 Analogous to @code{cons} except putting @expr{h} at the @emph{end} of
26561 the vector @expr{t}.
26562
26563 @item apply(f,args)
26564 Where @expr{f} is a variable and @var{args} is a vector, this
26565 is converted to a function call. Once again, note that @code{apply}
26566 is also a regular Calc function.
26567
26568 @item eval(x)
26569 @ignore
26570 @starindex
26571 @end ignore
26572 @tindex eval
26573 The formula @expr{x} is handled in the usual way, then the
26574 default simplifications are applied to it even if they have
26575 been turned off normally. This allows you to treat any function
26576 similarly to the way @code{cons} and @code{apply} are always
26577 treated. However, there is a slight difference: @samp{cons(2+3, [])}
26578 with default simplifications off will be converted to @samp{[2+3]},
26579 whereas @samp{eval(cons(2+3, []))} will be converted to @samp{[5]}.
26580
26581 @item evalsimp(x)
26582 @ignore
26583 @starindex
26584 @end ignore
26585 @tindex evalsimp
26586 The formula @expr{x} has meta-variables substituted in the usual
26587 way, then algebraically simplified as if by the @kbd{a s} command.
26588
26589 @item evalextsimp(x)
26590 @ignore
26591 @starindex
26592 @end ignore
26593 @tindex evalextsimp
26594 The formula @expr{x} has meta-variables substituted in the normal
26595 way, then ``extendedly'' simplified as if by the @kbd{a e} command.
26596
26597 @item select(x)
26598 @xref{Selections with Rewrite Rules}.
26599 @end table
26600
26601 There are also some special functions you can use in conditions.
26602
26603 @table @samp
26604 @item let(v := x)
26605 @ignore
26606 @starindex
26607 @end ignore
26608 @tindex let
26609 The expression @expr{x} is evaluated with meta-variables substituted.
26610 The @kbd{a s} command's simplifications are @emph{not} applied by
26611 default, but @expr{x} can include calls to @code{evalsimp} or
26612 @code{evalextsimp} as described above to invoke higher levels
26613 of simplification. The
26614 result of @expr{x} is then bound to the meta-variable @expr{v}. As
26615 usual, if this meta-variable has already been matched to something
26616 else the two values must be equal; if the meta-variable is new then
26617 it is bound to the result of the expression. This variable can then
26618 appear in later conditions, and on the righthand side of the rule.
26619 In fact, @expr{v} may be any pattern in which case the result of
26620 evaluating @expr{x} is matched to that pattern, binding any
26621 meta-variables that appear in that pattern. Note that @code{let}
26622 can only appear by itself as a condition, or as one term of an
26623 @samp{&&} which is a whole condition: It cannot be inside
26624 an @samp{||} term or otherwise buried.
26625
26626 The alternate, equivalent form @samp{let(v, x)} is also recognized.
26627 Note that the use of @samp{:=} by @code{let}, while still being
26628 assignment-like in character, is unrelated to the use of @samp{:=}
26629 in the main part of a rewrite rule.
26630
26631 As an example, @samp{f(a) := g(ia) :: let(ia := 1/a) :: constant(ia)}
26632 replaces @samp{f(a)} with @samp{g} of the inverse of @samp{a}, if
26633 that inverse exists and is constant. For example, if @samp{a} is a
26634 singular matrix the operation @samp{1/a} is left unsimplified and
26635 @samp{constant(ia)} fails, but if @samp{a} is an invertible matrix
26636 then the rule succeeds. Without @code{let} there would be no way
26637 to express this rule that didn't have to invert the matrix twice.
26638 Note that, because the meta-variable @samp{ia} is otherwise unbound
26639 in this rule, the @code{let} condition itself always ``succeeds''
26640 because no matter what @samp{1/a} evaluates to, it can successfully
26641 be bound to @code{ia}.
26642
26643 Here's another example, for integrating cosines of linear
26644 terms: @samp{myint(cos(y),x) := sin(y)/b :: let([a,b,x] := lin(y,x))}.
26645 The @code{lin} function returns a 3-vector if its argument is linear,
26646 or leaves itself unevaluated if not. But an unevaluated @code{lin}
26647 call will not match the 3-vector on the lefthand side of the @code{let},
26648 so this @code{let} both verifies that @code{y} is linear, and binds
26649 the coefficients @code{a} and @code{b} for use elsewhere in the rule.
26650 (It would have been possible to use @samp{sin(a x + b)/b} for the
26651 righthand side instead, but using @samp{sin(y)/b} avoids gratuitous
26652 rearrangement of the argument of the sine.)
26653
26654 @ignore
26655 @starindex
26656 @end ignore
26657 @tindex ierf
26658 Similarly, here is a rule that implements an inverse-@code{erf}
26659 function. It uses @code{root} to search for a solution. If
26660 @code{root} succeeds, it will return a vector of two numbers
26661 where the first number is the desired solution. If no solution
26662 is found, @code{root} remains in symbolic form. So we use
26663 @code{let} to check that the result was indeed a vector.
26664
26665 @example
26666 ierf(x) := y :: let([y,z] := root(erf(a) = x, a, .5))
26667 @end example
26668
26669 @item matches(v,p)
26670 The meta-variable @var{v}, which must already have been matched
26671 to something elsewhere in the rule, is compared against pattern
26672 @var{p}. Since @code{matches} is a standard Calc function, it
26673 can appear anywhere in a condition. But if it appears alone or
26674 as a term of a top-level @samp{&&}, then you get the special
26675 extra feature that meta-variables which are bound to things
26676 inside @var{p} can be used elsewhere in the surrounding rewrite
26677 rule.
26678
26679 The only real difference between @samp{let(p := v)} and
26680 @samp{matches(v, p)} is that the former evaluates @samp{v} using
26681 the default simplifications, while the latter does not.
26682
26683 @item remember
26684 @vindex remember
26685 This is actually a variable, not a function. If @code{remember}
26686 appears as a condition in a rule, then when that rule succeeds
26687 the original expression and rewritten expression are added to the
26688 front of the rule set that contained the rule. If the rule set
26689 was not stored in a variable, @code{remember} is ignored. The
26690 lefthand side is enclosed in @code{quote} in the added rule if it
26691 contains any variables.
26692
26693 For example, the rule @samp{f(n) := n f(n-1) :: remember} applied
26694 to @samp{f(7)} will add the rule @samp{f(7) := 7 f(6)} to the front
26695 of the rule set. The rule set @code{EvalRules} works slightly
26696 differently: There, the evaluation of @samp{f(6)} will complete before
26697 the result is added to the rule set, in this case as @samp{f(7) := 5040}.
26698 Thus @code{remember} is most useful inside @code{EvalRules}.
26699
26700 It is up to you to ensure that the optimization performed by
26701 @code{remember} is safe. For example, the rule @samp{foo(n) := n
26702 :: evalv(eatfoo) > 0 :: remember} is a bad idea (@code{evalv} is
26703 the function equivalent of the @kbd{=} command); if the variable
26704 @code{eatfoo} ever contains 1, rules like @samp{foo(7) := 7} will
26705 be added to the rule set and will continue to operate even if
26706 @code{eatfoo} is later changed to 0.
26707
26708 @item remember(c)
26709 @ignore
26710 @starindex
26711 @end ignore
26712 @tindex remember
26713 Remember the match as described above, but only if condition @expr{c}
26714 is true. For example, @samp{remember(n % 4 = 0)} in the above factorial
26715 rule remembers only every fourth result. Note that @samp{remember(1)}
26716 is equivalent to @samp{remember}, and @samp{remember(0)} has no effect.
26717 @end table
26718
26719 @node Composing Patterns in Rewrite Rules, Nested Formulas with Rewrite Rules, Other Features of Rewrite Rules, Rewrite Rules
26720 @subsection Composing Patterns in Rewrite Rules
26721
26722 @noindent
26723 There are three operators, @samp{&&&}, @samp{|||}, and @samp{!!!},
26724 that combine rewrite patterns to make larger patterns. The
26725 combinations are ``and,'' ``or,'' and ``not,'' respectively, and
26726 these operators are the pattern equivalents of @samp{&&}, @samp{||}
26727 and @samp{!} (which operate on zero-or-nonzero logical values).
26728
26729 Note that @samp{&&&}, @samp{|||}, and @samp{!!!} are left in symbolic
26730 form by all regular Calc features; they have special meaning only in
26731 the context of rewrite rule patterns.
26732
26733 The pattern @samp{@var{p1} &&& @var{p2}} matches anything that
26734 matches both @var{p1} and @var{p2}. One especially useful case is
26735 when one of @var{p1} or @var{p2} is a meta-variable. For example,
26736 here is a rule that operates on error forms:
26737
26738 @example
26739 f(x &&& a +/- b, x) := g(x)
26740 @end example
26741
26742 This does the same thing, but is arguably simpler than, the rule
26743
26744 @example
26745 f(a +/- b, a +/- b) := g(a +/- b)
26746 @end example
26747
26748 @ignore
26749 @starindex
26750 @end ignore
26751 @tindex ends
26752 Here's another interesting example:
26753
26754 @example
26755 ends(cons(a, x) &&& rcons(y, b)) := [a, b]
26756 @end example
26757
26758 @noindent
26759 which effectively clips out the middle of a vector leaving just
26760 the first and last elements. This rule will change a one-element
26761 vector @samp{[a]} to @samp{[a, a]}. The similar rule
26762
26763 @example
26764 ends(cons(a, rcons(y, b))) := [a, b]
26765 @end example
26766
26767 @noindent
26768 would do the same thing except that it would fail to match a
26769 one-element vector.
26770
26771 @tex
26772 \bigskip
26773 @end tex
26774
26775 The pattern @samp{@var{p1} ||| @var{p2}} matches anything that
26776 matches either @var{p1} or @var{p2}. Calc first tries matching
26777 against @var{p1}; if that fails, it goes on to try @var{p2}.
26778
26779 @ignore
26780 @starindex
26781 @end ignore
26782 @tindex curve
26783 A simple example of @samp{|||} is
26784
26785 @example
26786 curve(inf ||| -inf) := 0
26787 @end example
26788
26789 @noindent
26790 which converts both @samp{curve(inf)} and @samp{curve(-inf)} to zero.
26791
26792 Here is a larger example:
26793
26794 @example
26795 log(a, b) ||| (ln(a) :: let(b := e)) := mylog(a, b)
26796 @end example
26797
26798 This matches both generalized and natural logarithms in a single rule.
26799 Note that the @samp{::} term must be enclosed in parentheses because
26800 that operator has lower precedence than @samp{|||} or @samp{:=}.
26801
26802 (In practice this rule would probably include a third alternative,
26803 omitted here for brevity, to take care of @code{log10}.)
26804
26805 While Calc generally treats interior conditions exactly the same as
26806 conditions on the outside of a rule, it does guarantee that if all the
26807 variables in the condition are special names like @code{e}, or already
26808 bound in the pattern to which the condition is attached (say, if
26809 @samp{a} had appeared in this condition), then Calc will process this
26810 condition right after matching the pattern to the left of the @samp{::}.
26811 Thus, we know that @samp{b} will be bound to @samp{e} only if the
26812 @code{ln} branch of the @samp{|||} was taken.
26813
26814 Note that this rule was careful to bind the same set of meta-variables
26815 on both sides of the @samp{|||}. Calc does not check this, but if
26816 you bind a certain meta-variable only in one branch and then use that
26817 meta-variable elsewhere in the rule, results are unpredictable:
26818
26819 @example
26820 f(a,b) ||| g(b) := h(a,b)
26821 @end example
26822
26823 Here if the pattern matches @samp{g(17)}, Calc makes no promises about
26824 the value that will be substituted for @samp{a} on the righthand side.
26825
26826 @tex
26827 \bigskip
26828 @end tex
26829
26830 The pattern @samp{!!! @var{pat}} matches anything that does not
26831 match @var{pat}. Any meta-variables that are bound while matching
26832 @var{pat} remain unbound outside of @var{pat}.
26833
26834 For example,
26835
26836 @example
26837 f(x &&& !!! a +/- b, !!![]) := g(x)
26838 @end example
26839
26840 @noindent
26841 converts @code{f} whose first argument is anything @emph{except} an
26842 error form, and whose second argument is not the empty vector, into
26843 a similar call to @code{g} (but without the second argument).
26844
26845 If we know that the second argument will be a vector (empty or not),
26846 then an equivalent rule would be:
26847
26848 @example
26849 f(x, y) := g(x) :: typeof(x) != 7 :: vlen(y) > 0
26850 @end example
26851
26852 @noindent
26853 where of course 7 is the @code{typeof} code for error forms.
26854 Another final condition, that works for any kind of @samp{y},
26855 would be @samp{!istrue(y == [])}. (The @code{istrue} function
26856 returns an explicit 0 if its argument was left in symbolic form;
26857 plain @samp{!(y == [])} or @samp{y != []} would not work to replace
26858 @samp{!!![]} since these would be left unsimplified, and thus cause
26859 the rule to fail, if @samp{y} was something like a variable name.)
26860
26861 It is possible for a @samp{!!!} to refer to meta-variables bound
26862 elsewhere in the pattern. For example,
26863
26864 @example
26865 f(a, !!!a) := g(a)
26866 @end example
26867
26868 @noindent
26869 matches any call to @code{f} with different arguments, changing
26870 this to @code{g} with only the first argument.
26871
26872 If a function call is to be matched and one of the argument patterns
26873 contains a @samp{!!!} somewhere inside it, that argument will be
26874 matched last. Thus
26875
26876 @example
26877 f(!!!a, a) := g(a)
26878 @end example
26879
26880 @noindent
26881 will be careful to bind @samp{a} to the second argument of @code{f}
26882 before testing the first argument. If Calc had tried to match the
26883 first argument of @code{f} first, the results would have been
26884 disastrous: since @code{a} was unbound so far, the pattern @samp{a}
26885 would have matched anything at all, and the pattern @samp{!!!a}
26886 therefore would @emph{not} have matched anything at all!
26887
26888 @node Nested Formulas with Rewrite Rules, Multi-Phase Rewrite Rules, Composing Patterns in Rewrite Rules, Rewrite Rules
26889 @subsection Nested Formulas with Rewrite Rules
26890
26891 @noindent
26892 When @kbd{a r} (@code{calc-rewrite}) is used, it takes an expression from
26893 the top of the stack and attempts to match any of the specified rules
26894 to any part of the expression, starting with the whole expression
26895 and then, if that fails, trying deeper and deeper sub-expressions.
26896 For each part of the expression, the rules are tried in the order
26897 they appear in the rules vector. The first rule to match the first
26898 sub-expression wins; it replaces the matched sub-expression according
26899 to the @var{new} part of the rule.
26900
26901 Often, the rule set will match and change the formula several times.
26902 The top-level formula is first matched and substituted repeatedly until
26903 it no longer matches the pattern; then, sub-formulas are tried, and
26904 so on. Once every part of the formula has gotten its chance, the
26905 rewrite mechanism starts over again with the top-level formula
26906 (in case a substitution of one of its arguments has caused it again
26907 to match). This continues until no further matches can be made
26908 anywhere in the formula.
26909
26910 It is possible for a rule set to get into an infinite loop. The
26911 most obvious case, replacing a formula with itself, is not a problem
26912 because a rule is not considered to ``succeed'' unless the righthand
26913 side actually comes out to something different than the original
26914 formula or sub-formula that was matched. But if you accidentally
26915 had both @samp{ln(a b) := ln(a) + ln(b)} and the reverse
26916 @samp{ln(a) + ln(b) := ln(a b)} in your rule set, Calc would
26917 run forever switching a formula back and forth between the two
26918 forms.
26919
26920 To avoid disaster, Calc normally stops after 100 changes have been
26921 made to the formula. This will be enough for most multiple rewrites,
26922 but it will keep an endless loop of rewrites from locking up the
26923 computer forever. (On most systems, you can also type @kbd{C-g} to
26924 halt any Emacs command prematurely.)
26925
26926 To change this limit, give a positive numeric prefix argument.
26927 In particular, @kbd{M-1 a r} applies only one rewrite at a time,
26928 useful when you are first testing your rule (or just if repeated
26929 rewriting is not what is called for by your application).
26930
26931 @ignore
26932 @starindex
26933 @end ignore
26934 @ignore
26935 @mindex iter@idots
26936 @end ignore
26937 @tindex iterations
26938 You can also put a ``function call'' @samp{iterations(@var{n})}
26939 in place of a rule anywhere in your rules vector (but usually at
26940 the top). Then, @var{n} will be used instead of 100 as the default
26941 number of iterations for this rule set. You can use
26942 @samp{iterations(inf)} if you want no iteration limit by default.
26943 A prefix argument will override the @code{iterations} limit in the
26944 rule set.
26945
26946 @example
26947 [ iterations(1),
26948 f(x) := f(x+1) ]
26949 @end example
26950
26951 More precisely, the limit controls the number of ``iterations,''
26952 where each iteration is a successful matching of a rule pattern whose
26953 righthand side, after substituting meta-variables and applying the
26954 default simplifications, is different from the original sub-formula
26955 that was matched.
26956
26957 A prefix argument of zero sets the limit to infinity. Use with caution!
26958
26959 Given a negative numeric prefix argument, @kbd{a r} will match and
26960 substitute the top-level expression up to that many times, but
26961 will not attempt to match the rules to any sub-expressions.
26962
26963 In a formula, @code{rewrite(@var{expr}, @var{rules}, @var{n})}
26964 does a rewriting operation. Here @var{expr} is the expression
26965 being rewritten, @var{rules} is the rule, vector of rules, or
26966 variable containing the rules, and @var{n} is the optional
26967 iteration limit, which may be a positive integer, a negative
26968 integer, or @samp{inf} or @samp{-inf}. If @var{n} is omitted
26969 the @code{iterations} value from the rule set is used; if both
26970 are omitted, 100 is used.
26971
26972 @node Multi-Phase Rewrite Rules, Selections with Rewrite Rules, Nested Formulas with Rewrite Rules, Rewrite Rules
26973 @subsection Multi-Phase Rewrite Rules
26974
26975 @noindent
26976 It is possible to separate a rewrite rule set into several @dfn{phases}.
26977 During each phase, certain rules will be enabled while certain others
26978 will be disabled. A @dfn{phase schedule} controls the order in which
26979 phases occur during the rewriting process.
26980
26981 @ignore
26982 @starindex
26983 @end ignore
26984 @tindex phase
26985 @vindex all
26986 If a call to the marker function @code{phase} appears in the rules
26987 vector in place of a rule, all rules following that point will be
26988 members of the phase(s) identified in the arguments to @code{phase}.
26989 Phases are given integer numbers. The markers @samp{phase()} and
26990 @samp{phase(all)} both mean the following rules belong to all phases;
26991 this is the default at the start of the rule set.
26992
26993 If you do not explicitly schedule the phases, Calc sorts all phase
26994 numbers that appear in the rule set and executes the phases in
26995 ascending order. For example, the rule set
26996
26997 @example
26998 @group
26999 [ f0(x) := g0(x),
27000 phase(1),
27001 f1(x) := g1(x),
27002 phase(2),
27003 f2(x) := g2(x),
27004 phase(3),
27005 f3(x) := g3(x),
27006 phase(1,2),
27007 f4(x) := g4(x) ]
27008 @end group
27009 @end example
27010
27011 @noindent
27012 has three phases, 1 through 3. Phase 1 consists of the @code{f0},
27013 @code{f1}, and @code{f4} rules (in that order). Phase 2 consists of
27014 @code{f0}, @code{f2}, and @code{f4}. Phase 3 consists of @code{f0}
27015 and @code{f3}.
27016
27017 When Calc rewrites a formula using this rule set, it first rewrites
27018 the formula using only the phase 1 rules until no further changes are
27019 possible. Then it switches to the phase 2 rule set and continues
27020 until no further changes occur, then finally rewrites with phase 3.
27021 When no more phase 3 rules apply, rewriting finishes. (This is
27022 assuming @kbd{a r} with a large enough prefix argument to allow the
27023 rewriting to run to completion; the sequence just described stops
27024 early if the number of iterations specified in the prefix argument,
27025 100 by default, is reached.)
27026
27027 During each phase, Calc descends through the nested levels of the
27028 formula as described previously. (@xref{Nested Formulas with Rewrite
27029 Rules}.) Rewriting starts at the top of the formula, then works its
27030 way down to the parts, then goes back to the top and works down again.
27031 The phase 2 rules do not begin until no phase 1 rules apply anywhere
27032 in the formula.
27033
27034 @ignore
27035 @starindex
27036 @end ignore
27037 @tindex schedule
27038 A @code{schedule} marker appearing in the rule set (anywhere, but
27039 conventionally at the top) changes the default schedule of phases.
27040 In the simplest case, @code{schedule} has a sequence of phase numbers
27041 for arguments; each phase number is invoked in turn until the
27042 arguments to @code{schedule} are exhausted. Thus adding
27043 @samp{schedule(3,2,1)} at the top of the above rule set would
27044 reverse the order of the phases; @samp{schedule(1,2,3)} would have
27045 no effect since this is the default schedule; and @samp{schedule(1,2,1,3)}
27046 would give phase 1 a second chance after phase 2 has completed, before
27047 moving on to phase 3.
27048
27049 Any argument to @code{schedule} can instead be a vector of phase
27050 numbers (or even of sub-vectors). Then the sub-sequence of phases
27051 described by the vector are tried repeatedly until no change occurs
27052 in any phase in the sequence. For example, @samp{schedule([1, 2], 3)}
27053 tries phase 1, then phase 2, then, if either phase made any changes
27054 to the formula, repeats these two phases until they can make no
27055 further progress. Finally, it goes on to phase 3 for finishing
27056 touches.
27057
27058 Also, items in @code{schedule} can be variable names as well as
27059 numbers. A variable name is interpreted as the name of a function
27060 to call on the whole formula. For example, @samp{schedule(1, simplify)}
27061 says to apply the phase-1 rules (presumably, all of them), then to
27062 call @code{simplify} which is the function name equivalent of @kbd{a s}.
27063 Likewise, @samp{schedule([1, simplify])} says to alternate between
27064 phase 1 and @kbd{a s} until no further changes occur.
27065
27066 Phases can be used purely to improve efficiency; if it is known that
27067 a certain group of rules will apply only at the beginning of rewriting,
27068 and a certain other group will apply only at the end, then rewriting
27069 will be faster if these groups are identified as separate phases.
27070 Once the phase 1 rules are done, Calc can put them aside and no longer
27071 spend any time on them while it works on phase 2.
27072
27073 There are also some problems that can only be solved with several
27074 rewrite phases. For a real-world example of a multi-phase rule set,
27075 examine the set @code{FitRules}, which is used by the curve-fitting
27076 command to convert a model expression to linear form.
27077 @xref{Curve Fitting Details}. This set is divided into four phases.
27078 The first phase rewrites certain kinds of expressions to be more
27079 easily linearizable, but less computationally efficient. After the
27080 linear components have been picked out, the final phase includes the
27081 opposite rewrites to put each component back into an efficient form.
27082 If both sets of rules were included in one big phase, Calc could get
27083 into an infinite loop going back and forth between the two forms.
27084
27085 Elsewhere in @code{FitRules}, the components are first isolated,
27086 then recombined where possible to reduce the complexity of the linear
27087 fit, then finally packaged one component at a time into vectors.
27088 If the packaging rules were allowed to begin before the recombining
27089 rules were finished, some components might be put away into vectors
27090 before they had a chance to recombine. By putting these rules in
27091 two separate phases, this problem is neatly avoided.
27092
27093 @node Selections with Rewrite Rules, Matching Commands, Multi-Phase Rewrite Rules, Rewrite Rules
27094 @subsection Selections with Rewrite Rules
27095
27096 @noindent
27097 If a sub-formula of the current formula is selected (as by @kbd{j s};
27098 @pxref{Selecting Subformulas}), the @kbd{a r} (@code{calc-rewrite})
27099 command applies only to that sub-formula. Together with a negative
27100 prefix argument, you can use this fact to apply a rewrite to one
27101 specific part of a formula without affecting any other parts.
27102
27103 @kindex j r
27104 @pindex calc-rewrite-selection
27105 The @kbd{j r} (@code{calc-rewrite-selection}) command allows more
27106 sophisticated operations on selections. This command prompts for
27107 the rules in the same way as @kbd{a r}, but it then applies those
27108 rules to the whole formula in question even though a sub-formula
27109 of it has been selected. However, the selected sub-formula will
27110 first have been surrounded by a @samp{select( )} function call.
27111 (Calc's evaluator does not understand the function name @code{select};
27112 this is only a tag used by the @kbd{j r} command.)
27113
27114 For example, suppose the formula on the stack is @samp{2 (a + b)^2}
27115 and the sub-formula @samp{a + b} is selected. This formula will
27116 be rewritten to @samp{2 select(a + b)^2} and then the rewrite
27117 rules will be applied in the usual way. The rewrite rules can
27118 include references to @code{select} to tell where in the pattern
27119 the selected sub-formula should appear.
27120
27121 If there is still exactly one @samp{select( )} function call in
27122 the formula after rewriting is done, it indicates which part of
27123 the formula should be selected afterwards. Otherwise, the
27124 formula will be unselected.
27125
27126 You can make @kbd{j r} act much like @kbd{a r} by enclosing both parts
27127 of the rewrite rule with @samp{select()}. However, @kbd{j r}
27128 allows you to use the current selection in more flexible ways.
27129 Suppose you wished to make a rule which removed the exponent from
27130 the selected term; the rule @samp{select(a)^x := select(a)} would
27131 work. In the above example, it would rewrite @samp{2 select(a + b)^2}
27132 to @samp{2 select(a + b)}. This would then be returned to the
27133 stack as @samp{2 (a + b)} with the @samp{a + b} selected.
27134
27135 The @kbd{j r} command uses one iteration by default, unlike
27136 @kbd{a r} which defaults to 100 iterations. A numeric prefix
27137 argument affects @kbd{j r} in the same way as @kbd{a r}.
27138 @xref{Nested Formulas with Rewrite Rules}.
27139
27140 As with other selection commands, @kbd{j r} operates on the stack
27141 entry that contains the cursor. (If the cursor is on the top-of-stack
27142 @samp{.} marker, it works as if the cursor were on the formula
27143 at stack level 1.)
27144
27145 If you don't specify a set of rules, the rules are taken from the
27146 top of the stack, just as with @kbd{a r}. In this case, the
27147 cursor must indicate stack entry 2 or above as the formula to be
27148 rewritten (otherwise the same formula would be used as both the
27149 target and the rewrite rules).
27150
27151 If the indicated formula has no selection, the cursor position within
27152 the formula temporarily selects a sub-formula for the purposes of this
27153 command. If the cursor is not on any sub-formula (e.g., it is in
27154 the line-number area to the left of the formula), the @samp{select( )}
27155 markers are ignored by the rewrite mechanism and the rules are allowed
27156 to apply anywhere in the formula.
27157
27158 As a special feature, the normal @kbd{a r} command also ignores
27159 @samp{select( )} calls in rewrite rules. For example, if you used the
27160 above rule @samp{select(a)^x := select(a)} with @kbd{a r}, it would apply
27161 the rule as if it were @samp{a^x := a}. Thus, you can write general
27162 purpose rules with @samp{select( )} hints inside them so that they
27163 will ``do the right thing'' in both @kbd{a r} and @kbd{j r},
27164 both with and without selections.
27165
27166 @node Matching Commands, Automatic Rewrites, Selections with Rewrite Rules, Rewrite Rules
27167 @subsection Matching Commands
27168
27169 @noindent
27170 @kindex a m
27171 @pindex calc-match
27172 @tindex match
27173 The @kbd{a m} (@code{calc-match}) [@code{match}] function takes a
27174 vector of formulas and a rewrite-rule-style pattern, and produces
27175 a vector of all formulas which match the pattern. The command
27176 prompts you to enter the pattern; as for @kbd{a r}, you can enter
27177 a single pattern (i.e., a formula with meta-variables), or a
27178 vector of patterns, or a variable which contains patterns, or
27179 you can give a blank response in which case the patterns are taken
27180 from the top of the stack. The pattern set will be compiled once
27181 and saved if it is stored in a variable. If there are several
27182 patterns in the set, vector elements are kept if they match any
27183 of the patterns.
27184
27185 For example, @samp{match(a+b, [x, x+y, x-y, 7, x+y+z])}
27186 will return @samp{[x+y, x-y, x+y+z]}.
27187
27188 The @code{import} mechanism is not available for pattern sets.
27189
27190 The @kbd{a m} command can also be used to extract all vector elements
27191 which satisfy any condition: The pattern @samp{x :: x>0} will select
27192 all the positive vector elements.
27193
27194 @kindex I a m
27195 @tindex matchnot
27196 With the Inverse flag [@code{matchnot}], this command extracts all
27197 vector elements which do @emph{not} match the given pattern.
27198
27199 @ignore
27200 @starindex
27201 @end ignore
27202 @tindex matches
27203 There is also a function @samp{matches(@var{x}, @var{p})} which
27204 evaluates to 1 if expression @var{x} matches pattern @var{p}, or
27205 to 0 otherwise. This is sometimes useful for including into the
27206 conditional clauses of other rewrite rules.
27207
27208 @ignore
27209 @starindex
27210 @end ignore
27211 @tindex vmatches
27212 The function @code{vmatches} is just like @code{matches}, except
27213 that if the match succeeds it returns a vector of assignments to
27214 the meta-variables instead of the number 1. For example,
27215 @samp{vmatches(f(1,2), f(a,b))} returns @samp{[a := 1, b := 2]}.
27216 If the match fails, the function returns the number 0.
27217
27218 @node Automatic Rewrites, Debugging Rewrites, Matching Commands, Rewrite Rules
27219 @subsection Automatic Rewrites
27220
27221 @noindent
27222 @cindex @code{EvalRules} variable
27223 @vindex EvalRules
27224 It is possible to get Calc to apply a set of rewrite rules on all
27225 results, effectively adding to the built-in set of default
27226 simplifications. To do this, simply store your rule set in the
27227 variable @code{EvalRules}. There is a convenient @kbd{s E} command
27228 for editing @code{EvalRules}; @pxref{Operations on Variables}.
27229
27230 For example, suppose you want @samp{sin(a + b)} to be expanded out
27231 to @samp{sin(b) cos(a) + cos(b) sin(a)} wherever it appears, and
27232 similarly for @samp{cos(a + b)}. The corresponding rewrite rule
27233 set would be,
27234
27235 @smallexample
27236 @group
27237 [ sin(a + b) := cos(a) sin(b) + sin(a) cos(b),
27238 cos(a + b) := cos(a) cos(b) - sin(a) sin(b) ]
27239 @end group
27240 @end smallexample
27241
27242 To apply these manually, you could put them in a variable called
27243 @code{trigexp} and then use @kbd{a r trigexp} every time you wanted
27244 to expand trig functions. But if instead you store them in the
27245 variable @code{EvalRules}, they will automatically be applied to all
27246 sines and cosines of sums. Then, with @samp{2 x} and @samp{45} on
27247 the stack, typing @kbd{+ S} will (assuming Degrees mode) result in
27248 @samp{0.7071 sin(2 x) + 0.7071 cos(2 x)} automatically.
27249
27250 As each level of a formula is evaluated, the rules from
27251 @code{EvalRules} are applied before the default simplifications.
27252 Rewriting continues until no further @code{EvalRules} apply.
27253 Note that this is different from the usual order of application of
27254 rewrite rules: @code{EvalRules} works from the bottom up, simplifying
27255 the arguments to a function before the function itself, while @kbd{a r}
27256 applies rules from the top down.
27257
27258 Because the @code{EvalRules} are tried first, you can use them to
27259 override the normal behavior of any built-in Calc function.
27260
27261 It is important not to write a rule that will get into an infinite
27262 loop. For example, the rule set @samp{[f(0) := 1, f(n) := n f(n-1)]}
27263 appears to be a good definition of a factorial function, but it is
27264 unsafe. Imagine what happens if @samp{f(2.5)} is simplified. Calc
27265 will continue to subtract 1 from this argument forever without reaching
27266 zero. A safer second rule would be @samp{f(n) := n f(n-1) :: n>0}.
27267 Another dangerous rule is @samp{g(x, y) := g(y, x)}. Rewriting
27268 @samp{g(2, 4)}, this would bounce back and forth between that and
27269 @samp{g(4, 2)} forever. If an infinite loop in @code{EvalRules}
27270 occurs, Emacs will eventually stop with a ``Computation got stuck
27271 or ran too long'' message.
27272
27273 Another subtle difference between @code{EvalRules} and regular rewrites
27274 concerns rules that rewrite a formula into an identical formula. For
27275 example, @samp{f(n) := f(floor(n))} ``fails to match'' when @expr{n} is
27276 already an integer. But in @code{EvalRules} this case is detected only
27277 if the righthand side literally becomes the original formula before any
27278 further simplification. This means that @samp{f(n) := f(floor(n))} will
27279 get into an infinite loop if it occurs in @code{EvalRules}. Calc will
27280 replace @samp{f(6)} with @samp{f(floor(6))}, which is different from
27281 @samp{f(6)}, so it will consider the rule to have matched and will
27282 continue simplifying that formula; first the argument is simplified
27283 to get @samp{f(6)}, then the rule matches again to get @samp{f(floor(6))}
27284 again, ad infinitum. A much safer rule would check its argument first,
27285 say, with @samp{f(n) := f(floor(n)) :: !dint(n)}.
27286
27287 (What really happens is that the rewrite mechanism substitutes the
27288 meta-variables in the righthand side of a rule, compares to see if the
27289 result is the same as the original formula and fails if so, then uses
27290 the default simplifications to simplify the result and compares again
27291 (and again fails if the formula has simplified back to its original
27292 form). The only special wrinkle for the @code{EvalRules} is that the
27293 same rules will come back into play when the default simplifications
27294 are used. What Calc wants to do is build @samp{f(floor(6))}, see that
27295 this is different from the original formula, simplify to @samp{f(6)},
27296 see that this is the same as the original formula, and thus halt the
27297 rewriting. But while simplifying, @samp{f(6)} will again trigger
27298 the same @code{EvalRules} rule and Calc will get into a loop inside
27299 the rewrite mechanism itself.)
27300
27301 The @code{phase}, @code{schedule}, and @code{iterations} markers do
27302 not work in @code{EvalRules}. If the rule set is divided into phases,
27303 only the phase 1 rules are applied, and the schedule is ignored.
27304 The rules are always repeated as many times as possible.
27305
27306 The @code{EvalRules} are applied to all function calls in a formula,
27307 but not to numbers (and other number-like objects like error forms),
27308 nor to vectors or individual variable names. (Though they will apply
27309 to @emph{components} of vectors and error forms when appropriate.) You
27310 might try to make a variable @code{phihat} which automatically expands
27311 to its definition without the need to press @kbd{=} by writing the
27312 rule @samp{quote(phihat) := (1-sqrt(5))/2}, but unfortunately this rule
27313 will not work as part of @code{EvalRules}.
27314
27315 Finally, another limitation is that Calc sometimes calls its built-in
27316 functions directly rather than going through the default simplifications.
27317 When it does this, @code{EvalRules} will not be able to override those
27318 functions. For example, when you take the absolute value of the complex
27319 number @expr{(2, 3)}, Calc computes @samp{sqrt(2*2 + 3*3)} by calling
27320 the multiplication, addition, and square root functions directly rather
27321 than applying the default simplifications to this formula. So an
27322 @code{EvalRules} rule that (perversely) rewrites @samp{sqrt(13) := 6}
27323 would not apply. (However, if you put Calc into Symbolic mode so that
27324 @samp{sqrt(13)} will be left in symbolic form by the built-in square
27325 root function, your rule will be able to apply. But if the complex
27326 number were @expr{(3,4)}, so that @samp{sqrt(25)} must be calculated,
27327 then Symbolic mode will not help because @samp{sqrt(25)} can be
27328 evaluated exactly to 5.)
27329
27330 One subtle restriction that normally only manifests itself with
27331 @code{EvalRules} is that while a given rewrite rule is in the process
27332 of being checked, that same rule cannot be recursively applied. Calc
27333 effectively removes the rule from its rule set while checking the rule,
27334 then puts it back once the match succeeds or fails. (The technical
27335 reason for this is that compiled pattern programs are not reentrant.)
27336 For example, consider the rule @samp{foo(x) := x :: foo(x/2) > 0}
27337 attempting to match @samp{foo(8)}. This rule will be inactive while
27338 the condition @samp{foo(4) > 0} is checked, even though it might be
27339 an integral part of evaluating that condition. Note that this is not
27340 a problem for the more usual recursive type of rule, such as
27341 @samp{foo(x) := foo(x/2)}, because there the rule has succeeded and
27342 been reactivated by the time the righthand side is evaluated.
27343
27344 If @code{EvalRules} has no stored value (its default state), or if
27345 anything but a vector is stored in it, then it is ignored.
27346
27347 Even though Calc's rewrite mechanism is designed to compare rewrite
27348 rules to formulas as quickly as possible, storing rules in
27349 @code{EvalRules} may make Calc run substantially slower. This is
27350 particularly true of rules where the top-level call is a commonly used
27351 function, or is not fixed. The rule @samp{f(n) := n f(n-1) :: n>0} will
27352 only activate the rewrite mechanism for calls to the function @code{f},
27353 but @samp{lg(n) + lg(m) := lg(n m)} will check every @samp{+} operator.
27354
27355 @smallexample
27356 apply(f, [a*b]) := apply(f, [a]) + apply(f, [b]) :: in(f, [ln, log10])
27357 @end smallexample
27358
27359 @noindent
27360 may seem more ``efficient'' than two separate rules for @code{ln} and
27361 @code{log10}, but actually it is vastly less efficient because rules
27362 with @code{apply} as the top-level pattern must be tested against
27363 @emph{every} function call that is simplified.
27364
27365 @cindex @code{AlgSimpRules} variable
27366 @vindex AlgSimpRules
27367 Suppose you want @samp{sin(a + b)} to be expanded out not all the time,
27368 but only when @kbd{a s} is used to simplify the formula. The variable
27369 @code{AlgSimpRules} holds rules for this purpose. The @kbd{a s} command
27370 will apply @code{EvalRules} and @code{AlgSimpRules} to the formula, as
27371 well as all of its built-in simplifications.
27372
27373 Most of the special limitations for @code{EvalRules} don't apply to
27374 @code{AlgSimpRules}. Calc simply does an @kbd{a r AlgSimpRules}
27375 command with an infinite repeat count as the first step of @kbd{a s}.
27376 It then applies its own built-in simplifications throughout the
27377 formula, and then repeats these two steps (along with applying the
27378 default simplifications) until no further changes are possible.
27379
27380 @cindex @code{ExtSimpRules} variable
27381 @cindex @code{UnitSimpRules} variable
27382 @vindex ExtSimpRules
27383 @vindex UnitSimpRules
27384 There are also @code{ExtSimpRules} and @code{UnitSimpRules} variables
27385 that are used by @kbd{a e} and @kbd{u s}, respectively; these commands
27386 also apply @code{EvalRules} and @code{AlgSimpRules}. The variable
27387 @code{IntegSimpRules} contains simplification rules that are used
27388 only during integration by @kbd{a i}.
27389
27390 @node Debugging Rewrites, Examples of Rewrite Rules, Automatic Rewrites, Rewrite Rules
27391 @subsection Debugging Rewrites
27392
27393 @noindent
27394 If a buffer named @samp{*Trace*} exists, the rewrite mechanism will
27395 record some useful information there as it operates. The original
27396 formula is written there, as is the result of each successful rewrite,
27397 and the final result of the rewriting. All phase changes are also
27398 noted.
27399
27400 Calc always appends to @samp{*Trace*}. You must empty this buffer
27401 yourself periodically if it is in danger of growing unwieldy.
27402
27403 Note that the rewriting mechanism is substantially slower when the
27404 @samp{*Trace*} buffer exists, even if the buffer is not visible on
27405 the screen. Once you are done, you will probably want to kill this
27406 buffer (with @kbd{C-x k *Trace* @key{RET}}). If you leave it in
27407 existence and forget about it, all your future rewrite commands will
27408 be needlessly slow.
27409
27410 @node Examples of Rewrite Rules, , Debugging Rewrites, Rewrite Rules
27411 @subsection Examples of Rewrite Rules
27412
27413 @noindent
27414 Returning to the example of substituting the pattern
27415 @samp{sin(x)^2 + cos(x)^2} with 1, we saw that the rule
27416 @samp{opt(a) sin(x)^2 + opt(a) cos(x)^2 := a} does a good job of
27417 finding suitable cases. Another solution would be to use the rule
27418 @samp{cos(x)^2 := 1 - sin(x)^2}, followed by algebraic simplification
27419 if necessary. This rule will be the most effective way to do the job,
27420 but at the expense of making some changes that you might not desire.
27421
27422 Another algebraic rewrite rule is @samp{exp(x+y) := exp(x) exp(y)}.
27423 To make this work with the @w{@kbd{j r}} command so that it can be
27424 easily targeted to a particular exponential in a large formula,
27425 you might wish to write the rule as @samp{select(exp(x+y)) :=
27426 select(exp(x) exp(y))}. The @samp{select} markers will be
27427 ignored by the regular @kbd{a r} command
27428 (@pxref{Selections with Rewrite Rules}).
27429
27430 A surprisingly useful rewrite rule is @samp{a/(b-c) := a*(b+c)/(b^2-c^2)}.
27431 This will simplify the formula whenever @expr{b} and/or @expr{c} can
27432 be made simpler by squaring. For example, applying this rule to
27433 @samp{2 / (sqrt(2) + 3)} yields @samp{6:7 - 2:7 sqrt(2)} (assuming
27434 Symbolic mode has been enabled to keep the square root from being
27435 evaluated to a floating-point approximation). This rule is also
27436 useful when working with symbolic complex numbers, e.g.,
27437 @samp{(a + b i) / (c + d i)}.
27438
27439 As another example, we could define our own ``triangular numbers'' function
27440 with the rules @samp{[tri(0) := 0, tri(n) := n + tri(n-1) :: n>0]}. Enter
27441 this vector and store it in a variable: @kbd{@w{s t} trirules}. Now, given
27442 a suitable formula like @samp{tri(5)} on the stack, type @samp{a r trirules}
27443 to apply these rules repeatedly. After six applications, @kbd{a r} will
27444 stop with 15 on the stack. Once these rules are debugged, it would probably
27445 be most useful to add them to @code{EvalRules} so that Calc will evaluate
27446 the new @code{tri} function automatically. We could then use @kbd{Z K} on
27447 the keyboard macro @kbd{' tri($) @key{RET}} to make a command that applies
27448 @code{tri} to the value on the top of the stack. @xref{Programming}.
27449
27450 @cindex Quaternions
27451 The following rule set, contributed by
27452 @texline Fran\c cois
27453 @infoline Francois
27454 Pinard, implements @dfn{quaternions}, a generalization of the concept of
27455 complex numbers. Quaternions have four components, and are here
27456 represented by function calls @samp{quat(@var{w}, [@var{x}, @var{y},
27457 @var{z}])} with ``real part'' @var{w} and the three ``imaginary'' parts
27458 collected into a vector. Various arithmetical operations on quaternions
27459 are supported. To use these rules, either add them to @code{EvalRules},
27460 or create a command based on @kbd{a r} for simplifying quaternion
27461 formulas. A convenient way to enter quaternions would be a command
27462 defined by a keyboard macro containing: @kbd{' quat($$$$, [$$$, $$, $])
27463 @key{RET}}.
27464
27465 @smallexample
27466 [ quat(w, x, y, z) := quat(w, [x, y, z]),
27467 quat(w, [0, 0, 0]) := w,
27468 abs(quat(w, v)) := hypot(w, v),
27469 -quat(w, v) := quat(-w, -v),
27470 r + quat(w, v) := quat(r + w, v) :: real(r),
27471 r - quat(w, v) := quat(r - w, -v) :: real(r),
27472 quat(w1, v1) + quat(w2, v2) := quat(w1 + w2, v1 + v2),
27473 r * quat(w, v) := quat(r * w, r * v) :: real(r),
27474 plain(quat(w1, v1) * quat(w2, v2))
27475 := quat(w1 * w2 - v1 * v2, w1 * v2 + w2 * v1 + cross(v1, v2)),
27476 quat(w1, v1) / r := quat(w1 / r, v1 / r) :: real(r),
27477 z / quat(w, v) := z * quatinv(quat(w, v)),
27478 quatinv(quat(w, v)) := quat(w, -v) / (w^2 + v^2),
27479 quatsqr(quat(w, v)) := quat(w^2 - v^2, 2 * w * v),
27480 quat(w, v)^k := quatsqr(quat(w, v)^(k / 2))
27481 :: integer(k) :: k > 0 :: k % 2 = 0,
27482 quat(w, v)^k := quatsqr(quat(w, v)^((k - 1) / 2)) * quat(w, v)
27483 :: integer(k) :: k > 2,
27484 quat(w, v)^-k := quatinv(quat(w, v)^k) :: integer(k) :: k > 0 ]
27485 @end smallexample
27486
27487 Quaternions, like matrices, have non-commutative multiplication.
27488 In other words, @expr{q1 * q2 = q2 * q1} is not necessarily true if
27489 @expr{q1} and @expr{q2} are @code{quat} forms. The @samp{quat*quat}
27490 rule above uses @code{plain} to prevent Calc from rearranging the
27491 product. It may also be wise to add the line @samp{[quat(), matrix]}
27492 to the @code{Decls} matrix, to ensure that Calc's other algebraic
27493 operations will not rearrange a quaternion product. @xref{Declarations}.
27494
27495 These rules also accept a four-argument @code{quat} form, converting
27496 it to the preferred form in the first rule. If you would rather see
27497 results in the four-argument form, just append the two items
27498 @samp{phase(2), quat(w, [x, y, z]) := quat(w, x, y, z)} to the end
27499 of the rule set. (But remember that multi-phase rule sets don't work
27500 in @code{EvalRules}.)
27501
27502 @node Units, Store and Recall, Algebra, Top
27503 @chapter Operating on Units
27504
27505 @noindent
27506 One special interpretation of algebraic formulas is as numbers with units.
27507 For example, the formula @samp{5 m / s^2} can be read ``five meters
27508 per second squared.'' The commands in this chapter help you
27509 manipulate units expressions in this form. Units-related commands
27510 begin with the @kbd{u} prefix key.
27511
27512 @menu
27513 * Basic Operations on Units::
27514 * The Units Table::
27515 * Predefined Units::
27516 * User-Defined Units::
27517 @end menu
27518
27519 @node Basic Operations on Units, The Units Table, Units, Units
27520 @section Basic Operations on Units
27521
27522 @noindent
27523 A @dfn{units expression} is a formula which is basically a number
27524 multiplied and/or divided by one or more @dfn{unit names}, which may
27525 optionally be raised to integer powers. Actually, the value part need not
27526 be a number; any product or quotient involving unit names is a units
27527 expression. Many of the units commands will also accept any formula,
27528 where the command applies to all units expressions which appear in the
27529 formula.
27530
27531 A unit name is a variable whose name appears in the @dfn{unit table},
27532 or a variable whose name is a prefix character like @samp{k} (for ``kilo'')
27533 or @samp{u} (for ``micro'') followed by a name in the unit table.
27534 A substantial table of built-in units is provided with Calc;
27535 @pxref{Predefined Units}. You can also define your own unit names;
27536 @pxref{User-Defined Units}.
27537
27538 Note that if the value part of a units expression is exactly @samp{1},
27539 it will be removed by the Calculator's automatic algebra routines: The
27540 formula @samp{1 mm} is ``simplified'' to @samp{mm}. This is only a
27541 display anomaly, however; @samp{mm} will work just fine as a
27542 representation of one millimeter.
27543
27544 You may find that Algebraic mode (@pxref{Algebraic Entry}) makes working
27545 with units expressions easier. Otherwise, you will have to remember
27546 to hit the apostrophe key every time you wish to enter units.
27547
27548 @kindex u s
27549 @pindex calc-simplify-units
27550 @ignore
27551 @mindex usimpl@idots
27552 @end ignore
27553 @tindex usimplify
27554 The @kbd{u s} (@code{calc-simplify-units}) [@code{usimplify}] command
27555 simplifies a units
27556 expression. It uses @kbd{a s} (@code{calc-simplify}) to simplify the
27557 expression first as a regular algebraic formula; it then looks for
27558 features that can be further simplified by converting one object's units
27559 to be compatible with another's. For example, @samp{5 m + 23 mm} will
27560 simplify to @samp{5.023 m}. When different but compatible units are
27561 added, the righthand term's units are converted to match those of the
27562 lefthand term. @xref{Simplification Modes}, for a way to have this done
27563 automatically at all times.
27564
27565 Units simplification also handles quotients of two units with the same
27566 dimensionality, as in @w{@samp{2 in s/L cm}} to @samp{5.08 s/L}; fractional
27567 powers of unit expressions, as in @samp{sqrt(9 mm^2)} to @samp{3 mm} and
27568 @samp{sqrt(9 acre)} to a quantity in meters; and @code{floor},
27569 @code{ceil}, @code{round}, @code{rounde}, @code{roundu}, @code{trunc},
27570 @code{float}, @code{frac}, @code{abs}, and @code{clean}
27571 applied to units expressions, in which case
27572 the operation in question is applied only to the numeric part of the
27573 expression. Finally, trigonometric functions of quantities with units
27574 of angle are evaluated, regardless of the current angular mode.
27575
27576 @kindex u c
27577 @pindex calc-convert-units
27578 The @kbd{u c} (@code{calc-convert-units}) command converts a units
27579 expression to new, compatible units. For example, given the units
27580 expression @samp{55 mph}, typing @kbd{u c m/s @key{RET}} produces
27581 @samp{24.5872 m/s}. If the units you request are inconsistent with
27582 the original units, the number will be converted into your units
27583 times whatever ``remainder'' units are left over. For example,
27584 converting @samp{55 mph} into acres produces @samp{6.08e-3 acre / m s}.
27585 (Recall that multiplication binds more strongly than division in Calc
27586 formulas, so the units here are acres per meter-second.) Remainder
27587 units are expressed in terms of ``fundamental'' units like @samp{m} and
27588 @samp{s}, regardless of the input units.
27589
27590 One special exception is that if you specify a single unit name, and
27591 a compatible unit appears somewhere in the units expression, then
27592 that compatible unit will be converted to the new unit and the
27593 remaining units in the expression will be left alone. For example,
27594 given the input @samp{980 cm/s^2}, the command @kbd{u c ms} will
27595 change the @samp{s} to @samp{ms} to get @samp{9.8e-4 cm/ms^2}.
27596 The ``remainder unit'' @samp{cm} is left alone rather than being
27597 changed to the base unit @samp{m}.
27598
27599 You can use explicit unit conversion instead of the @kbd{u s} command
27600 to gain more control over the units of the result of an expression.
27601 For example, given @samp{5 m + 23 mm}, you can type @kbd{u c m} or
27602 @kbd{u c mm} to express the result in either meters or millimeters.
27603 (For that matter, you could type @kbd{u c fath} to express the result
27604 in fathoms, if you preferred!)
27605
27606 In place of a specific set of units, you can also enter one of the
27607 units system names @code{si}, @code{mks} (equivalent), or @code{cgs}.
27608 For example, @kbd{u c si @key{RET}} converts the expression into
27609 International System of Units (SI) base units. Also, @kbd{u c base}
27610 converts to Calc's base units, which are the same as @code{si} units
27611 except that @code{base} uses @samp{g} as the fundamental unit of mass
27612 whereas @code{si} uses @samp{kg}.
27613
27614 @cindex Composite units
27615 The @kbd{u c} command also accepts @dfn{composite units}, which
27616 are expressed as the sum of several compatible unit names. For
27617 example, converting @samp{30.5 in} to units @samp{mi+ft+in} (miles,
27618 feet, and inches) produces @samp{2 ft + 6.5 in}. Calc first
27619 sorts the unit names into order of decreasing relative size.
27620 It then accounts for as much of the input quantity as it can
27621 using an integer number times the largest unit, then moves on
27622 to the next smaller unit, and so on. Only the smallest unit
27623 may have a non-integer amount attached in the result. A few
27624 standard unit names exist for common combinations, such as
27625 @code{mfi} for @samp{mi+ft+in}, and @code{tpo} for @samp{ton+lb+oz}.
27626 Composite units are expanded as if by @kbd{a x}, so that
27627 @samp{(ft+in)/hr} is first converted to @samp{ft/hr+in/hr}.
27628
27629 If the value on the stack does not contain any units, @kbd{u c} will
27630 prompt first for the old units which this value should be considered
27631 to have, then for the new units. Assuming the old and new units you
27632 give are consistent with each other, the result also will not contain
27633 any units. For example, @kbd{@w{u c} cm @key{RET} in @key{RET}} converts the number
27634 2 on the stack to 5.08.
27635
27636 @kindex u b
27637 @pindex calc-base-units
27638 The @kbd{u b} (@code{calc-base-units}) command is shorthand for
27639 @kbd{u c base}; it converts the units expression on the top of the
27640 stack into @code{base} units. If @kbd{u s} does not simplify a
27641 units expression as far as you would like, try @kbd{u b}.
27642
27643 The @kbd{u c} and @kbd{u b} commands treat temperature units (like
27644 @samp{degC} and @samp{K}) as relative temperatures. For example,
27645 @kbd{u c} converts @samp{10 degC} to @samp{18 degF}: A change of 10
27646 degrees Celsius corresponds to a change of 18 degrees Fahrenheit.
27647
27648 @kindex u t
27649 @pindex calc-convert-temperature
27650 @cindex Temperature conversion
27651 The @kbd{u t} (@code{calc-convert-temperature}) command converts
27652 absolute temperatures. The value on the stack must be a simple units
27653 expression with units of temperature only. This command would convert
27654 @samp{10 degC} to @samp{50 degF}, the equivalent temperature on the
27655 Fahrenheit scale.
27656
27657 @kindex u r
27658 @pindex calc-remove-units
27659 @kindex u x
27660 @pindex calc-extract-units
27661 The @kbd{u r} (@code{calc-remove-units}) command removes units from the
27662 formula at the top of the stack. The @kbd{u x}
27663 (@code{calc-extract-units}) command extracts only the units portion of a
27664 formula. These commands essentially replace every term of the formula
27665 that does or doesn't (respectively) look like a unit name by the
27666 constant 1, then resimplify the formula.
27667
27668 @kindex u a
27669 @pindex calc-autorange-units
27670 The @kbd{u a} (@code{calc-autorange-units}) command turns on and off a
27671 mode in which unit prefixes like @code{k} (``kilo'') are automatically
27672 applied to keep the numeric part of a units expression in a reasonable
27673 range. This mode affects @kbd{u s} and all units conversion commands
27674 except @kbd{u b}. For example, with autoranging on, @samp{12345 Hz}
27675 will be simplified to @samp{12.345 kHz}. Autoranging is useful for
27676 some kinds of units (like @code{Hz} and @code{m}), but is probably
27677 undesirable for non-metric units like @code{ft} and @code{tbsp}.
27678 (Composite units are more appropriate for those; see above.)
27679
27680 Autoranging always applies the prefix to the leftmost unit name.
27681 Calc chooses the largest prefix that causes the number to be greater
27682 than or equal to 1.0. Thus an increasing sequence of adjusted times
27683 would be @samp{1 ms, 10 ms, 100 ms, 1 s, 10 s, 100 s, 1 ks}.
27684 Generally the rule of thumb is that the number will be adjusted
27685 to be in the interval @samp{[1 .. 1000)}, although there are several
27686 exceptions to this rule. First, if the unit has a power then this
27687 is not possible; @samp{0.1 s^2} simplifies to @samp{100000 ms^2}.
27688 Second, the ``centi-'' prefix is allowed to form @code{cm} (centimeters),
27689 but will not apply to other units. The ``deci-,'' ``deka-,'' and
27690 ``hecto-'' prefixes are never used. Thus the allowable interval is
27691 @samp{[1 .. 10)} for millimeters and @samp{[1 .. 100)} for centimeters.
27692 Finally, a prefix will not be added to a unit if the resulting name
27693 is also the actual name of another unit; @samp{1e-15 t} would normally
27694 be considered a ``femto-ton,'' but it is written as @samp{1000 at}
27695 (1000 atto-tons) instead because @code{ft} would be confused with feet.
27696
27697 @node The Units Table, Predefined Units, Basic Operations on Units, Units
27698 @section The Units Table
27699
27700 @noindent
27701 @kindex u v
27702 @pindex calc-enter-units-table
27703 The @kbd{u v} (@code{calc-enter-units-table}) command displays the units table
27704 in another buffer called @code{*Units Table*}. Each entry in this table
27705 gives the unit name as it would appear in an expression, the definition
27706 of the unit in terms of simpler units, and a full name or description of
27707 the unit. Fundamental units are defined as themselves; these are the
27708 units produced by the @kbd{u b} command. The fundamental units are
27709 meters, seconds, grams, kelvins, amperes, candelas, moles, radians,
27710 and steradians.
27711
27712 The Units Table buffer also displays the Unit Prefix Table. Note that
27713 two prefixes, ``kilo'' and ``hecto,'' accept either upper- or lower-case
27714 prefix letters. @samp{Meg} is also accepted as a synonym for the @samp{M}
27715 prefix. Whenever a unit name can be interpreted as either a built-in name
27716 or a prefix followed by another built-in name, the former interpretation
27717 wins. For example, @samp{2 pt} means two pints, not two pico-tons.
27718
27719 The Units Table buffer, once created, is not rebuilt unless you define
27720 new units. To force the buffer to be rebuilt, give any numeric prefix
27721 argument to @kbd{u v}.
27722
27723 @kindex u V
27724 @pindex calc-view-units-table
27725 The @kbd{u V} (@code{calc-view-units-table}) command is like @kbd{u v} except
27726 that the cursor is not moved into the Units Table buffer. You can
27727 type @kbd{u V} again to remove the Units Table from the display. To
27728 return from the Units Table buffer after a @kbd{u v}, type @kbd{M-# c}
27729 again or use the regular Emacs @w{@kbd{C-x o}} (@code{other-window})
27730 command. You can also kill the buffer with @kbd{C-x k} if you wish;
27731 the actual units table is safely stored inside the Calculator.
27732
27733 @kindex u g
27734 @pindex calc-get-unit-definition
27735 The @kbd{u g} (@code{calc-get-unit-definition}) command retrieves a unit's
27736 defining expression and pushes it onto the Calculator stack. For example,
27737 @kbd{u g in} will produce the expression @samp{2.54 cm}. This is the
27738 same definition for the unit that would appear in the Units Table buffer.
27739 Note that this command works only for actual unit names; @kbd{u g km}
27740 will report that no such unit exists, for example, because @code{km} is
27741 really the unit @code{m} with a @code{k} (``kilo'') prefix. To see a
27742 definition of a unit in terms of base units, it is easier to push the
27743 unit name on the stack and then reduce it to base units with @kbd{u b}.
27744
27745 @kindex u e
27746 @pindex calc-explain-units
27747 The @kbd{u e} (@code{calc-explain-units}) command displays an English
27748 description of the units of the expression on the stack. For example,
27749 for the expression @samp{62 km^2 g / s^2 mol K}, the description is
27750 ``Square-Kilometer Gram per (Second-squared Mole Degree-Kelvin).'' This
27751 command uses the English descriptions that appear in the righthand
27752 column of the Units Table.
27753
27754 @node Predefined Units, User-Defined Units, The Units Table, Units
27755 @section Predefined Units
27756
27757 @noindent
27758 Since the exact definitions of many kinds of units have evolved over the
27759 years, and since certain countries sometimes have local differences in
27760 their definitions, it is a good idea to examine Calc's definition of a
27761 unit before depending on its exact value. For example, there are three
27762 different units for gallons, corresponding to the US (@code{gal}),
27763 Canadian (@code{galC}), and British (@code{galUK}) definitions. Also,
27764 note that @code{oz} is a standard ounce of mass, @code{ozt} is a Troy
27765 ounce, and @code{ozfl} is a fluid ounce.
27766
27767 The temperature units corresponding to degrees Kelvin and Centigrade
27768 (Celsius) are the same in this table, since most units commands treat
27769 temperatures as being relative. The @code{calc-convert-temperature}
27770 command has special rules for handling the different absolute magnitudes
27771 of the various temperature scales.
27772
27773 The unit of volume ``liters'' can be referred to by either the lower-case
27774 @code{l} or the upper-case @code{L}.
27775
27776 The unit @code{A} stands for Amperes; the name @code{Ang} is used
27777 @tex
27778 for \AA ngstroms.
27779 @end tex
27780 @ifinfo
27781 for Angstroms.
27782 @end ifinfo
27783
27784 The unit @code{pt} stands for pints; the name @code{point} stands for
27785 a typographical point, defined by @samp{72 point = 1 in}. There is
27786 also @code{tpt}, which stands for a printer's point as defined by the
27787 @TeX{} typesetting system: @samp{72.27 tpt = 1 in}.
27788
27789 The unit @code{e} stands for the elementary (electron) unit of charge;
27790 because algebra command could mistake this for the special constant
27791 @expr{e}, Calc provides the alternate unit name @code{ech} which is
27792 preferable to @code{e}.
27793
27794 The name @code{g} stands for one gram of mass; there is also @code{gf},
27795 one gram of force. (Likewise for @kbd{lb}, pounds, and @kbd{lbf}.)
27796 Meanwhile, one ``@expr{g}'' of acceleration is denoted @code{ga}.
27797
27798 The unit @code{ton} is a U.S. ton of @samp{2000 lb}, and @code{t} is
27799 a metric ton of @samp{1000 kg}.
27800
27801 The names @code{s} (or @code{sec}) and @code{min} refer to units of
27802 time; @code{arcsec} and @code{arcmin} are units of angle.
27803
27804 Some ``units'' are really physical constants; for example, @code{c}
27805 represents the speed of light, and @code{h} represents Planck's
27806 constant. You can use these just like other units: converting
27807 @samp{.5 c} to @samp{m/s} expresses one-half the speed of light in
27808 meters per second. You can also use this merely as a handy reference;
27809 the @kbd{u g} command gets the definition of one of these constants
27810 in its normal terms, and @kbd{u b} expresses the definition in base
27811 units.
27812
27813 Two units, @code{pi} and @code{fsc} (the fine structure constant,
27814 approximately @mathit{1/137}) are dimensionless. The units simplification
27815 commands simply treat these names as equivalent to their corresponding
27816 values. However you can, for example, use @kbd{u c} to convert a pure
27817 number into multiples of the fine structure constant, or @kbd{u b} to
27818 convert this back into a pure number. (When @kbd{u c} prompts for the
27819 ``old units,'' just enter a blank line to signify that the value
27820 really is unitless.)
27821
27822 @c Describe angular units, luminosity vs. steradians problem.
27823
27824 @node User-Defined Units, , Predefined Units, Units
27825 @section User-Defined Units
27826
27827 @noindent
27828 Calc provides ways to get quick access to your selected ``favorite''
27829 units, as well as ways to define your own new units.
27830
27831 @kindex u 0-9
27832 @pindex calc-quick-units
27833 @vindex Units
27834 @cindex @code{Units} variable
27835 @cindex Quick units
27836 To select your favorite units, store a vector of unit names or
27837 expressions in the Calc variable @code{Units}. The @kbd{u 1}
27838 through @kbd{u 9} commands (@code{calc-quick-units}) provide access
27839 to these units. If the value on the top of the stack is a plain
27840 number (with no units attached), then @kbd{u 1} gives it the
27841 specified units. (Basically, it multiplies the number by the
27842 first item in the @code{Units} vector.) If the number on the
27843 stack @emph{does} have units, then @kbd{u 1} converts that number
27844 to the new units. For example, suppose the vector @samp{[in, ft]}
27845 is stored in @code{Units}. Then @kbd{30 u 1} will create the
27846 expression @samp{30 in}, and @kbd{u 2} will convert that expression
27847 to @samp{2.5 ft}.
27848
27849 The @kbd{u 0} command accesses the tenth element of @code{Units}.
27850 Only ten quick units may be defined at a time. If the @code{Units}
27851 variable has no stored value (the default), or if its value is not
27852 a vector, then the quick-units commands will not function. The
27853 @kbd{s U} command is a convenient way to edit the @code{Units}
27854 variable; @pxref{Operations on Variables}.
27855
27856 @kindex u d
27857 @pindex calc-define-unit
27858 @cindex User-defined units
27859 The @kbd{u d} (@code{calc-define-unit}) command records the units
27860 expression on the top of the stack as the definition for a new,
27861 user-defined unit. For example, putting @samp{16.5 ft} on the stack and
27862 typing @kbd{u d rod} defines the new unit @samp{rod} to be equivalent to
27863 16.5 feet. The unit conversion and simplification commands will now
27864 treat @code{rod} just like any other unit of length. You will also be
27865 prompted for an optional English description of the unit, which will
27866 appear in the Units Table.
27867
27868 @kindex u u
27869 @pindex calc-undefine-unit
27870 The @kbd{u u} (@code{calc-undefine-unit}) command removes a user-defined
27871 unit. It is not possible to remove one of the predefined units,
27872 however.
27873
27874 If you define a unit with an existing unit name, your new definition
27875 will replace the original definition of that unit. If the unit was a
27876 predefined unit, the old definition will not be replaced, only
27877 ``shadowed.'' The built-in definition will reappear if you later use
27878 @kbd{u u} to remove the shadowing definition.
27879
27880 To create a new fundamental unit, use either 1 or the unit name itself
27881 as the defining expression. Otherwise the expression can involve any
27882 other units that you like (except for composite units like @samp{mfi}).
27883 You can create a new composite unit with a sum of other units as the
27884 defining expression. The next unit operation like @kbd{u c} or @kbd{u v}
27885 will rebuild the internal unit table incorporating your modifications.
27886 Note that erroneous definitions (such as two units defined in terms of
27887 each other) will not be detected until the unit table is next rebuilt;
27888 @kbd{u v} is a convenient way to force this to happen.
27889
27890 Temperature units are treated specially inside the Calculator; it is not
27891 possible to create user-defined temperature units.
27892
27893 @kindex u p
27894 @pindex calc-permanent-units
27895 @cindex Calc init file, user-defined units
27896 The @kbd{u p} (@code{calc-permanent-units}) command stores the user-defined
27897 units in your Calc init file (the file given by the variable
27898 @code{calc-settings-file}, typically @file{~/.calc.el}), so that the
27899 units will still be available in subsequent Emacs sessions. If there
27900 was already a set of user-defined units in your Calc init file, it
27901 is replaced by the new set. (@xref{General Mode Commands}, for a way to
27902 tell Calc to use a different file for the Calc init file.)
27903
27904 @node Store and Recall, Graphics, Units, Top
27905 @chapter Storing and Recalling
27906
27907 @noindent
27908 Calculator variables are really just Lisp variables that contain numbers
27909 or formulas in a form that Calc can understand. The commands in this
27910 section allow you to manipulate variables conveniently. Commands related
27911 to variables use the @kbd{s} prefix key.
27912
27913 @menu
27914 * Storing Variables::
27915 * Recalling Variables::
27916 * Operations on Variables::
27917 * Let Command::
27918 * Evaluates-To Operator::
27919 @end menu
27920
27921 @node Storing Variables, Recalling Variables, Store and Recall, Store and Recall
27922 @section Storing Variables
27923
27924 @noindent
27925 @kindex s s
27926 @pindex calc-store
27927 @cindex Storing variables
27928 @cindex Quick variables
27929 @vindex q0
27930 @vindex q9
27931 The @kbd{s s} (@code{calc-store}) command stores the value at the top of
27932 the stack into a specified variable. It prompts you to enter the
27933 name of the variable. If you press a single digit, the value is stored
27934 immediately in one of the ``quick'' variables @code{q0} through
27935 @code{q9}. Or you can enter any variable name.
27936
27937 @kindex s t
27938 @pindex calc-store-into
27939 The @kbd{s s} command leaves the stored value on the stack. There is
27940 also an @kbd{s t} (@code{calc-store-into}) command, which removes a
27941 value from the stack and stores it in a variable.
27942
27943 If the top of stack value is an equation @samp{a = 7} or assignment
27944 @samp{a := 7} with a variable on the lefthand side, then Calc will
27945 assign that variable with that value by default, i.e., if you type
27946 @kbd{s s @key{RET}} or @kbd{s t @key{RET}}. In this example, the
27947 value 7 would be stored in the variable @samp{a}. (If you do type
27948 a variable name at the prompt, the top-of-stack value is stored in
27949 its entirety, even if it is an equation: @samp{s s b @key{RET}}
27950 with @samp{a := 7} on the stack stores @samp{a := 7} in @code{b}.)
27951
27952 In fact, the top of stack value can be a vector of equations or
27953 assignments with different variables on their lefthand sides; the
27954 default will be to store all the variables with their corresponding
27955 righthand sides simultaneously.
27956
27957 It is also possible to type an equation or assignment directly at
27958 the prompt for the @kbd{s s} or @kbd{s t} command: @kbd{s s foo = 7}.
27959 In this case the expression to the right of the @kbd{=} or @kbd{:=}
27960 symbol is evaluated as if by the @kbd{=} command, and that value is
27961 stored in the variable. No value is taken from the stack; @kbd{s s}
27962 and @kbd{s t} are equivalent when used in this way.
27963
27964 @kindex s 0-9
27965 @kindex t 0-9
27966 The prefix keys @kbd{s} and @kbd{t} may be followed immediately by a
27967 digit; @kbd{s 9} is equivalent to @kbd{s s 9}, and @kbd{t 9} is
27968 equivalent to @kbd{s t 9}. (The @kbd{t} prefix is otherwise used
27969 for trail and time/date commands.)
27970
27971 @kindex s +
27972 @kindex s -
27973 @ignore
27974 @mindex @idots
27975 @end ignore
27976 @kindex s *
27977 @ignore
27978 @mindex @null
27979 @end ignore
27980 @kindex s /
27981 @ignore
27982 @mindex @null
27983 @end ignore
27984 @kindex s ^
27985 @ignore
27986 @mindex @null
27987 @end ignore
27988 @kindex s |
27989 @ignore
27990 @mindex @null
27991 @end ignore
27992 @kindex s n
27993 @ignore
27994 @mindex @null
27995 @end ignore
27996 @kindex s &
27997 @ignore
27998 @mindex @null
27999 @end ignore
28000 @kindex s [
28001 @ignore
28002 @mindex @null
28003 @end ignore
28004 @kindex s ]
28005 @pindex calc-store-plus
28006 @pindex calc-store-minus
28007 @pindex calc-store-times
28008 @pindex calc-store-div
28009 @pindex calc-store-power
28010 @pindex calc-store-concat
28011 @pindex calc-store-neg
28012 @pindex calc-store-inv
28013 @pindex calc-store-decr
28014 @pindex calc-store-incr
28015 There are also several ``arithmetic store'' commands. For example,
28016 @kbd{s +} removes a value from the stack and adds it to the specified
28017 variable. The other arithmetic stores are @kbd{s -}, @kbd{s *}, @kbd{s /},
28018 @kbd{s ^}, and @w{@kbd{s |}} (vector concatenation), plus @kbd{s n} and
28019 @kbd{s &} which negate or invert the value in a variable, and @w{@kbd{s [}}
28020 and @kbd{s ]} which decrease or increase a variable by one.
28021
28022 All the arithmetic stores accept the Inverse prefix to reverse the
28023 order of the operands. If @expr{v} represents the contents of the
28024 variable, and @expr{a} is the value drawn from the stack, then regular
28025 @w{@kbd{s -}} assigns
28026 @texline @math{v \coloneq v - a},
28027 @infoline @expr{v := v - a},
28028 but @kbd{I s -} assigns
28029 @texline @math{v \coloneq a - v}.
28030 @infoline @expr{v := a - v}.
28031 While @kbd{I s *} might seem pointless, it is
28032 useful if matrix multiplication is involved. Actually, all the
28033 arithmetic stores use formulas designed to behave usefully both
28034 forwards and backwards:
28035
28036 @example
28037 @group
28038 s + v := v + a v := a + v
28039 s - v := v - a v := a - v
28040 s * v := v * a v := a * v
28041 s / v := v / a v := a / v
28042 s ^ v := v ^ a v := a ^ v
28043 s | v := v | a v := a | v
28044 s n v := v / (-1) v := (-1) / v
28045 s & v := v ^ (-1) v := (-1) ^ v
28046 s [ v := v - 1 v := 1 - v
28047 s ] v := v - (-1) v := (-1) - v
28048 @end group
28049 @end example
28050
28051 In the last four cases, a numeric prefix argument will be used in
28052 place of the number one. (For example, @kbd{M-2 s ]} increases
28053 a variable by 2, and @kbd{M-2 I s ]} replaces a variable by
28054 minus-two minus the variable.
28055
28056 The first six arithmetic stores can also be typed @kbd{s t +}, @kbd{s t -},
28057 etc. The commands @kbd{s s +}, @kbd{s s -}, and so on are analogous
28058 arithmetic stores that don't remove the value @expr{a} from the stack.
28059
28060 All arithmetic stores report the new value of the variable in the
28061 Trail for your information. They signal an error if the variable
28062 previously had no stored value. If default simplifications have been
28063 turned off, the arithmetic stores temporarily turn them on for numeric
28064 arguments only (i.e., they temporarily do an @kbd{m N} command).
28065 @xref{Simplification Modes}. Large vectors put in the trail by
28066 these commands always use abbreviated (@kbd{t .}) mode.
28067
28068 @kindex s m
28069 @pindex calc-store-map
28070 The @kbd{s m} command is a general way to adjust a variable's value
28071 using any Calc function. It is a ``mapping'' command analogous to
28072 @kbd{V M}, @kbd{V R}, etc. @xref{Reducing and Mapping}, to see
28073 how to specify a function for a mapping command. Basically,
28074 all you do is type the Calc command key that would invoke that
28075 function normally. For example, @kbd{s m n} applies the @kbd{n}
28076 key to negate the contents of the variable, so @kbd{s m n} is
28077 equivalent to @kbd{s n}. Also, @kbd{s m Q} takes the square root
28078 of the value stored in a variable, @kbd{s m v v} uses @kbd{v v} to
28079 reverse the vector stored in the variable, and @kbd{s m H I S}
28080 takes the hyperbolic arcsine of the variable contents.
28081
28082 If the mapping function takes two or more arguments, the additional
28083 arguments are taken from the stack; the old value of the variable
28084 is provided as the first argument. Thus @kbd{s m -} with @expr{a}
28085 on the stack computes @expr{v - a}, just like @kbd{s -}. With the
28086 Inverse prefix, the variable's original value becomes the @emph{last}
28087 argument instead of the first. Thus @kbd{I s m -} is also
28088 equivalent to @kbd{I s -}.
28089
28090 @kindex s x
28091 @pindex calc-store-exchange
28092 The @kbd{s x} (@code{calc-store-exchange}) command exchanges the value
28093 of a variable with the value on the top of the stack. Naturally, the
28094 variable must already have a stored value for this to work.
28095
28096 You can type an equation or assignment at the @kbd{s x} prompt. The
28097 command @kbd{s x a=6} takes no values from the stack; instead, it
28098 pushes the old value of @samp{a} on the stack and stores @samp{a = 6}.
28099
28100 @kindex s u
28101 @pindex calc-unstore
28102 @cindex Void variables
28103 @cindex Un-storing variables
28104 Until you store something in them, variables are ``void,'' that is, they
28105 contain no value at all. If they appear in an algebraic formula they
28106 will be left alone even if you press @kbd{=} (@code{calc-evaluate}).
28107 The @kbd{s u} (@code{calc-unstore}) command returns a variable to the
28108 void state.
28109
28110 The only variables with predefined values are the ``special constants''
28111 @code{pi}, @code{e}, @code{i}, @code{phi}, and @code{gamma}. You are free
28112 to unstore these variables or to store new values into them if you like,
28113 although some of the algebraic-manipulation functions may assume these
28114 variables represent their standard values. Calc displays a warning if
28115 you change the value of one of these variables, or of one of the other
28116 special variables @code{inf}, @code{uinf}, and @code{nan} (which are
28117 normally void).
28118
28119 Note that @code{pi} doesn't actually have 3.14159265359 stored
28120 in it, but rather a special magic value that evaluates to @cpi{}
28121 at the current precision. Likewise @code{e}, @code{i}, and
28122 @code{phi} evaluate according to the current precision or polar mode.
28123 If you recall a value from @code{pi} and store it back, this magic
28124 property will be lost.
28125
28126 @kindex s c
28127 @pindex calc-copy-variable
28128 The @kbd{s c} (@code{calc-copy-variable}) command copies the stored
28129 value of one variable to another. It differs from a simple @kbd{s r}
28130 followed by an @kbd{s t} in two important ways. First, the value never
28131 goes on the stack and thus is never rounded, evaluated, or simplified
28132 in any way; it is not even rounded down to the current precision.
28133 Second, the ``magic'' contents of a variable like @code{e} can
28134 be copied into another variable with this command, perhaps because
28135 you need to unstore @code{e} right now but you wish to put it
28136 back when you're done. The @kbd{s c} command is the only way to
28137 manipulate these magic values intact.
28138
28139 @node Recalling Variables, Operations on Variables, Storing Variables, Store and Recall
28140 @section Recalling Variables
28141
28142 @noindent
28143 @kindex s r
28144 @pindex calc-recall
28145 @cindex Recalling variables
28146 The most straightforward way to extract the stored value from a variable
28147 is to use the @kbd{s r} (@code{calc-recall}) command. This command prompts
28148 for a variable name (similarly to @code{calc-store}), looks up the value
28149 of the specified variable, and pushes that value onto the stack. It is
28150 an error to try to recall a void variable.
28151
28152 It is also possible to recall the value from a variable by evaluating a
28153 formula containing that variable. For example, @kbd{' a @key{RET} =} is
28154 the same as @kbd{s r a @key{RET}} except that if the variable is void, the
28155 former will simply leave the formula @samp{a} on the stack whereas the
28156 latter will produce an error message.
28157
28158 @kindex r 0-9
28159 The @kbd{r} prefix may be followed by a digit, so that @kbd{r 9} is
28160 equivalent to @kbd{s r 9}. (The @kbd{r} prefix is otherwise unused
28161 in the current version of Calc.)
28162
28163 @node Operations on Variables, Let Command, Recalling Variables, Store and Recall
28164 @section Other Operations on Variables
28165
28166 @noindent
28167 @kindex s e
28168 @pindex calc-edit-variable
28169 The @kbd{s e} (@code{calc-edit-variable}) command edits the stored
28170 value of a variable without ever putting that value on the stack
28171 or simplifying or evaluating the value. It prompts for the name of
28172 the variable to edit. If the variable has no stored value, the
28173 editing buffer will start out empty. If the editing buffer is
28174 empty when you press @kbd{C-c C-c} to finish, the variable will
28175 be made void. @xref{Editing Stack Entries}, for a general
28176 description of editing.
28177
28178 The @kbd{s e} command is especially useful for creating and editing
28179 rewrite rules which are stored in variables. Sometimes these rules
28180 contain formulas which must not be evaluated until the rules are
28181 actually used. (For example, they may refer to @samp{deriv(x,y)},
28182 where @code{x} will someday become some expression involving @code{y};
28183 if you let Calc evaluate the rule while you are defining it, Calc will
28184 replace @samp{deriv(x,y)} with 0 because the formula @code{x} does
28185 not itself refer to @code{y}.) By contrast, recalling the variable,
28186 editing with @kbd{`}, and storing will evaluate the variable's value
28187 as a side effect of putting the value on the stack.
28188
28189 @kindex s A
28190 @kindex s D
28191 @ignore
28192 @mindex @idots
28193 @end ignore
28194 @kindex s E
28195 @ignore
28196 @mindex @null
28197 @end ignore
28198 @kindex s F
28199 @ignore
28200 @mindex @null
28201 @end ignore
28202 @kindex s G
28203 @ignore
28204 @mindex @null
28205 @end ignore
28206 @kindex s H
28207 @ignore
28208 @mindex @null
28209 @end ignore
28210 @kindex s I
28211 @ignore
28212 @mindex @null
28213 @end ignore
28214 @kindex s L
28215 @ignore
28216 @mindex @null
28217 @end ignore
28218 @kindex s P
28219 @ignore
28220 @mindex @null
28221 @end ignore
28222 @kindex s R
28223 @ignore
28224 @mindex @null
28225 @end ignore
28226 @kindex s T
28227 @ignore
28228 @mindex @null
28229 @end ignore
28230 @kindex s U
28231 @ignore
28232 @mindex @null
28233 @end ignore
28234 @kindex s X
28235 @pindex calc-store-AlgSimpRules
28236 @pindex calc-store-Decls
28237 @pindex calc-store-EvalRules
28238 @pindex calc-store-FitRules
28239 @pindex calc-store-GenCount
28240 @pindex calc-store-Holidays
28241 @pindex calc-store-IntegLimit
28242 @pindex calc-store-LineStyles
28243 @pindex calc-store-PointStyles
28244 @pindex calc-store-PlotRejects
28245 @pindex calc-store-TimeZone
28246 @pindex calc-store-Units
28247 @pindex calc-store-ExtSimpRules
28248 There are several special-purpose variable-editing commands that
28249 use the @kbd{s} prefix followed by a shifted letter:
28250
28251 @table @kbd
28252 @item s A
28253 Edit @code{AlgSimpRules}. @xref{Algebraic Simplifications}.
28254 @item s D
28255 Edit @code{Decls}. @xref{Declarations}.
28256 @item s E
28257 Edit @code{EvalRules}. @xref{Default Simplifications}.
28258 @item s F
28259 Edit @code{FitRules}. @xref{Curve Fitting}.
28260 @item s G
28261 Edit @code{GenCount}. @xref{Solving Equations}.
28262 @item s H
28263 Edit @code{Holidays}. @xref{Business Days}.
28264 @item s I
28265 Edit @code{IntegLimit}. @xref{Calculus}.
28266 @item s L
28267 Edit @code{LineStyles}. @xref{Graphics}.
28268 @item s P
28269 Edit @code{PointStyles}. @xref{Graphics}.
28270 @item s R
28271 Edit @code{PlotRejects}. @xref{Graphics}.
28272 @item s T
28273 Edit @code{TimeZone}. @xref{Time Zones}.
28274 @item s U
28275 Edit @code{Units}. @xref{User-Defined Units}.
28276 @item s X
28277 Edit @code{ExtSimpRules}. @xref{Unsafe Simplifications}.
28278 @end table
28279
28280 These commands are just versions of @kbd{s e} that use fixed variable
28281 names rather than prompting for the variable name.
28282
28283 @kindex s p
28284 @pindex calc-permanent-variable
28285 @cindex Storing variables
28286 @cindex Permanent variables
28287 @cindex Calc init file, variables
28288 The @kbd{s p} (@code{calc-permanent-variable}) command saves a
28289 variable's value permanently in your Calc init file (the file given by
28290 the variable @code{calc-settings-file}, typically @file{~/.calc.el}), so
28291 that its value will still be available in future Emacs sessions. You
28292 can re-execute @w{@kbd{s p}} later on to update the saved value, but the
28293 only way to remove a saved variable is to edit your calc init file
28294 by hand. (@xref{General Mode Commands}, for a way to tell Calc to
28295 use a different file for the Calc init file.)
28296
28297 If you do not specify the name of a variable to save (i.e.,
28298 @kbd{s p @key{RET}}), all Calc variables with defined values
28299 are saved except for the special constants @code{pi}, @code{e},
28300 @code{i}, @code{phi}, and @code{gamma}; the variables @code{TimeZone}
28301 and @code{PlotRejects};
28302 @code{FitRules}, @code{DistribRules}, and other built-in rewrite
28303 rules; and @code{PlotData@var{n}} variables generated
28304 by the graphics commands. (You can still save these variables by
28305 explicitly naming them in an @kbd{s p} command.)
28306
28307 @kindex s i
28308 @pindex calc-insert-variables
28309 The @kbd{s i} (@code{calc-insert-variables}) command writes
28310 the values of all Calc variables into a specified buffer.
28311 The variables are written with the prefix @code{var-} in the form of
28312 Lisp @code{setq} commands
28313 which store the values in string form. You can place these commands
28314 in your Calc init file (or @file{.emacs}) if you wish, though in this case it
28315 would be easier to use @kbd{s p @key{RET}}. (Note that @kbd{s i}
28316 omits the same set of variables as @w{@kbd{s p @key{RET}}}; the difference
28317 is that @kbd{s i} will store the variables in any buffer, and it also
28318 stores in a more human-readable format.)
28319
28320 @node Let Command, Evaluates-To Operator, Operations on Variables, Store and Recall
28321 @section The Let Command
28322
28323 @noindent
28324 @kindex s l
28325 @pindex calc-let
28326 @cindex Variables, temporary assignment
28327 @cindex Temporary assignment to variables
28328 If you have an expression like @samp{a+b^2} on the stack and you wish to
28329 compute its value where @expr{b=3}, you can simply store 3 in @expr{b} and
28330 then press @kbd{=} to reevaluate the formula. This has the side-effect
28331 of leaving the stored value of 3 in @expr{b} for future operations.
28332
28333 The @kbd{s l} (@code{calc-let}) command evaluates a formula under a
28334 @emph{temporary} assignment of a variable. It stores the value on the
28335 top of the stack into the specified variable, then evaluates the
28336 second-to-top stack entry, then restores the original value (or lack of one)
28337 in the variable. Thus after @kbd{'@w{ }a+b^2 @key{RET} 3 s l b @key{RET}},
28338 the stack will contain the formula @samp{a + 9}. The subsequent command
28339 @kbd{@w{5 s l a} @key{RET}} will replace this formula with the number 14.
28340 The variables @samp{a} and @samp{b} are not permanently affected in any way
28341 by these commands.
28342
28343 The value on the top of the stack may be an equation or assignment, or
28344 a vector of equations or assignments, in which case the default will be
28345 analogous to the case of @kbd{s t @key{RET}}. @xref{Storing Variables}.
28346
28347 Also, you can answer the variable-name prompt with an equation or
28348 assignment: @kbd{s l b=3 @key{RET}} is the same as storing 3 on the stack
28349 and typing @kbd{s l b @key{RET}}.
28350
28351 The @kbd{a b} (@code{calc-substitute}) command is another way to substitute
28352 a variable with a value in a formula. It does an actual substitution
28353 rather than temporarily assigning the variable and evaluating. For
28354 example, letting @expr{n=2} in @samp{f(n pi)} with @kbd{a b} will
28355 produce @samp{f(2 pi)}, whereas @kbd{s l} would give @samp{f(6.28)}
28356 since the evaluation step will also evaluate @code{pi}.
28357
28358 @node Evaluates-To Operator, , Let Command, Store and Recall
28359 @section The Evaluates-To Operator
28360
28361 @noindent
28362 @tindex evalto
28363 @tindex =>
28364 @cindex Evaluates-to operator
28365 @cindex @samp{=>} operator
28366 The special algebraic symbol @samp{=>} is known as the @dfn{evaluates-to
28367 operator}. (It will show up as an @code{evalto} function call in
28368 other language modes like Pascal and La@TeX{}.) This is a binary
28369 operator, that is, it has a lefthand and a righthand argument,
28370 although it can be entered with the righthand argument omitted.
28371
28372 A formula like @samp{@var{a} => @var{b}} is evaluated by Calc as
28373 follows: First, @var{a} is not simplified or modified in any
28374 way. The previous value of argument @var{b} is thrown away; the
28375 formula @var{a} is then copied and evaluated as if by the @kbd{=}
28376 command according to all current modes and stored variable values,
28377 and the result is installed as the new value of @var{b}.
28378
28379 For example, suppose you enter the algebraic formula @samp{2 + 3 => 17}.
28380 The number 17 is ignored, and the lefthand argument is left in its
28381 unevaluated form; the result is the formula @samp{2 + 3 => 5}.
28382
28383 @kindex s =
28384 @pindex calc-evalto
28385 You can enter an @samp{=>} formula either directly using algebraic
28386 entry (in which case the righthand side may be omitted since it is
28387 going to be replaced right away anyhow), or by using the @kbd{s =}
28388 (@code{calc-evalto}) command, which takes @var{a} from the stack
28389 and replaces it with @samp{@var{a} => @var{b}}.
28390
28391 Calc keeps track of all @samp{=>} operators on the stack, and
28392 recomputes them whenever anything changes that might affect their
28393 values, i.e., a mode setting or variable value. This occurs only
28394 if the @samp{=>} operator is at the top level of the formula, or
28395 if it is part of a top-level vector. In other words, pushing
28396 @samp{2 + (a => 17)} will change the 17 to the actual value of
28397 @samp{a} when you enter the formula, but the result will not be
28398 dynamically updated when @samp{a} is changed later because the
28399 @samp{=>} operator is buried inside a sum. However, a vector
28400 of @samp{=>} operators will be recomputed, since it is convenient
28401 to push a vector like @samp{[a =>, b =>, c =>]} on the stack to
28402 make a concise display of all the variables in your problem.
28403 (Another way to do this would be to use @samp{[a, b, c] =>},
28404 which provides a slightly different format of display. You
28405 can use whichever you find easiest to read.)
28406
28407 @kindex m C
28408 @pindex calc-auto-recompute
28409 The @kbd{m C} (@code{calc-auto-recompute}) command allows you to
28410 turn this automatic recomputation on or off. If you turn
28411 recomputation off, you must explicitly recompute an @samp{=>}
28412 operator on the stack in one of the usual ways, such as by
28413 pressing @kbd{=}. Turning recomputation off temporarily can save
28414 a lot of time if you will be changing several modes or variables
28415 before you look at the @samp{=>} entries again.
28416
28417 Most commands are not especially useful with @samp{=>} operators
28418 as arguments. For example, given @samp{x + 2 => 17}, it won't
28419 work to type @kbd{1 +} to get @samp{x + 3 => 18}. If you want
28420 to operate on the lefthand side of the @samp{=>} operator on
28421 the top of the stack, type @kbd{j 1} (that's the digit ``one'')
28422 to select the lefthand side, execute your commands, then type
28423 @kbd{j u} to unselect.
28424
28425 All current modes apply when an @samp{=>} operator is computed,
28426 including the current simplification mode. Recall that the
28427 formula @samp{x + y + x} is not handled by Calc's default
28428 simplifications, but the @kbd{a s} command will reduce it to
28429 the simpler form @samp{y + 2 x}. You can also type @kbd{m A}
28430 to enable an Algebraic Simplification mode in which the
28431 equivalent of @kbd{a s} is used on all of Calc's results.
28432 If you enter @samp{x + y + x =>} normally, the result will
28433 be @samp{x + y + x => x + y + x}. If you change to
28434 Algebraic Simplification mode, the result will be
28435 @samp{x + y + x => y + 2 x}. However, just pressing @kbd{a s}
28436 once will have no effect on @samp{x + y + x => x + y + x},
28437 because the righthand side depends only on the lefthand side
28438 and the current mode settings, and the lefthand side is not
28439 affected by commands like @kbd{a s}.
28440
28441 The ``let'' command (@kbd{s l}) has an interesting interaction
28442 with the @samp{=>} operator. The @kbd{s l} command evaluates the
28443 second-to-top stack entry with the top stack entry supplying
28444 a temporary value for a given variable. As you might expect,
28445 if that stack entry is an @samp{=>} operator its righthand
28446 side will temporarily show this value for the variable. In
28447 fact, all @samp{=>}s on the stack will be updated if they refer
28448 to that variable. But this change is temporary in the sense
28449 that the next command that causes Calc to look at those stack
28450 entries will make them revert to the old variable value.
28451
28452 @smallexample
28453 @group
28454 2: a => a 2: a => 17 2: a => a
28455 1: a + 1 => a + 1 1: a + 1 => 18 1: a + 1 => a + 1
28456 . . .
28457
28458 17 s l a @key{RET} p 8 @key{RET}
28459 @end group
28460 @end smallexample
28461
28462 Here the @kbd{p 8} command changes the current precision,
28463 thus causing the @samp{=>} forms to be recomputed after the
28464 influence of the ``let'' is gone. The @kbd{d @key{SPC}} command
28465 (@code{calc-refresh}) is a handy way to force the @samp{=>}
28466 operators on the stack to be recomputed without any other
28467 side effects.
28468
28469 @kindex s :
28470 @pindex calc-assign
28471 @tindex assign
28472 @tindex :=
28473 Embedded mode also uses @samp{=>} operators. In Embedded mode,
28474 the lefthand side of an @samp{=>} operator can refer to variables
28475 assigned elsewhere in the file by @samp{:=} operators. The
28476 assignment operator @samp{a := 17} does not actually do anything
28477 by itself. But Embedded mode recognizes it and marks it as a sort
28478 of file-local definition of the variable. You can enter @samp{:=}
28479 operators in Algebraic mode, or by using the @kbd{s :}
28480 (@code{calc-assign}) [@code{assign}] command which takes a variable
28481 and value from the stack and replaces them with an assignment.
28482
28483 @xref{TeX and LaTeX Language Modes}, for the way @samp{=>} appears in
28484 @TeX{} language output. The @dfn{eqn} mode gives similar
28485 treatment to @samp{=>}.
28486
28487 @node Graphics, Kill and Yank, Store and Recall, Top
28488 @chapter Graphics
28489
28490 @noindent
28491 The commands for graphing data begin with the @kbd{g} prefix key. Calc
28492 uses GNUPLOT 2.0 or 3.0 to do graphics. These commands will only work
28493 if GNUPLOT is available on your system. (While GNUPLOT sounds like
28494 a relative of GNU Emacs, it is actually completely unrelated.
28495 However, it is free software and can be obtained from the Free
28496 Software Foundation's machine @samp{prep.ai.mit.edu}.)
28497
28498 @vindex calc-gnuplot-name
28499 If you have GNUPLOT installed on your system but Calc is unable to
28500 find it, you may need to set the @code{calc-gnuplot-name} variable
28501 in your Calc init file or @file{.emacs}. You may also need to set some Lisp
28502 variables to show Calc how to run GNUPLOT on your system; these
28503 are described under @kbd{g D} and @kbd{g O} below. If you are
28504 using the X window system, Calc will configure GNUPLOT for you
28505 automatically. If you have GNUPLOT 3.0 and you are not using X,
28506 Calc will configure GNUPLOT to display graphs using simple character
28507 graphics that will work on any terminal.
28508
28509 @menu
28510 * Basic Graphics::
28511 * Three Dimensional Graphics::
28512 * Managing Curves::
28513 * Graphics Options::
28514 * Devices::
28515 @end menu
28516
28517 @node Basic Graphics, Three Dimensional Graphics, Graphics, Graphics
28518 @section Basic Graphics
28519
28520 @noindent
28521 @kindex g f
28522 @pindex calc-graph-fast
28523 The easiest graphics command is @kbd{g f} (@code{calc-graph-fast}).
28524 This command takes two vectors of equal length from the stack.
28525 The vector at the top of the stack represents the ``y'' values of
28526 the various data points. The vector in the second-to-top position
28527 represents the corresponding ``x'' values. This command runs
28528 GNUPLOT (if it has not already been started by previous graphing
28529 commands) and displays the set of data points. The points will
28530 be connected by lines, and there will also be some kind of symbol
28531 to indicate the points themselves.
28532
28533 The ``x'' entry may instead be an interval form, in which case suitable
28534 ``x'' values are interpolated between the minimum and maximum values of
28535 the interval (whether the interval is open or closed is ignored).
28536
28537 The ``x'' entry may also be a number, in which case Calc uses the
28538 sequence of ``x'' values @expr{x}, @expr{x+1}, @expr{x+2}, etc.
28539 (Generally the number 0 or 1 would be used for @expr{x} in this case.)
28540
28541 The ``y'' entry may be any formula instead of a vector. Calc effectively
28542 uses @kbd{N} (@code{calc-eval-num}) to evaluate variables in the formula;
28543 the result of this must be a formula in a single (unassigned) variable.
28544 The formula is plotted with this variable taking on the various ``x''
28545 values. Graphs of formulas by default use lines without symbols at the
28546 computed data points. Note that if neither ``x'' nor ``y'' is a vector,
28547 Calc guesses at a reasonable number of data points to use. See the
28548 @kbd{g N} command below. (The ``x'' values must be either a vector
28549 or an interval if ``y'' is a formula.)
28550
28551 @ignore
28552 @starindex
28553 @end ignore
28554 @tindex xy
28555 If ``y'' is (or evaluates to) a formula of the form
28556 @samp{xy(@var{x}, @var{y})} then the result is a
28557 parametric plot. The two arguments of the fictitious @code{xy} function
28558 are used as the ``x'' and ``y'' coordinates of the curve, respectively.
28559 In this case the ``x'' vector or interval you specified is not directly
28560 visible in the graph. For example, if ``x'' is the interval @samp{[0..360]}
28561 and ``y'' is the formula @samp{xy(sin(t), cos(t))}, the resulting graph
28562 will be a circle.
28563
28564 Also, ``x'' and ``y'' may each be variable names, in which case Calc
28565 looks for suitable vectors, intervals, or formulas stored in those
28566 variables.
28567
28568 The ``x'' and ``y'' values for the data points (as pulled from the vectors,
28569 calculated from the formulas, or interpolated from the intervals) should
28570 be real numbers (integers, fractions, or floats). If either the ``x''
28571 value or the ``y'' value of a given data point is not a real number, that
28572 data point will be omitted from the graph. The points on either side
28573 of the invalid point will @emph{not} be connected by a line.
28574
28575 See the documentation for @kbd{g a} below for a description of the way
28576 numeric prefix arguments affect @kbd{g f}.
28577
28578 @cindex @code{PlotRejects} variable
28579 @vindex PlotRejects
28580 If you store an empty vector in the variable @code{PlotRejects}
28581 (i.e., @kbd{[ ] s t PlotRejects}), Calc will append information to
28582 this vector for every data point which was rejected because its
28583 ``x'' or ``y'' values were not real numbers. The result will be
28584 a matrix where each row holds the curve number, data point number,
28585 ``x'' value, and ``y'' value for a rejected data point.
28586 @xref{Evaluates-To Operator}, for a handy way to keep tabs on the
28587 current value of @code{PlotRejects}. @xref{Operations on Variables},
28588 for the @kbd{s R} command which is another easy way to examine
28589 @code{PlotRejects}.
28590
28591 @kindex g c
28592 @pindex calc-graph-clear
28593 To clear the graphics display, type @kbd{g c} (@code{calc-graph-clear}).
28594 If the GNUPLOT output device is an X window, the window will go away.
28595 Effects on other kinds of output devices will vary. You don't need
28596 to use @kbd{g c} if you don't want to---if you give another @kbd{g f}
28597 or @kbd{g p} command later on, it will reuse the existing graphics
28598 window if there is one.
28599
28600 @node Three Dimensional Graphics, Managing Curves, Basic Graphics, Graphics
28601 @section Three-Dimensional Graphics
28602
28603 @kindex g F
28604 @pindex calc-graph-fast-3d
28605 The @kbd{g F} (@code{calc-graph-fast-3d}) command makes a three-dimensional
28606 graph. It works only if you have GNUPLOT 3.0 or later; with GNUPLOT 2.0,
28607 you will see a GNUPLOT error message if you try this command.
28608
28609 The @kbd{g F} command takes three values from the stack, called ``x'',
28610 ``y'', and ``z'', respectively. As was the case for 2D graphs, there
28611 are several options for these values.
28612
28613 In the first case, ``x'' and ``y'' are each vectors (not necessarily of
28614 the same length); either or both may instead be interval forms. The
28615 ``z'' value must be a matrix with the same number of rows as elements
28616 in ``x'', and the same number of columns as elements in ``y''. The
28617 result is a surface plot where
28618 @texline @math{z_{ij}}
28619 @infoline @expr{z_ij}
28620 is the height of the point
28621 at coordinate @expr{(x_i, y_j)} on the surface. The 3D graph will
28622 be displayed from a certain default viewpoint; you can change this
28623 viewpoint by adding a @samp{set view} to the @samp{*Gnuplot Commands*}
28624 buffer as described later. See the GNUPLOT 3.0 documentation for a
28625 description of the @samp{set view} command.
28626
28627 Each point in the matrix will be displayed as a dot in the graph,
28628 and these points will be connected by a grid of lines (@dfn{isolines}).
28629
28630 In the second case, ``x'', ``y'', and ``z'' are all vectors of equal
28631 length. The resulting graph displays a 3D line instead of a surface,
28632 where the coordinates of points along the line are successive triplets
28633 of values from the input vectors.
28634
28635 In the third case, ``x'' and ``y'' are vectors or interval forms, and
28636 ``z'' is any formula involving two variables (not counting variables
28637 with assigned values). These variables are sorted into alphabetical
28638 order; the first takes on values from ``x'' and the second takes on
28639 values from ``y'' to form a matrix of results that are graphed as a
28640 3D surface.
28641
28642 @ignore
28643 @starindex
28644 @end ignore
28645 @tindex xyz
28646 If the ``z'' formula evaluates to a call to the fictitious function
28647 @samp{xyz(@var{x}, @var{y}, @var{z})}, then the result is a
28648 ``parametric surface.'' In this case, the axes of the graph are
28649 taken from the @var{x} and @var{y} values in these calls, and the
28650 ``x'' and ``y'' values from the input vectors or intervals are used only
28651 to specify the range of inputs to the formula. For example, plotting
28652 @samp{[0..360], [0..180], xyz(sin(x)*sin(y), cos(x)*sin(y), cos(y))}
28653 will draw a sphere. (Since the default resolution for 3D plots is
28654 5 steps in each of ``x'' and ``y'', this will draw a very crude
28655 sphere. You could use the @kbd{g N} command, described below, to
28656 increase this resolution, or specify the ``x'' and ``y'' values as
28657 vectors with more than 5 elements.
28658
28659 It is also possible to have a function in a regular @kbd{g f} plot
28660 evaluate to an @code{xyz} call. Since @kbd{g f} plots a line, not
28661 a surface, the result will be a 3D parametric line. For example,
28662 @samp{[[0..720], xyz(sin(x), cos(x), x)]} will plot two turns of a
28663 helix (a three-dimensional spiral).
28664
28665 As for @kbd{g f}, each of ``x'', ``y'', and ``z'' may instead be
28666 variables containing the relevant data.
28667
28668 @node Managing Curves, Graphics Options, Three Dimensional Graphics, Graphics
28669 @section Managing Curves
28670
28671 @noindent
28672 The @kbd{g f} command is really shorthand for the following commands:
28673 @kbd{C-u g d g a g p}. Likewise, @w{@kbd{g F}} is shorthand for
28674 @kbd{C-u g d g A g p}. You can gain more control over your graph
28675 by using these commands directly.
28676
28677 @kindex g a
28678 @pindex calc-graph-add
28679 The @kbd{g a} (@code{calc-graph-add}) command adds the ``curve''
28680 represented by the two values on the top of the stack to the current
28681 graph. You can have any number of curves in the same graph. When
28682 you give the @kbd{g p} command, all the curves will be drawn superimposed
28683 on the same axes.
28684
28685 The @kbd{g a} command (and many others that affect the current graph)
28686 will cause a special buffer, @samp{*Gnuplot Commands*}, to be displayed
28687 in another window. This buffer is a template of the commands that will
28688 be sent to GNUPLOT when it is time to draw the graph. The first
28689 @kbd{g a} command adds a @code{plot} command to this buffer. Succeeding
28690 @kbd{g a} commands add extra curves onto that @code{plot} command.
28691 Other graph-related commands put other GNUPLOT commands into this
28692 buffer. In normal usage you never need to work with this buffer
28693 directly, but you can if you wish. The only constraint is that there
28694 must be only one @code{plot} command, and it must be the last command
28695 in the buffer. If you want to save and later restore a complete graph
28696 configuration, you can use regular Emacs commands to save and restore
28697 the contents of the @samp{*Gnuplot Commands*} buffer.
28698
28699 @vindex PlotData1
28700 @vindex PlotData2
28701 If the values on the stack are not variable names, @kbd{g a} will invent
28702 variable names for them (of the form @samp{PlotData@var{n}}) and store
28703 the values in those variables. The ``x'' and ``y'' variables are what
28704 go into the @code{plot} command in the template. If you add a curve
28705 that uses a certain variable and then later change that variable, you
28706 can replot the graph without having to delete and re-add the curve.
28707 That's because the variable name, not the vector, interval or formula
28708 itself, is what was added by @kbd{g a}.
28709
28710 A numeric prefix argument on @kbd{g a} or @kbd{g f} changes the way
28711 stack entries are interpreted as curves. With a positive prefix
28712 argument @expr{n}, the top @expr{n} stack entries are ``y'' values
28713 for @expr{n} different curves which share a common ``x'' value in
28714 the @expr{n+1}st stack entry. (Thus @kbd{g a} with no prefix
28715 argument is equivalent to @kbd{C-u 1 g a}.)
28716
28717 A prefix of zero or plain @kbd{C-u} means to take two stack entries,
28718 ``x'' and ``y'' as usual, but to interpret ``y'' as a vector of
28719 ``y'' values for several curves that share a common ``x''.
28720
28721 A negative prefix argument tells Calc to read @expr{n} vectors from
28722 the stack; each vector @expr{[x, y]} describes an independent curve.
28723 This is the only form of @kbd{g a} that creates several curves at once
28724 that don't have common ``x'' values. (Of course, the range of ``x''
28725 values covered by all the curves ought to be roughly the same if
28726 they are to look nice on the same graph.)
28727
28728 For example, to plot
28729 @texline @math{\sin n x}
28730 @infoline @expr{sin(n x)}
28731 for integers @expr{n}
28732 from 1 to 5, you could use @kbd{v x} to create a vector of integers
28733 (@expr{n}), then @kbd{V M '} or @kbd{V M $} to map @samp{sin(n x)}
28734 across this vector. The resulting vector of formulas is suitable
28735 for use as the ``y'' argument to a @kbd{C-u g a} or @kbd{C-u g f}
28736 command.
28737
28738 @kindex g A
28739 @pindex calc-graph-add-3d
28740 The @kbd{g A} (@code{calc-graph-add-3d}) command adds a 3D curve
28741 to the graph. It is not valid to intermix 2D and 3D curves in a
28742 single graph. This command takes three arguments, ``x'', ``y'',
28743 and ``z'', from the stack. With a positive prefix @expr{n}, it
28744 takes @expr{n+2} arguments (common ``x'' and ``y'', plus @expr{n}
28745 separate ``z''s). With a zero prefix, it takes three stack entries
28746 but the ``z'' entry is a vector of curve values. With a negative
28747 prefix @expr{-n}, it takes @expr{n} vectors of the form @expr{[x, y, z]}.
28748 The @kbd{g A} command works by adding a @code{splot} (surface-plot)
28749 command to the @samp{*Gnuplot Commands*} buffer.
28750
28751 (Although @kbd{g a} adds a 2D @code{plot} command to the
28752 @samp{*Gnuplot Commands*} buffer, Calc changes this to @code{splot}
28753 before sending it to GNUPLOT if it notices that the data points are
28754 evaluating to @code{xyz} calls. It will not work to mix 2D and 3D
28755 @kbd{g a} curves in a single graph, although Calc does not currently
28756 check for this.)
28757
28758 @kindex g d
28759 @pindex calc-graph-delete
28760 The @kbd{g d} (@code{calc-graph-delete}) command deletes the most
28761 recently added curve from the graph. It has no effect if there are
28762 no curves in the graph. With a numeric prefix argument of any kind,
28763 it deletes all of the curves from the graph.
28764
28765 @kindex g H
28766 @pindex calc-graph-hide
28767 The @kbd{g H} (@code{calc-graph-hide}) command ``hides'' or ``unhides''
28768 the most recently added curve. A hidden curve will not appear in
28769 the actual plot, but information about it such as its name and line and
28770 point styles will be retained.
28771
28772 @kindex g j
28773 @pindex calc-graph-juggle
28774 The @kbd{g j} (@code{calc-graph-juggle}) command moves the curve
28775 at the end of the list (the ``most recently added curve'') to the
28776 front of the list. The next-most-recent curve is thus exposed for
28777 @w{@kbd{g d}} or similar commands to use. With @kbd{g j} you can work
28778 with any curve in the graph even though curve-related commands only
28779 affect the last curve in the list.
28780
28781 @kindex g p
28782 @pindex calc-graph-plot
28783 The @kbd{g p} (@code{calc-graph-plot}) command uses GNUPLOT to draw
28784 the graph described in the @samp{*Gnuplot Commands*} buffer. Any
28785 GNUPLOT parameters which are not defined by commands in this buffer
28786 are reset to their default values. The variables named in the @code{plot}
28787 command are written to a temporary data file and the variable names
28788 are then replaced by the file name in the template. The resulting
28789 plotting commands are fed to the GNUPLOT program. See the documentation
28790 for the GNUPLOT program for more specific information. All temporary
28791 files are removed when Emacs or GNUPLOT exits.
28792
28793 If you give a formula for ``y'', Calc will remember all the values that
28794 it calculates for the formula so that later plots can reuse these values.
28795 Calc throws out these saved values when you change any circumstances
28796 that may affect the data, such as switching from Degrees to Radians
28797 mode, or changing the value of a parameter in the formula. You can
28798 force Calc to recompute the data from scratch by giving a negative
28799 numeric prefix argument to @kbd{g p}.
28800
28801 Calc uses a fairly rough step size when graphing formulas over intervals.
28802 This is to ensure quick response. You can ``refine'' a plot by giving
28803 a positive numeric prefix argument to @kbd{g p}. Calc goes through
28804 the data points it has computed and saved from previous plots of the
28805 function, and computes and inserts a new data point midway between
28806 each of the existing points. You can refine a plot any number of times,
28807 but beware that the amount of calculation involved doubles each time.
28808
28809 Calc does not remember computed values for 3D graphs. This means the
28810 numerix prefix argument, if any, to @kbd{g p} is effectively ignored if
28811 the current graph is three-dimensional.
28812
28813 @kindex g P
28814 @pindex calc-graph-print
28815 The @kbd{g P} (@code{calc-graph-print}) command is like @kbd{g p},
28816 except that it sends the output to a printer instead of to the
28817 screen. More precisely, @kbd{g p} looks for @samp{set terminal}
28818 or @samp{set output} commands in the @samp{*Gnuplot Commands*} buffer;
28819 lacking these it uses the default settings. However, @kbd{g P}
28820 ignores @samp{set terminal} and @samp{set output} commands and
28821 uses a different set of default values. All of these values are
28822 controlled by the @kbd{g D} and @kbd{g O} commands discussed below.
28823 Provided everything is set up properly, @kbd{g p} will plot to
28824 the screen unless you have specified otherwise and @kbd{g P} will
28825 always plot to the printer.
28826
28827 @node Graphics Options, Devices, Managing Curves, Graphics
28828 @section Graphics Options
28829
28830 @noindent
28831 @kindex g g
28832 @pindex calc-graph-grid
28833 The @kbd{g g} (@code{calc-graph-grid}) command turns the ``grid''
28834 on and off. It is off by default; tick marks appear only at the
28835 edges of the graph. With the grid turned on, dotted lines appear
28836 across the graph at each tick mark. Note that this command only
28837 changes the setting in @samp{*Gnuplot Commands*}; to see the effects
28838 of the change you must give another @kbd{g p} command.
28839
28840 @kindex g b
28841 @pindex calc-graph-border
28842 The @kbd{g b} (@code{calc-graph-border}) command turns the border
28843 (the box that surrounds the graph) on and off. It is on by default.
28844 This command will only work with GNUPLOT 3.0 and later versions.
28845
28846 @kindex g k
28847 @pindex calc-graph-key
28848 The @kbd{g k} (@code{calc-graph-key}) command turns the ``key''
28849 on and off. The key is a chart in the corner of the graph that
28850 shows the correspondence between curves and line styles. It is
28851 off by default, and is only really useful if you have several
28852 curves on the same graph.
28853
28854 @kindex g N
28855 @pindex calc-graph-num-points
28856 The @kbd{g N} (@code{calc-graph-num-points}) command allows you
28857 to select the number of data points in the graph. This only affects
28858 curves where neither ``x'' nor ``y'' is specified as a vector.
28859 Enter a blank line to revert to the default value (initially 15).
28860 With no prefix argument, this command affects only the current graph.
28861 With a positive prefix argument this command changes or, if you enter
28862 a blank line, displays the default number of points used for all
28863 graphs created by @kbd{g a} that don't specify the resolution explicitly.
28864 With a negative prefix argument, this command changes or displays
28865 the default value (initially 5) used for 3D graphs created by @kbd{g A}.
28866 Note that a 3D setting of 5 means that a total of @expr{5^2 = 25} points
28867 will be computed for the surface.
28868
28869 Data values in the graph of a function are normally computed to a
28870 precision of five digits, regardless of the current precision at the
28871 time. This is usually more than adequate, but there are cases where
28872 it will not be. For example, plotting @expr{1 + x} with @expr{x} in the
28873 interval @samp{[0 ..@: 1e-6]} will round all the data points down
28874 to 1.0! Putting the command @samp{set precision @var{n}} in the
28875 @samp{*Gnuplot Commands*} buffer will cause the data to be computed
28876 at precision @var{n} instead of 5. Since this is such a rare case,
28877 there is no keystroke-based command to set the precision.
28878
28879 @kindex g h
28880 @pindex calc-graph-header
28881 The @kbd{g h} (@code{calc-graph-header}) command sets the title
28882 for the graph. This will show up centered above the graph.
28883 The default title is blank (no title).
28884
28885 @kindex g n
28886 @pindex calc-graph-name
28887 The @kbd{g n} (@code{calc-graph-name}) command sets the title of an
28888 individual curve. Like the other curve-manipulating commands, it
28889 affects the most recently added curve, i.e., the last curve on the
28890 list in the @samp{*Gnuplot Commands*} buffer. To set the title of
28891 the other curves you must first juggle them to the end of the list
28892 with @kbd{g j}, or edit the @samp{*Gnuplot Commands*} buffer by hand.
28893 Curve titles appear in the key; if the key is turned off they are
28894 not used.
28895
28896 @kindex g t
28897 @kindex g T
28898 @pindex calc-graph-title-x
28899 @pindex calc-graph-title-y
28900 The @kbd{g t} (@code{calc-graph-title-x}) and @kbd{g T}
28901 (@code{calc-graph-title-y}) commands set the titles on the ``x''
28902 and ``y'' axes, respectively. These titles appear next to the
28903 tick marks on the left and bottom edges of the graph, respectively.
28904 Calc does not have commands to control the tick marks themselves,
28905 but you can edit them into the @samp{*Gnuplot Commands*} buffer if
28906 you wish. See the GNUPLOT documentation for details.
28907
28908 @kindex g r
28909 @kindex g R
28910 @pindex calc-graph-range-x
28911 @pindex calc-graph-range-y
28912 The @kbd{g r} (@code{calc-graph-range-x}) and @kbd{g R}
28913 (@code{calc-graph-range-y}) commands set the range of values on the
28914 ``x'' and ``y'' axes, respectively. You are prompted to enter a
28915 suitable range. This should be either a pair of numbers of the
28916 form, @samp{@var{min}:@var{max}}, or a blank line to revert to the
28917 default behavior of setting the range based on the range of values
28918 in the data, or @samp{$} to take the range from the top of the stack.
28919 Ranges on the stack can be represented as either interval forms or
28920 vectors: @samp{[@var{min} ..@: @var{max}]} or @samp{[@var{min}, @var{max}]}.
28921
28922 @kindex g l
28923 @kindex g L
28924 @pindex calc-graph-log-x
28925 @pindex calc-graph-log-y
28926 The @kbd{g l} (@code{calc-graph-log-x}) and @kbd{g L} (@code{calc-graph-log-y})
28927 commands allow you to set either or both of the axes of the graph to
28928 be logarithmic instead of linear.
28929
28930 @kindex g C-l
28931 @kindex g C-r
28932 @kindex g C-t
28933 @pindex calc-graph-log-z
28934 @pindex calc-graph-range-z
28935 @pindex calc-graph-title-z
28936 For 3D plots, @kbd{g C-t}, @kbd{g C-r}, and @kbd{g C-l} (those are
28937 letters with the Control key held down) are the corresponding commands
28938 for the ``z'' axis.
28939
28940 @kindex g z
28941 @kindex g Z
28942 @pindex calc-graph-zero-x
28943 @pindex calc-graph-zero-y
28944 The @kbd{g z} (@code{calc-graph-zero-x}) and @kbd{g Z}
28945 (@code{calc-graph-zero-y}) commands control whether a dotted line is
28946 drawn to indicate the ``x'' and/or ``y'' zero axes. (These are the same
28947 dotted lines that would be drawn there anyway if you used @kbd{g g} to
28948 turn the ``grid'' feature on.) Zero-axis lines are on by default, and
28949 may be turned off only in GNUPLOT 3.0 and later versions. They are
28950 not available for 3D plots.
28951
28952 @kindex g s
28953 @pindex calc-graph-line-style
28954 The @kbd{g s} (@code{calc-graph-line-style}) command turns the connecting
28955 lines on or off for the most recently added curve, and optionally selects
28956 the style of lines to be used for that curve. Plain @kbd{g s} simply
28957 toggles the lines on and off. With a numeric prefix argument, @kbd{g s}
28958 turns lines on and sets a particular line style. Line style numbers
28959 start at one and their meanings vary depending on the output device.
28960 GNUPLOT guarantees that there will be at least six different line styles
28961 available for any device.
28962
28963 @kindex g S
28964 @pindex calc-graph-point-style
28965 The @kbd{g S} (@code{calc-graph-point-style}) command similarly turns
28966 the symbols at the data points on or off, or sets the point style.
28967 If you turn both lines and points off, the data points will show as
28968 tiny dots.
28969
28970 @cindex @code{LineStyles} variable
28971 @cindex @code{PointStyles} variable
28972 @vindex LineStyles
28973 @vindex PointStyles
28974 Another way to specify curve styles is with the @code{LineStyles} and
28975 @code{PointStyles} variables. These variables initially have no stored
28976 values, but if you store a vector of integers in one of these variables,
28977 the @kbd{g a} and @kbd{g f} commands will use those style numbers
28978 instead of the defaults for new curves that are added to the graph.
28979 An entry should be a positive integer for a specific style, or 0 to let
28980 the style be chosen automatically, or @mathit{-1} to turn off lines or points
28981 altogether. If there are more curves than elements in the vector, the
28982 last few curves will continue to have the default styles. Of course,
28983 you can later use @kbd{g s} and @kbd{g S} to change any of these styles.
28984
28985 For example, @kbd{'[2 -1 3] @key{RET} s t LineStyles} causes the first curve
28986 to have lines in style number 2, the second curve to have no connecting
28987 lines, and the third curve to have lines in style 3. Point styles will
28988 still be assigned automatically, but you could store another vector in
28989 @code{PointStyles} to define them, too.
28990
28991 @node Devices, , Graphics Options, Graphics
28992 @section Graphical Devices
28993
28994 @noindent
28995 @kindex g D
28996 @pindex calc-graph-device
28997 The @kbd{g D} (@code{calc-graph-device}) command sets the device name
28998 (or ``terminal name'' in GNUPLOT lingo) to be used by @kbd{g p} commands
28999 on this graph. It does not affect the permanent default device name.
29000 If you enter a blank name, the device name reverts to the default.
29001 Enter @samp{?} to see a list of supported devices.
29002
29003 With a positive numeric prefix argument, @kbd{g D} instead sets
29004 the default device name, used by all plots in the future which do
29005 not override it with a plain @kbd{g D} command. If you enter a
29006 blank line this command shows you the current default. The special
29007 name @code{default} signifies that Calc should choose @code{x11} if
29008 the X window system is in use (as indicated by the presence of a
29009 @code{DISPLAY} environment variable), or otherwise @code{dumb} under
29010 GNUPLOT 3.0 and later, or @code{postscript} under GNUPLOT 2.0.
29011 This is the initial default value.
29012
29013 The @code{dumb} device is an interface to ``dumb terminals,'' i.e.,
29014 terminals with no special graphics facilities. It writes a crude
29015 picture of the graph composed of characters like @code{-} and @code{|}
29016 to a buffer called @samp{*Gnuplot Trail*}, which Calc then displays.
29017 The graph is made the same size as the Emacs screen, which on most
29018 dumb terminals will be
29019 @texline @math{80\times24}
29020 @infoline 80x24
29021 characters. The graph is displayed in
29022 an Emacs ``recursive edit''; type @kbd{q} or @kbd{C-c C-c} to exit
29023 the recursive edit and return to Calc. Note that the @code{dumb}
29024 device is present only in GNUPLOT 3.0 and later versions.
29025
29026 The word @code{dumb} may be followed by two numbers separated by
29027 spaces. These are the desired width and height of the graph in
29028 characters. Also, the device name @code{big} is like @code{dumb}
29029 but creates a graph four times the width and height of the Emacs
29030 screen. You will then have to scroll around to view the entire
29031 graph. In the @samp{*Gnuplot Trail*} buffer, @key{SPC}, @key{DEL},
29032 @kbd{<}, and @kbd{>} are defined to scroll by one screenful in each
29033 of the four directions.
29034
29035 With a negative numeric prefix argument, @kbd{g D} sets or displays
29036 the device name used by @kbd{g P} (@code{calc-graph-print}). This
29037 is initially @code{postscript}. If you don't have a PostScript
29038 printer, you may decide once again to use @code{dumb} to create a
29039 plot on any text-only printer.
29040
29041 @kindex g O
29042 @pindex calc-graph-output
29043 The @kbd{g O} (@code{calc-graph-output}) command sets the name of
29044 the output file used by GNUPLOT. For some devices, notably @code{x11},
29045 there is no output file and this information is not used. Many other
29046 ``devices'' are really file formats like @code{postscript}; in these
29047 cases the output in the desired format goes into the file you name
29048 with @kbd{g O}. Type @kbd{g O stdout @key{RET}} to set GNUPLOT to write
29049 to its standard output stream, i.e., to @samp{*Gnuplot Trail*}.
29050 This is the default setting.
29051
29052 Another special output name is @code{tty}, which means that GNUPLOT
29053 is going to write graphics commands directly to its standard output,
29054 which you wish Emacs to pass through to your terminal. Tektronix
29055 graphics terminals, among other devices, operate this way. Calc does
29056 this by telling GNUPLOT to write to a temporary file, then running a
29057 sub-shell executing the command @samp{cat tempfile >/dev/tty}. On
29058 typical Unix systems, this will copy the temporary file directly to
29059 the terminal, bypassing Emacs entirely. You will have to type @kbd{C-l}
29060 to Emacs afterwards to refresh the screen.
29061
29062 Once again, @kbd{g O} with a positive or negative prefix argument
29063 sets the default or printer output file names, respectively. In each
29064 case you can specify @code{auto}, which causes Calc to invent a temporary
29065 file name for each @kbd{g p} (or @kbd{g P}) command. This temporary file
29066 will be deleted once it has been displayed or printed. If the output file
29067 name is not @code{auto}, the file is not automatically deleted.
29068
29069 The default and printer devices and output files can be saved
29070 permanently by the @kbd{m m} (@code{calc-save-modes}) command. The
29071 default number of data points (see @kbd{g N}) and the X geometry
29072 (see @kbd{g X}) are also saved. Other graph information is @emph{not}
29073 saved; you can save a graph's configuration simply by saving the contents
29074 of the @samp{*Gnuplot Commands*} buffer.
29075
29076 @vindex calc-gnuplot-plot-command
29077 @vindex calc-gnuplot-default-device
29078 @vindex calc-gnuplot-default-output
29079 @vindex calc-gnuplot-print-command
29080 @vindex calc-gnuplot-print-device
29081 @vindex calc-gnuplot-print-output
29082 If you are installing Calc you may wish to configure the default and
29083 printer devices and output files for the whole system. The relevant
29084 Lisp variables are @code{calc-gnuplot-default-device} and @code{-output},
29085 and @code{calc-gnuplot-print-device} and @code{-output}. The output
29086 file names must be either strings as described above, or Lisp
29087 expressions which are evaluated on the fly to get the output file names.
29088
29089 Other important Lisp variables are @code{calc-gnuplot-plot-command} and
29090 @code{calc-gnuplot-print-command}, which give the system commands to
29091 display or print the output of GNUPLOT, respectively. These may be
29092 @code{nil} if no command is necessary, or strings which can include
29093 @samp{%s} to signify the name of the file to be displayed or printed.
29094 Or, these variables may contain Lisp expressions which are evaluated
29095 to display or print the output.
29096
29097 @kindex g x
29098 @pindex calc-graph-display
29099 The @kbd{g x} (@code{calc-graph-display}) command lets you specify
29100 on which X window system display your graphs should be drawn. Enter
29101 a blank line to see the current display name. This command has no
29102 effect unless the current device is @code{x11}.
29103
29104 @kindex g X
29105 @pindex calc-graph-geometry
29106 The @kbd{g X} (@code{calc-graph-geometry}) command is a similar
29107 command for specifying the position and size of the X window.
29108 The normal value is @code{default}, which generally means your
29109 window manager will let you place the window interactively.
29110 Entering @samp{800x500+0+0} would create an 800-by-500 pixel
29111 window in the upper-left corner of the screen.
29112
29113 The buffer called @samp{*Gnuplot Trail*} holds a transcript of the
29114 session with GNUPLOT. This shows the commands Calc has ``typed'' to
29115 GNUPLOT and the responses it has received. Calc tries to notice when an
29116 error message has appeared here and display the buffer for you when
29117 this happens. You can check this buffer yourself if you suspect
29118 something has gone wrong.
29119
29120 @kindex g C
29121 @pindex calc-graph-command
29122 The @kbd{g C} (@code{calc-graph-command}) command prompts you to
29123 enter any line of text, then simply sends that line to the current
29124 GNUPLOT process. The @samp{*Gnuplot Trail*} buffer looks deceptively
29125 like a Shell buffer but you can't type commands in it yourself.
29126 Instead, you must use @kbd{g C} for this purpose.
29127
29128 @kindex g v
29129 @kindex g V
29130 @pindex calc-graph-view-commands
29131 @pindex calc-graph-view-trail
29132 The @kbd{g v} (@code{calc-graph-view-commands}) and @kbd{g V}
29133 (@code{calc-graph-view-trail}) commands display the @samp{*Gnuplot Commands*}
29134 and @samp{*Gnuplot Trail*} buffers, respectively, in another window.
29135 This happens automatically when Calc thinks there is something you
29136 will want to see in either of these buffers. If you type @kbd{g v}
29137 or @kbd{g V} when the relevant buffer is already displayed, the
29138 buffer is hidden again.
29139
29140 One reason to use @kbd{g v} is to add your own commands to the
29141 @samp{*Gnuplot Commands*} buffer. Press @kbd{g v}, then use
29142 @kbd{C-x o} to switch into that window. For example, GNUPLOT has
29143 @samp{set label} and @samp{set arrow} commands that allow you to
29144 annotate your plots. Since Calc doesn't understand these commands,
29145 you have to add them to the @samp{*Gnuplot Commands*} buffer
29146 yourself, then use @w{@kbd{g p}} to replot using these new commands. Note
29147 that your commands must appear @emph{before} the @code{plot} command.
29148 To get help on any GNUPLOT feature, type, e.g., @kbd{g C help set label}.
29149 You may have to type @kbd{g C @key{RET}} a few times to clear the
29150 ``press return for more'' or ``subtopic of @dots{}'' requests.
29151 Note that Calc always sends commands (like @samp{set nolabel}) to
29152 reset all plotting parameters to the defaults before each plot, so
29153 to delete a label all you need to do is delete the @samp{set label}
29154 line you added (or comment it out with @samp{#}) and then replot
29155 with @kbd{g p}.
29156
29157 @kindex g q
29158 @pindex calc-graph-quit
29159 You can use @kbd{g q} (@code{calc-graph-quit}) to kill the GNUPLOT
29160 process that is running. The next graphing command you give will
29161 start a fresh GNUPLOT process. The word @samp{Graph} appears in
29162 the Calc window's mode line whenever a GNUPLOT process is currently
29163 running. The GNUPLOT process is automatically killed when you
29164 exit Emacs if you haven't killed it manually by then.
29165
29166 @kindex g K
29167 @pindex calc-graph-kill
29168 The @kbd{g K} (@code{calc-graph-kill}) command is like @kbd{g q}
29169 except that it also views the @samp{*Gnuplot Trail*} buffer so that
29170 you can see the process being killed. This is better if you are
29171 killing GNUPLOT because you think it has gotten stuck.
29172
29173 @node Kill and Yank, Keypad Mode, Graphics, Top
29174 @chapter Kill and Yank Functions
29175
29176 @noindent
29177 The commands in this chapter move information between the Calculator and
29178 other Emacs editing buffers.
29179
29180 In many cases Embedded mode is an easier and more natural way to
29181 work with Calc from a regular editing buffer. @xref{Embedded Mode}.
29182
29183 @menu
29184 * Killing From Stack::
29185 * Yanking Into Stack::
29186 * Grabbing From Buffers::
29187 * Yanking Into Buffers::
29188 * X Cut and Paste::
29189 @end menu
29190
29191 @node Killing From Stack, Yanking Into Stack, Kill and Yank, Kill and Yank
29192 @section Killing from the Stack
29193
29194 @noindent
29195 @kindex C-k
29196 @pindex calc-kill
29197 @kindex M-k
29198 @pindex calc-copy-as-kill
29199 @kindex C-w
29200 @pindex calc-kill-region
29201 @kindex M-w
29202 @pindex calc-copy-region-as-kill
29203 @cindex Kill ring
29204 @dfn{Kill} commands are Emacs commands that insert text into the
29205 ``kill ring,'' from which it can later be ``yanked'' by a @kbd{C-y}
29206 command. Three common kill commands in normal Emacs are @kbd{C-k}, which
29207 kills one line, @kbd{C-w}, which kills the region between mark and point,
29208 and @kbd{M-w}, which puts the region into the kill ring without actually
29209 deleting it. All of these commands work in the Calculator, too. Also,
29210 @kbd{M-k} has been provided to complete the set; it puts the current line
29211 into the kill ring without deleting anything.
29212
29213 The kill commands are unusual in that they pay attention to the location
29214 of the cursor in the Calculator buffer. If the cursor is on or below the
29215 bottom line, the kill commands operate on the top of the stack. Otherwise,
29216 they operate on whatever stack element the cursor is on. Calc's kill
29217 commands always operate on whole stack entries. (They act the same as their
29218 standard Emacs cousins except they ``round up'' the specified region to
29219 encompass full lines.) The text is copied into the kill ring exactly as
29220 it appears on the screen, including line numbers if they are enabled.
29221
29222 A numeric prefix argument to @kbd{C-k} or @kbd{M-k} affects the number
29223 of lines killed. A positive argument kills the current line and @expr{n-1}
29224 lines below it. A negative argument kills the @expr{-n} lines above the
29225 current line. Again this mirrors the behavior of the standard Emacs
29226 @kbd{C-k} command. Although a whole line is always deleted, @kbd{C-k}
29227 with no argument copies only the number itself into the kill ring, whereas
29228 @kbd{C-k} with a prefix argument of 1 copies the number with its trailing
29229 newline.
29230
29231 @node Yanking Into Stack, Grabbing From Buffers, Killing From Stack, Kill and Yank
29232 @section Yanking into the Stack
29233
29234 @noindent
29235 @kindex C-y
29236 @pindex calc-yank
29237 The @kbd{C-y} command yanks the most recently killed text back into the
29238 Calculator. It pushes this value onto the top of the stack regardless of
29239 the cursor position. In general it re-parses the killed text as a number
29240 or formula (or a list of these separated by commas or newlines). However if
29241 the thing being yanked is something that was just killed from the Calculator
29242 itself, its full internal structure is yanked. For example, if you have
29243 set the floating-point display mode to show only four significant digits,
29244 then killing and re-yanking 3.14159 (which displays as 3.142) will yank the
29245 full 3.14159, even though yanking it into any other buffer would yank the
29246 number in its displayed form, 3.142. (Since the default display modes
29247 show all objects to their full precision, this feature normally makes no
29248 difference.)
29249
29250 @node Grabbing From Buffers, Yanking Into Buffers, Yanking Into Stack, Kill and Yank
29251 @section Grabbing from Other Buffers
29252
29253 @noindent
29254 @kindex M-# g
29255 @pindex calc-grab-region
29256 The @kbd{M-# g} (@code{calc-grab-region}) command takes the text between
29257 point and mark in the current buffer and attempts to parse it as a
29258 vector of values. Basically, it wraps the text in vector brackets
29259 @samp{[ ]} unless the text already is enclosed in vector brackets,
29260 then reads the text as if it were an algebraic entry. The contents
29261 of the vector may be numbers, formulas, or any other Calc objects.
29262 If the @kbd{M-# g} command works successfully, it does an automatic
29263 @kbd{M-# c} to enter the Calculator buffer.
29264
29265 A numeric prefix argument grabs the specified number of lines around
29266 point, ignoring the mark. A positive prefix grabs from point to the
29267 @expr{n}th following newline (so that @kbd{M-1 M-# g} grabs from point
29268 to the end of the current line); a negative prefix grabs from point
29269 back to the @expr{n+1}st preceding newline. In these cases the text
29270 that is grabbed is exactly the same as the text that @kbd{C-k} would
29271 delete given that prefix argument.
29272
29273 A prefix of zero grabs the current line; point may be anywhere on the
29274 line.
29275
29276 A plain @kbd{C-u} prefix interprets the region between point and mark
29277 as a single number or formula rather than a vector. For example,
29278 @kbd{M-# g} on the text @samp{2 a b} produces the vector of three
29279 values @samp{[2, a, b]}, but @kbd{C-u M-# g} on the same region
29280 reads a formula which is a product of three things: @samp{2 a b}.
29281 (The text @samp{a + b}, on the other hand, will be grabbed as a
29282 vector of one element by plain @kbd{M-# g} because the interpretation
29283 @samp{[a, +, b]} would be a syntax error.)
29284
29285 If a different language has been specified (@pxref{Language Modes}),
29286 the grabbed text will be interpreted according to that language.
29287
29288 @kindex M-# r
29289 @pindex calc-grab-rectangle
29290 The @kbd{M-# r} (@code{calc-grab-rectangle}) command takes the text between
29291 point and mark and attempts to parse it as a matrix. If point and mark
29292 are both in the leftmost column, the lines in between are parsed in their
29293 entirety. Otherwise, point and mark define the corners of a rectangle
29294 whose contents are parsed.
29295
29296 Each line of the grabbed area becomes a row of the matrix. The result
29297 will actually be a vector of vectors, which Calc will treat as a matrix
29298 only if every row contains the same number of values.
29299
29300 If a line contains a portion surrounded by square brackets (or curly
29301 braces), that portion is interpreted as a vector which becomes a row
29302 of the matrix. Any text surrounding the bracketed portion on the line
29303 is ignored.
29304
29305 Otherwise, the entire line is interpreted as a row vector as if it
29306 were surrounded by square brackets. Leading line numbers (in the
29307 format used in the Calc stack buffer) are ignored. If you wish to
29308 force this interpretation (even if the line contains bracketed
29309 portions), give a negative numeric prefix argument to the
29310 @kbd{M-# r} command.
29311
29312 If you give a numeric prefix argument of zero or plain @kbd{C-u}, each
29313 line is instead interpreted as a single formula which is converted into
29314 a one-element vector. Thus the result of @kbd{C-u M-# r} will be a
29315 one-column matrix. For example, suppose one line of the data is the
29316 expression @samp{2 a}. A plain @w{@kbd{M-# r}} will interpret this as
29317 @samp{[2 a]}, which in turn is read as a two-element vector that forms
29318 one row of the matrix. But a @kbd{C-u M-# r} will interpret this row
29319 as @samp{[2*a]}.
29320
29321 If you give a positive numeric prefix argument @var{n}, then each line
29322 will be split up into columns of width @var{n}; each column is parsed
29323 separately as a matrix element. If a line contained
29324 @w{@samp{2 +/- 3 4 +/- 5}}, then grabbing with a prefix argument of 8
29325 would correctly split the line into two error forms.
29326
29327 @xref{Matrix Functions}, to see how to pull the matrix apart into its
29328 constituent rows and columns. (If it is a
29329 @texline @math{1\times1}
29330 @infoline 1x1
29331 matrix, just hit @kbd{v u} (@code{calc-unpack}) twice.)
29332
29333 @kindex M-# :
29334 @kindex M-# _
29335 @pindex calc-grab-sum-across
29336 @pindex calc-grab-sum-down
29337 @cindex Summing rows and columns of data
29338 The @kbd{M-# :} (@code{calc-grab-sum-down}) command is a handy way to
29339 grab a rectangle of data and sum its columns. It is equivalent to
29340 typing @kbd{M-# r}, followed by @kbd{V R : +} (the vector reduction
29341 command that sums the columns of a matrix; @pxref{Reducing}). The
29342 result of the command will be a vector of numbers, one for each column
29343 in the input data. The @kbd{M-# _} (@code{calc-grab-sum-across}) command
29344 similarly grabs a rectangle and sums its rows by executing @w{@kbd{V R _ +}}.
29345
29346 As well as being more convenient, @kbd{M-# :} and @kbd{M-# _} are also
29347 much faster because they don't actually place the grabbed vector on
29348 the stack. In a @kbd{M-# r V R : +} sequence, formatting the vector
29349 for display on the stack takes a large fraction of the total time
29350 (unless you have planned ahead and used @kbd{v .} and @kbd{t .} modes).
29351
29352 For example, suppose we have a column of numbers in a file which we
29353 wish to sum. Go to one corner of the column and press @kbd{C-@@} to
29354 set the mark; go to the other corner and type @kbd{M-# :}. Since there
29355 is only one column, the result will be a vector of one number, the sum.
29356 (You can type @kbd{v u} to unpack this vector into a plain number if
29357 you want to do further arithmetic with it.)
29358
29359 To compute the product of the column of numbers, we would have to do
29360 it ``by hand'' since there's no special grab-and-multiply command.
29361 Use @kbd{M-# r} to grab the column of numbers into the calculator in
29362 the form of a column matrix. The statistics command @kbd{u *} is a
29363 handy way to find the product of a vector or matrix of numbers.
29364 @xref{Statistical Operations}. Another approach would be to use
29365 an explicit column reduction command, @kbd{V R : *}.
29366
29367 @node Yanking Into Buffers, X Cut and Paste, Grabbing From Buffers, Kill and Yank
29368 @section Yanking into Other Buffers
29369
29370 @noindent
29371 @kindex y
29372 @pindex calc-copy-to-buffer
29373 The plain @kbd{y} (@code{calc-copy-to-buffer}) command inserts the number
29374 at the top of the stack into the most recently used normal editing buffer.
29375 (More specifically, this is the most recently used buffer which is displayed
29376 in a window and whose name does not begin with @samp{*}. If there is no
29377 such buffer, this is the most recently used buffer except for Calculator
29378 and Calc Trail buffers.) The number is inserted exactly as it appears and
29379 without a newline. (If line-numbering is enabled, the line number is
29380 normally not included.) The number is @emph{not} removed from the stack.
29381
29382 With a prefix argument, @kbd{y} inserts several numbers, one per line.
29383 A positive argument inserts the specified number of values from the top
29384 of the stack. A negative argument inserts the @expr{n}th value from the
29385 top of the stack. An argument of zero inserts the entire stack. Note
29386 that @kbd{y} with an argument of 1 is slightly different from @kbd{y}
29387 with no argument; the former always copies full lines, whereas the
29388 latter strips off the trailing newline.
29389
29390 With a lone @kbd{C-u} as a prefix argument, @kbd{y} @emph{replaces} the
29391 region in the other buffer with the yanked text, then quits the
29392 Calculator, leaving you in that buffer. A typical use would be to use
29393 @kbd{M-# g} to read a region of data into the Calculator, operate on the
29394 data to produce a new matrix, then type @kbd{C-u y} to replace the
29395 original data with the new data. One might wish to alter the matrix
29396 display style (@pxref{Vector and Matrix Formats}) or change the current
29397 display language (@pxref{Language Modes}) before doing this. Also, note
29398 that this command replaces a linear region of text (as grabbed by
29399 @kbd{M-# g}), not a rectangle (as grabbed by @kbd{M-# r}).
29400
29401 If the editing buffer is in overwrite (as opposed to insert) mode,
29402 and the @kbd{C-u} prefix was not used, then the yanked number will
29403 overwrite the characters following point rather than being inserted
29404 before those characters. The usual conventions of overwrite mode
29405 are observed; for example, characters will be inserted at the end of
29406 a line rather than overflowing onto the next line. Yanking a multi-line
29407 object such as a matrix in overwrite mode overwrites the next @var{n}
29408 lines in the buffer, lengthening or shortening each line as necessary.
29409 Finally, if the thing being yanked is a simple integer or floating-point
29410 number (like @samp{-1.2345e-3}) and the characters following point also
29411 make up such a number, then Calc will replace that number with the new
29412 number, lengthening or shortening as necessary. The concept of
29413 ``overwrite mode'' has thus been generalized from overwriting characters
29414 to overwriting one complete number with another.
29415
29416 @kindex M-# y
29417 The @kbd{M-# y} key sequence is equivalent to @kbd{y} except that
29418 it can be typed anywhere, not just in Calc. This provides an easy
29419 way to guarantee that Calc knows which editing buffer you want to use!
29420
29421 @node X Cut and Paste, , Yanking Into Buffers, Kill and Yank
29422 @section X Cut and Paste
29423
29424 @noindent
29425 If you are using Emacs with the X window system, there is an easier
29426 way to move small amounts of data into and out of the calculator:
29427 Use the mouse-oriented cut and paste facilities of X.
29428
29429 The default bindings for a three-button mouse cause the left button
29430 to move the Emacs cursor to the given place, the right button to
29431 select the text between the cursor and the clicked location, and
29432 the middle button to yank the selection into the buffer at the
29433 clicked location. So, if you have a Calc window and an editing
29434 window on your Emacs screen, you can use left-click/right-click
29435 to select a number, vector, or formula from one window, then
29436 middle-click to paste that value into the other window. When you
29437 paste text into the Calc window, Calc interprets it as an algebraic
29438 entry. It doesn't matter where you click in the Calc window; the
29439 new value is always pushed onto the top of the stack.
29440
29441 The @code{xterm} program that is typically used for general-purpose
29442 shell windows in X interprets the mouse buttons in the same way.
29443 So you can use the mouse to move data between Calc and any other
29444 Unix program. One nice feature of @code{xterm} is that a double
29445 left-click selects one word, and a triple left-click selects a
29446 whole line. So you can usually transfer a single number into Calc
29447 just by double-clicking on it in the shell, then middle-clicking
29448 in the Calc window.
29449
29450 @node Keypad Mode, Embedded Mode, Kill and Yank, Introduction
29451 @chapter Keypad Mode
29452
29453 @noindent
29454 @kindex M-# k
29455 @pindex calc-keypad
29456 The @kbd{M-# k} (@code{calc-keypad}) command starts the Calculator
29457 and displays a picture of a calculator-style keypad. If you are using
29458 the X window system, you can click on any of the ``keys'' in the
29459 keypad using the left mouse button to operate the calculator.
29460 The original window remains the selected window; in Keypad mode
29461 you can type in your file while simultaneously performing
29462 calculations with the mouse.
29463
29464 @pindex full-calc-keypad
29465 If you have used @kbd{M-# b} first, @kbd{M-# k} instead invokes
29466 the @code{full-calc-keypad} command, which takes over the whole
29467 Emacs screen and displays the keypad, the Calc stack, and the Calc
29468 trail all at once. This mode would normally be used when running
29469 Calc standalone (@pxref{Standalone Operation}).
29470
29471 If you aren't using the X window system, you must switch into
29472 the @samp{*Calc Keypad*} window, place the cursor on the desired
29473 ``key,'' and type @key{SPC} or @key{RET}. If you think this
29474 is easier than using Calc normally, go right ahead.
29475
29476 Calc commands are more or less the same in Keypad mode. Certain
29477 keypad keys differ slightly from the corresponding normal Calc
29478 keystrokes; all such deviations are described below.
29479
29480 Keypad mode includes many more commands than will fit on the keypad
29481 at once. Click the right mouse button [@code{calc-keypad-menu}]
29482 to switch to the next menu. The bottom five rows of the keypad
29483 stay the same; the top three rows change to a new set of commands.
29484 To return to earlier menus, click the middle mouse button
29485 [@code{calc-keypad-menu-back}] or simply advance through the menus
29486 until you wrap around. Typing @key{TAB} inside the keypad window
29487 is equivalent to clicking the right mouse button there.
29488
29489 You can always click the @key{EXEC} button and type any normal
29490 Calc key sequence. This is equivalent to switching into the
29491 Calc buffer, typing the keys, then switching back to your
29492 original buffer.
29493
29494 @menu
29495 * Keypad Main Menu::
29496 * Keypad Functions Menu::
29497 * Keypad Binary Menu::
29498 * Keypad Vectors Menu::
29499 * Keypad Modes Menu::
29500 @end menu
29501
29502 @node Keypad Main Menu, Keypad Functions Menu, Keypad Mode, Keypad Mode
29503 @section Main Menu
29504
29505 @smallexample
29506 @group
29507 |----+-----Calc 2.00-----+----1
29508 |FLR |CEIL|RND |TRNC|CLN2|FLT |
29509 |----+----+----+----+----+----|
29510 | LN |EXP | |ABS |IDIV|MOD |
29511 |----+----+----+----+----+----|
29512 |SIN |COS |TAN |SQRT|y^x |1/x |
29513 |----+----+----+----+----+----|
29514 | ENTER |+/- |EEX |UNDO| <- |
29515 |-----+---+-+--+--+-+---++----|
29516 | INV | 7 | 8 | 9 | / |
29517 |-----+-----+-----+-----+-----|
29518 | HYP | 4 | 5 | 6 | * |
29519 |-----+-----+-----+-----+-----|
29520 |EXEC | 1 | 2 | 3 | - |
29521 |-----+-----+-----+-----+-----|
29522 | OFF | 0 | . | PI | + |
29523 |-----+-----+-----+-----+-----+
29524 @end group
29525 @end smallexample
29526
29527 @noindent
29528 This is the menu that appears the first time you start Keypad mode.
29529 It will show up in a vertical window on the right side of your screen.
29530 Above this menu is the traditional Calc stack display. On a 24-line
29531 screen you will be able to see the top three stack entries.
29532
29533 The ten digit keys, decimal point, and @key{EEX} key are used for
29534 entering numbers in the obvious way. @key{EEX} begins entry of an
29535 exponent in scientific notation. Just as with regular Calc, the
29536 number is pushed onto the stack as soon as you press @key{ENTER}
29537 or any other function key.
29538
29539 The @key{+/-} key corresponds to normal Calc's @kbd{n} key. During
29540 numeric entry it changes the sign of the number or of the exponent.
29541 At other times it changes the sign of the number on the top of the
29542 stack.
29543
29544 The @key{INV} and @key{HYP} keys modify other keys. As well as
29545 having the effects described elsewhere in this manual, Keypad mode
29546 defines several other ``inverse'' operations. These are described
29547 below and in the following sections.
29548
29549 The @key{ENTER} key finishes the current numeric entry, or otherwise
29550 duplicates the top entry on the stack.
29551
29552 The @key{UNDO} key undoes the most recent Calc operation.
29553 @kbd{INV UNDO} is the ``redo'' command, and @kbd{HYP UNDO} is
29554 ``last arguments'' (@kbd{M-@key{RET}}).
29555
29556 The @key{<-} key acts as a ``backspace'' during numeric entry.
29557 At other times it removes the top stack entry. @kbd{INV <-}
29558 clears the entire stack. @kbd{HYP <-} takes an integer from
29559 the stack, then removes that many additional stack elements.
29560
29561 The @key{EXEC} key prompts you to enter any keystroke sequence
29562 that would normally work in Calc mode. This can include a
29563 numeric prefix if you wish. It is also possible simply to
29564 switch into the Calc window and type commands in it; there is
29565 nothing ``magic'' about this window when Keypad mode is active.
29566
29567 The other keys in this display perform their obvious calculator
29568 functions. @key{CLN2} rounds the top-of-stack by temporarily
29569 reducing the precision by 2 digits. @key{FLT} converts an
29570 integer or fraction on the top of the stack to floating-point.
29571
29572 The @key{INV} and @key{HYP} keys combined with several of these keys
29573 give you access to some common functions even if the appropriate menu
29574 is not displayed. Obviously you don't need to learn these keys
29575 unless you find yourself wasting time switching among the menus.
29576
29577 @table @kbd
29578 @item INV +/-
29579 is the same as @key{1/x}.
29580 @item INV +
29581 is the same as @key{SQRT}.
29582 @item INV -
29583 is the same as @key{CONJ}.
29584 @item INV *
29585 is the same as @key{y^x}.
29586 @item INV /
29587 is the same as @key{INV y^x} (the @expr{x}th root of @expr{y}).
29588 @item HYP/INV 1
29589 are the same as @key{SIN} / @kbd{INV SIN}.
29590 @item HYP/INV 2
29591 are the same as @key{COS} / @kbd{INV COS}.
29592 @item HYP/INV 3
29593 are the same as @key{TAN} / @kbd{INV TAN}.
29594 @item INV/HYP 4
29595 are the same as @key{LN} / @kbd{HYP LN}.
29596 @item INV/HYP 5
29597 are the same as @key{EXP} / @kbd{HYP EXP}.
29598 @item INV 6
29599 is the same as @key{ABS}.
29600 @item INV 7
29601 is the same as @key{RND} (@code{calc-round}).
29602 @item INV 8
29603 is the same as @key{CLN2}.
29604 @item INV 9
29605 is the same as @key{FLT} (@code{calc-float}).
29606 @item INV 0
29607 is the same as @key{IMAG}.
29608 @item INV .
29609 is the same as @key{PREC}.
29610 @item INV ENTER
29611 is the same as @key{SWAP}.
29612 @item HYP ENTER
29613 is the same as @key{RLL3}.
29614 @item INV HYP ENTER
29615 is the same as @key{OVER}.
29616 @item HYP +/-
29617 packs the top two stack entries as an error form.
29618 @item HYP EEX
29619 packs the top two stack entries as a modulo form.
29620 @item INV EEX
29621 creates an interval form; this removes an integer which is one
29622 of 0 @samp{[]}, 1 @samp{[)}, 2 @samp{(]} or 3 @samp{()}, followed
29623 by the two limits of the interval.
29624 @end table
29625
29626 The @kbd{OFF} key turns Calc off; typing @kbd{M-# k} or @kbd{M-# M-#}
29627 again has the same effect. This is analogous to typing @kbd{q} or
29628 hitting @kbd{M-# c} again in the normal calculator. If Calc is
29629 running standalone (the @code{full-calc-keypad} command appeared in the
29630 command line that started Emacs), then @kbd{OFF} is replaced with
29631 @kbd{EXIT}; clicking on this actually exits Emacs itself.
29632
29633 @node Keypad Functions Menu, Keypad Binary Menu, Keypad Main Menu, Keypad Mode
29634 @section Functions Menu
29635
29636 @smallexample
29637 @group
29638 |----+----+----+----+----+----2
29639 |IGAM|BETA|IBET|ERF |BESJ|BESY|
29640 |----+----+----+----+----+----|
29641 |IMAG|CONJ| RE |ATN2|RAND|RAGN|
29642 |----+----+----+----+----+----|
29643 |GCD |FACT|DFCT|BNOM|PERM|NXTP|
29644 |----+----+----+----+----+----|
29645 @end group
29646 @end smallexample
29647
29648 @noindent
29649 This menu provides various operations from the @kbd{f} and @kbd{k}
29650 prefix keys.
29651
29652 @key{IMAG} multiplies the number on the stack by the imaginary
29653 number @expr{i = (0, 1)}.
29654
29655 @key{RE} extracts the real part a complex number. @kbd{INV RE}
29656 extracts the imaginary part.
29657
29658 @key{RAND} takes a number from the top of the stack and computes
29659 a random number greater than or equal to zero but less than that
29660 number. (@xref{Random Numbers}.) @key{RAGN} is the ``random
29661 again'' command; it computes another random number using the
29662 same limit as last time.
29663
29664 @key{INV GCD} computes the LCM (least common multiple) function.
29665
29666 @key{INV FACT} is the gamma function.
29667 @texline @math{\Gamma(x) = (x-1)!}.
29668 @infoline @expr{gamma(x) = (x-1)!}.
29669
29670 @key{PERM} is the number-of-permutations function, which is on the
29671 @kbd{H k c} key in normal Calc.
29672
29673 @key{NXTP} finds the next prime after a number. @kbd{INV NXTP}
29674 finds the previous prime.
29675
29676 @node Keypad Binary Menu, Keypad Vectors Menu, Keypad Functions Menu, Keypad Mode
29677 @section Binary Menu
29678
29679 @smallexample
29680 @group
29681 |----+----+----+----+----+----3
29682 |AND | OR |XOR |NOT |LSH |RSH |
29683 |----+----+----+----+----+----|
29684 |DEC |HEX |OCT |BIN |WSIZ|ARSH|
29685 |----+----+----+----+----+----|
29686 | A | B | C | D | E | F |
29687 |----+----+----+----+----+----|
29688 @end group
29689 @end smallexample
29690
29691 @noindent
29692 The keys in this menu perform operations on binary integers.
29693 Note that both logical and arithmetic right-shifts are provided.
29694 @key{INV LSH} rotates one bit to the left.
29695
29696 The ``difference'' function (normally on @kbd{b d}) is on @key{INV AND}.
29697 The ``clip'' function (normally on @w{@kbd{b c}}) is on @key{INV NOT}.
29698
29699 The @key{DEC}, @key{HEX}, @key{OCT}, and @key{BIN} keys select the
29700 current radix for display and entry of numbers: Decimal, hexadecimal,
29701 octal, or binary. The six letter keys @key{A} through @key{F} are used
29702 for entering hexadecimal numbers.
29703
29704 The @key{WSIZ} key displays the current word size for binary operations
29705 and allows you to enter a new word size. You can respond to the prompt
29706 using either the keyboard or the digits and @key{ENTER} from the keypad.
29707 The initial word size is 32 bits.
29708
29709 @node Keypad Vectors Menu, Keypad Modes Menu, Keypad Binary Menu, Keypad Mode
29710 @section Vectors Menu
29711
29712 @smallexample
29713 @group
29714 |----+----+----+----+----+----4
29715 |SUM |PROD|MAX |MAP*|MAP^|MAP$|
29716 |----+----+----+----+----+----|
29717 |MINV|MDET|MTRN|IDNT|CRSS|"x" |
29718 |----+----+----+----+----+----|
29719 |PACK|UNPK|INDX|BLD |LEN |... |
29720 |----+----+----+----+----+----|
29721 @end group
29722 @end smallexample
29723
29724 @noindent
29725 The keys in this menu operate on vectors and matrices.
29726
29727 @key{PACK} removes an integer @var{n} from the top of the stack;
29728 the next @var{n} stack elements are removed and packed into a vector,
29729 which is replaced onto the stack. Thus the sequence
29730 @kbd{1 ENTER 3 ENTER 5 ENTER 3 PACK} enters the vector
29731 @samp{[1, 3, 5]} onto the stack. To enter a matrix, build each row
29732 on the stack as a vector, then use a final @key{PACK} to collect the
29733 rows into a matrix.
29734
29735 @key{UNPK} unpacks the vector on the stack, pushing each of its
29736 components separately.
29737
29738 @key{INDX} removes an integer @var{n}, then builds a vector of
29739 integers from 1 to @var{n}. @kbd{INV INDX} takes three numbers
29740 from the stack: The vector size @var{n}, the starting number,
29741 and the increment. @kbd{BLD} takes an integer @var{n} and any
29742 value @var{x} and builds a vector of @var{n} copies of @var{x}.
29743
29744 @key{IDNT} removes an integer @var{n}, then builds an @var{n}-by-@var{n}
29745 identity matrix.
29746
29747 @key{LEN} replaces a vector by its length, an integer.
29748
29749 @key{...} turns on or off ``abbreviated'' display mode for large vectors.
29750
29751 @key{MINV}, @key{MDET}, @key{MTRN}, and @key{CROSS} are the matrix
29752 inverse, determinant, and transpose, and vector cross product.
29753
29754 @key{SUM} replaces a vector by the sum of its elements. It is
29755 equivalent to @kbd{u +} in normal Calc (@pxref{Statistical Operations}).
29756 @key{PROD} computes the product of the elements of a vector, and
29757 @key{MAX} computes the maximum of all the elements of a vector.
29758
29759 @key{INV SUM} computes the alternating sum of the first element
29760 minus the second, plus the third, minus the fourth, and so on.
29761 @key{INV MAX} computes the minimum of the vector elements.
29762
29763 @key{HYP SUM} computes the mean of the vector elements.
29764 @key{HYP PROD} computes the sample standard deviation.
29765 @key{HYP MAX} computes the median.
29766
29767 @key{MAP*} multiplies two vectors elementwise. It is equivalent
29768 to the @kbd{V M *} command. @key{MAP^} computes powers elementwise.
29769 The arguments must be vectors of equal length, or one must be a vector
29770 and the other must be a plain number. For example, @kbd{2 MAP^} squares
29771 all the elements of a vector.
29772
29773 @key{MAP$} maps the formula on the top of the stack across the
29774 vector in the second-to-top position. If the formula contains
29775 several variables, Calc takes that many vectors starting at the
29776 second-to-top position and matches them to the variables in
29777 alphabetical order. The result is a vector of the same size as
29778 the input vectors, whose elements are the formula evaluated with
29779 the variables set to the various sets of numbers in those vectors.
29780 For example, you could simulate @key{MAP^} using @key{MAP$} with
29781 the formula @samp{x^y}.
29782
29783 The @kbd{"x"} key pushes the variable name @expr{x} onto the
29784 stack. To build the formula @expr{x^2 + 6}, you would use the
29785 key sequence @kbd{"x" 2 y^x 6 +}. This formula would then be
29786 suitable for use with the @key{MAP$} key described above.
29787 With @key{INV}, @key{HYP}, or @key{INV} and @key{HYP}, the
29788 @kbd{"x"} key pushes the variable names @expr{y}, @expr{z}, and
29789 @expr{t}, respectively.
29790
29791 @node Keypad Modes Menu, , Keypad Vectors Menu, Keypad Mode
29792 @section Modes Menu
29793
29794 @smallexample
29795 @group
29796 |----+----+----+----+----+----5
29797 |FLT |FIX |SCI |ENG |GRP | |
29798 |----+----+----+----+----+----|
29799 |RAD |DEG |FRAC|POLR|SYMB|PREC|
29800 |----+----+----+----+----+----|
29801 |SWAP|RLL3|RLL4|OVER|STO |RCL |
29802 |----+----+----+----+----+----|
29803 @end group
29804 @end smallexample
29805
29806 @noindent
29807 The keys in this menu manipulate modes, variables, and the stack.
29808
29809 The @key{FLT}, @key{FIX}, @key{SCI}, and @key{ENG} keys select
29810 floating-point, fixed-point, scientific, or engineering notation.
29811 @key{FIX} displays two digits after the decimal by default; the
29812 others display full precision. With the @key{INV} prefix, these
29813 keys pop a number-of-digits argument from the stack.
29814
29815 The @key{GRP} key turns grouping of digits with commas on or off.
29816 @kbd{INV GRP} enables grouping to the right of the decimal point as
29817 well as to the left.
29818
29819 The @key{RAD} and @key{DEG} keys switch between radians and degrees
29820 for trigonometric functions.
29821
29822 The @key{FRAC} key turns Fraction mode on or off. This affects
29823 whether commands like @kbd{/} with integer arguments produce
29824 fractional or floating-point results.
29825
29826 The @key{POLR} key turns Polar mode on or off, determining whether
29827 polar or rectangular complex numbers are used by default.
29828
29829 The @key{SYMB} key turns Symbolic mode on or off, in which
29830 operations that would produce inexact floating-point results
29831 are left unevaluated as algebraic formulas.
29832
29833 The @key{PREC} key selects the current precision. Answer with
29834 the keyboard or with the keypad digit and @key{ENTER} keys.
29835
29836 The @key{SWAP} key exchanges the top two stack elements.
29837 The @key{RLL3} key rotates the top three stack elements upwards.
29838 The @key{RLL4} key rotates the top four stack elements upwards.
29839 The @key{OVER} key duplicates the second-to-top stack element.
29840
29841 The @key{STO} and @key{RCL} keys are analogous to @kbd{s t} and
29842 @kbd{s r} in regular Calc. @xref{Store and Recall}. Click the
29843 @key{STO} or @key{RCL} key, then one of the ten digits. (Named
29844 variables are not available in Keypad mode.) You can also use,
29845 for example, @kbd{STO + 3} to add to register 3.
29846
29847 @node Embedded Mode, Programming, Keypad Mode, Top
29848 @chapter Embedded Mode
29849
29850 @noindent
29851 Embedded mode in Calc provides an alternative to copying numbers
29852 and formulas back and forth between editing buffers and the Calc
29853 stack. In Embedded mode, your editing buffer becomes temporarily
29854 linked to the stack and this copying is taken care of automatically.
29855
29856 @menu
29857 * Basic Embedded Mode::
29858 * More About Embedded Mode::
29859 * Assignments in Embedded Mode::
29860 * Mode Settings in Embedded Mode::
29861 * Customizing Embedded Mode::
29862 @end menu
29863
29864 @node Basic Embedded Mode, More About Embedded Mode, Embedded Mode, Embedded Mode
29865 @section Basic Embedded Mode
29866
29867 @noindent
29868 @kindex M-# e
29869 @pindex calc-embedded
29870 To enter Embedded mode, position the Emacs point (cursor) on a
29871 formula in any buffer and press @kbd{M-# e} (@code{calc-embedded}).
29872 Note that @kbd{M-# e} is not to be used in the Calc stack buffer
29873 like most Calc commands, but rather in regular editing buffers that
29874 are visiting your own files.
29875
29876 Calc will try to guess an appropriate language based on the major mode
29877 of the editing buffer. (@xref{Language Modes}.) If the current buffer is
29878 in @code{latex-mode}, for example, Calc will set its language to La@TeX{}.
29879 Similarly, Calc will use @TeX{} language for @code{tex-mode},
29880 @code{plain-tex-mode} and @code{context-mode}, C language for
29881 @code{c-mode} and @code{c++-mode}, FORTRAN language for
29882 @code{fortran-mode} and @code{f90-mode}, Pascal for @code{pascal-mode},
29883 and eqn for @code{nroff-mode}. These can be overridden with Calc's mode
29884 changing commands (@pxref{Mode Settings in Embedded Mode}). If no
29885 suitable language is available, Calc will continue with its current language.
29886
29887 Calc normally scans backward and forward in the buffer for the
29888 nearest opening and closing @dfn{formula delimiters}. The simplest
29889 delimiters are blank lines. Other delimiters that Embedded mode
29890 understands are:
29891
29892 @enumerate
29893 @item
29894 The @TeX{} and La@TeX{} math delimiters @samp{$ $}, @samp{$$ $$},
29895 @samp{\[ \]}, and @samp{\( \)};
29896 @item
29897 Lines beginning with @samp{\begin} and @samp{\end} (except matrix delimiters);
29898 @item
29899 Lines beginning with @samp{@@} (Texinfo delimiters).
29900 @item
29901 Lines beginning with @samp{.EQ} and @samp{.EN} (@dfn{eqn} delimiters);
29902 @item
29903 Lines containing a single @samp{%} or @samp{.\"} symbol and nothing else.
29904 @end enumerate
29905
29906 @xref{Customizing Embedded Mode}, to see how to make Calc recognize
29907 your own favorite delimiters. Delimiters like @samp{$ $} can appear
29908 on their own separate lines or in-line with the formula.
29909
29910 If you give a positive or negative numeric prefix argument, Calc
29911 instead uses the current point as one end of the formula, and moves
29912 forward or backward (respectively) by that many lines to find the
29913 other end. Explicit delimiters are not necessary in this case.
29914
29915 With a prefix argument of zero, Calc uses the current region
29916 (delimited by point and mark) instead of formula delimiters.
29917
29918 @kindex M-# w
29919 @pindex calc-embedded-word
29920 With a prefix argument of @kbd{C-u} only, Calc scans for the first
29921 non-numeric character (i.e., the first character that is not a
29922 digit, sign, decimal point, or upper- or lower-case @samp{e})
29923 forward and backward to delimit the formula. @kbd{M-# w}
29924 (@code{calc-embedded-word}) is equivalent to @kbd{C-u M-# e}.
29925
29926 When you enable Embedded mode for a formula, Calc reads the text
29927 between the delimiters and tries to interpret it as a Calc formula.
29928 Calc can generally identify @TeX{} formulas and
29929 Big-style formulas even if the language mode is wrong. If Calc
29930 can't make sense of the formula, it beeps and refuses to enter
29931 Embedded mode. But if the current language is wrong, Calc can
29932 sometimes parse the formula successfully (but incorrectly);
29933 for example, the C expression @samp{atan(a[1])} can be parsed
29934 in Normal language mode, but the @code{atan} won't correspond to
29935 the built-in @code{arctan} function, and the @samp{a[1]} will be
29936 interpreted as @samp{a} times the vector @samp{[1]}!
29937
29938 If you press @kbd{M-# e} or @kbd{M-# w} to activate an embedded
29939 formula which is blank, say with the cursor on the space between
29940 the two delimiters @samp{$ $}, Calc will immediately prompt for
29941 an algebraic entry.
29942
29943 Only one formula in one buffer can be enabled at a time. If you
29944 move to another area of the current buffer and give Calc commands,
29945 Calc turns Embedded mode off for the old formula and then tries
29946 to restart Embedded mode at the new position. Other buffers are
29947 not affected by Embedded mode.
29948
29949 When Embedded mode begins, Calc pushes the current formula onto
29950 the stack. No Calc stack window is created; however, Calc copies
29951 the top-of-stack position into the original buffer at all times.
29952 You can create a Calc window by hand with @kbd{M-# o} if you
29953 find you need to see the entire stack.
29954
29955 For example, typing @kbd{M-# e} while somewhere in the formula
29956 @samp{n>2} in the following line enables Embedded mode on that
29957 inequality:
29958
29959 @example
29960 We define $F_n = F_(n-1)+F_(n-2)$ for all $n>2$.
29961 @end example
29962
29963 @noindent
29964 The formula @expr{n>2} will be pushed onto the Calc stack, and
29965 the top of stack will be copied back into the editing buffer.
29966 This means that spaces will appear around the @samp{>} symbol
29967 to match Calc's usual display style:
29968
29969 @example
29970 We define $F_n = F_(n-1)+F_(n-2)$ for all $n > 2$.
29971 @end example
29972
29973 @noindent
29974 No spaces have appeared around the @samp{+} sign because it's
29975 in a different formula, one which we have not yet touched with
29976 Embedded mode.
29977
29978 Now that Embedded mode is enabled, keys you type in this buffer
29979 are interpreted as Calc commands. At this point we might use
29980 the ``commute'' command @kbd{j C} to reverse the inequality.
29981 This is a selection-based command for which we first need to
29982 move the cursor onto the operator (@samp{>} in this case) that
29983 needs to be commuted.
29984
29985 @example
29986 We define $F_n = F_(n-1)+F_(n-2)$ for all $2 < n$.
29987 @end example
29988
29989 The @kbd{M-# o} command is a useful way to open a Calc window
29990 without actually selecting that window. Giving this command
29991 verifies that @samp{2 < n} is also on the Calc stack. Typing
29992 @kbd{17 @key{RET}} would produce:
29993
29994 @example
29995 We define $F_n = F_(n-1)+F_(n-2)$ for all $17$.
29996 @end example
29997
29998 @noindent
29999 with @samp{2 < n} and @samp{17} on the stack; typing @key{TAB}
30000 at this point will exchange the two stack values and restore
30001 @samp{2 < n} to the embedded formula. Even though you can't
30002 normally see the stack in Embedded mode, it is still there and
30003 it still operates in the same way. But, as with old-fashioned
30004 RPN calculators, you can only see the value at the top of the
30005 stack at any given time (unless you use @kbd{M-# o}).
30006
30007 Typing @kbd{M-# e} again turns Embedded mode off. The Calc
30008 window reveals that the formula @w{@samp{2 < n}} is automatically
30009 removed from the stack, but the @samp{17} is not. Entering
30010 Embedded mode always pushes one thing onto the stack, and
30011 leaving Embedded mode always removes one thing. Anything else
30012 that happens on the stack is entirely your business as far as
30013 Embedded mode is concerned.
30014
30015 If you press @kbd{M-# e} in the wrong place by accident, it is
30016 possible that Calc will be able to parse the nearby text as a
30017 formula and will mangle that text in an attempt to redisplay it
30018 ``properly'' in the current language mode. If this happens,
30019 press @kbd{M-# e} again to exit Embedded mode, then give the
30020 regular Emacs ``undo'' command (@kbd{C-_} or @kbd{C-x u}) to put
30021 the text back the way it was before Calc edited it. Note that Calc's
30022 own Undo command (typed before you turn Embedded mode back off)
30023 will not do you any good, because as far as Calc is concerned
30024 you haven't done anything with this formula yet.
30025
30026 @node More About Embedded Mode, Assignments in Embedded Mode, Basic Embedded Mode, Embedded Mode
30027 @section More About Embedded Mode
30028
30029 @noindent
30030 When Embedded mode ``activates'' a formula, i.e., when it examines
30031 the formula for the first time since the buffer was created or
30032 loaded, Calc tries to sense the language in which the formula was
30033 written. If the formula contains any La@TeX{}-like @samp{\} sequences,
30034 it is parsed (i.e., read) in La@TeX{} mode. If the formula appears to
30035 be written in multi-line Big mode, it is parsed in Big mode. Otherwise,
30036 it is parsed according to the current language mode.
30037
30038 Note that Calc does not change the current language mode according
30039 the formula it reads in. Even though it can read a La@TeX{} formula when
30040 not in La@TeX{} mode, it will immediately rewrite this formula using
30041 whatever language mode is in effect.
30042
30043 @tex
30044 \bigskip
30045 @end tex
30046
30047 @kindex d p
30048 @pindex calc-show-plain
30049 Calc's parser is unable to read certain kinds of formulas. For
30050 example, with @kbd{v ]} (@code{calc-matrix-brackets}) you can
30051 specify matrix display styles which the parser is unable to
30052 recognize as matrices. The @kbd{d p} (@code{calc-show-plain})
30053 command turns on a mode in which a ``plain'' version of a
30054 formula is placed in front of the fully-formatted version.
30055 When Calc reads a formula that has such a plain version in
30056 front, it reads the plain version and ignores the formatted
30057 version.
30058
30059 Plain formulas are preceded and followed by @samp{%%%} signs
30060 by default. This notation has the advantage that the @samp{%}
30061 character begins a comment in @TeX{} and La@TeX{}, so if your formula is
30062 embedded in a @TeX{} or La@TeX{} document its plain version will be
30063 invisible in the final printed copy. @xref{Customizing
30064 Embedded Mode}, to see how to change the ``plain'' formula
30065 delimiters, say to something that @dfn{eqn} or some other
30066 formatter will treat as a comment.
30067
30068 There are several notations which Calc's parser for ``big''
30069 formatted formulas can't yet recognize. In particular, it can't
30070 read the large symbols for @code{sum}, @code{prod}, and @code{integ},
30071 and it can't handle @samp{=>} with the righthand argument omitted.
30072 Also, Calc won't recognize special formats you have defined with
30073 the @kbd{Z C} command (@pxref{User-Defined Compositions}). In
30074 these cases it is important to use ``plain'' mode to make sure
30075 Calc will be able to read your formula later.
30076
30077 Another example where ``plain'' mode is important is if you have
30078 specified a float mode with few digits of precision. Normally
30079 any digits that are computed but not displayed will simply be
30080 lost when you save and re-load your embedded buffer, but ``plain''
30081 mode allows you to make sure that the complete number is present
30082 in the file as well as the rounded-down number.
30083
30084 @tex
30085 \bigskip
30086 @end tex
30087
30088 Embedded buffers remember active formulas for as long as they
30089 exist in Emacs memory. Suppose you have an embedded formula
30090 which is @cpi{} to the normal 12 decimal places, and then
30091 type @w{@kbd{C-u 5 d n}} to display only five decimal places.
30092 If you then type @kbd{d n}, all 12 places reappear because the
30093 full number is still there on the Calc stack. More surprisingly,
30094 even if you exit Embedded mode and later re-enter it for that
30095 formula, typing @kbd{d n} will restore all 12 places because
30096 each buffer remembers all its active formulas. However, if you
30097 save the buffer in a file and reload it in a new Emacs session,
30098 all non-displayed digits will have been lost unless you used
30099 ``plain'' mode.
30100
30101 @tex
30102 \bigskip
30103 @end tex
30104
30105 In some applications of Embedded mode, you will want to have a
30106 sequence of copies of a formula that show its evolution as you
30107 work on it. For example, you might want to have a sequence
30108 like this in your file (elaborating here on the example from
30109 the ``Getting Started'' chapter):
30110
30111 @smallexample
30112 The derivative of
30113
30114 ln(ln(x))
30115
30116 is
30117
30118 @r{(the derivative of }ln(ln(x))@r{)}
30119
30120 whose value at x = 2 is
30121
30122 @r{(the value)}
30123
30124 and at x = 3 is
30125
30126 @r{(the value)}
30127 @end smallexample
30128
30129 @kindex M-# d
30130 @pindex calc-embedded-duplicate
30131 The @kbd{M-# d} (@code{calc-embedded-duplicate}) command is a
30132 handy way to make sequences like this. If you type @kbd{M-# d},
30133 the formula under the cursor (which may or may not have Embedded
30134 mode enabled for it at the time) is copied immediately below and
30135 Embedded mode is then enabled for that copy.
30136
30137 For this example, you would start with just
30138
30139 @smallexample
30140 The derivative of
30141
30142 ln(ln(x))
30143 @end smallexample
30144
30145 @noindent
30146 and press @kbd{M-# d} with the cursor on this formula. The result
30147 is
30148
30149 @smallexample
30150 The derivative of
30151
30152 ln(ln(x))
30153
30154
30155 ln(ln(x))
30156 @end smallexample
30157
30158 @noindent
30159 with the second copy of the formula enabled in Embedded mode.
30160 You can now press @kbd{a d x @key{RET}} to take the derivative, and
30161 @kbd{M-# d M-# d} to make two more copies of the derivative.
30162 To complete the computations, type @kbd{3 s l x @key{RET}} to evaluate
30163 the last formula, then move up to the second-to-last formula
30164 and type @kbd{2 s l x @key{RET}}.
30165
30166 Finally, you would want to press @kbd{M-# e} to exit Embedded
30167 mode, then go up and insert the necessary text in between the
30168 various formulas and numbers.
30169
30170 @tex
30171 \bigskip
30172 @end tex
30173
30174 @kindex M-# f
30175 @kindex M-# '
30176 @pindex calc-embedded-new-formula
30177 The @kbd{M-# f} (@code{calc-embedded-new-formula}) command
30178 creates a new embedded formula at the current point. It inserts
30179 some default delimiters, which are usually just blank lines,
30180 and then does an algebraic entry to get the formula (which is
30181 then enabled for Embedded mode). This is just shorthand for
30182 typing the delimiters yourself, positioning the cursor between
30183 the new delimiters, and pressing @kbd{M-# e}. The key sequence
30184 @kbd{M-# '} is equivalent to @kbd{M-# f}.
30185
30186 @kindex M-# n
30187 @kindex M-# p
30188 @pindex calc-embedded-next
30189 @pindex calc-embedded-previous
30190 The @kbd{M-# n} (@code{calc-embedded-next}) and @kbd{M-# p}
30191 (@code{calc-embedded-previous}) commands move the cursor to the
30192 next or previous active embedded formula in the buffer. They
30193 can take positive or negative prefix arguments to move by several
30194 formulas. Note that these commands do not actually examine the
30195 text of the buffer looking for formulas; they only see formulas
30196 which have previously been activated in Embedded mode. In fact,
30197 @kbd{M-# n} and @kbd{M-# p} are a useful way to tell which
30198 embedded formulas are currently active. Also, note that these
30199 commands do not enable Embedded mode on the next or previous
30200 formula, they just move the cursor. (By the way, @kbd{M-# n} is
30201 not as awkward to type as it may seem, because @kbd{M-#} ignores
30202 Shift and Meta on the second keystroke: @kbd{M-# M-N} can be typed
30203 by holding down Shift and Meta and alternately typing two keys.)
30204
30205 @kindex M-# `
30206 @pindex calc-embedded-edit
30207 The @kbd{M-# `} (@code{calc-embedded-edit}) command edits the
30208 embedded formula at the current point as if by @kbd{`} (@code{calc-edit}).
30209 Embedded mode does not have to be enabled for this to work. Press
30210 @kbd{C-c C-c} to finish the edit, or @kbd{C-x k} to cancel.
30211
30212 @node Assignments in Embedded Mode, Mode Settings in Embedded Mode, More About Embedded Mode, Embedded Mode
30213 @section Assignments in Embedded Mode
30214
30215 @noindent
30216 The @samp{:=} (assignment) and @samp{=>} (``evaluates-to'') operators
30217 are especially useful in Embedded mode. They allow you to make
30218 a definition in one formula, then refer to that definition in
30219 other formulas embedded in the same buffer.
30220
30221 An embedded formula which is an assignment to a variable, as in
30222
30223 @example
30224 foo := 5
30225 @end example
30226
30227 @noindent
30228 records @expr{5} as the stored value of @code{foo} for the
30229 purposes of Embedded mode operations in the current buffer. It
30230 does @emph{not} actually store @expr{5} as the ``global'' value
30231 of @code{foo}, however. Regular Calc operations, and Embedded
30232 formulas in other buffers, will not see this assignment.
30233
30234 One way to use this assigned value is simply to create an
30235 Embedded formula elsewhere that refers to @code{foo}, and to press
30236 @kbd{=} in that formula. However, this permanently replaces the
30237 @code{foo} in the formula with its current value. More interesting
30238 is to use @samp{=>} elsewhere:
30239
30240 @example
30241 foo + 7 => 12
30242 @end example
30243
30244 @xref{Evaluates-To Operator}, for a general discussion of @samp{=>}.
30245
30246 If you move back and change the assignment to @code{foo}, any
30247 @samp{=>} formulas which refer to it are automatically updated.
30248
30249 @example
30250 foo := 17
30251
30252 foo + 7 => 24
30253 @end example
30254
30255 The obvious question then is, @emph{how} can one easily change the
30256 assignment to @code{foo}? If you simply select the formula in
30257 Embedded mode and type 17, the assignment itself will be replaced
30258 by the 17. The effect on the other formula will be that the
30259 variable @code{foo} becomes unassigned:
30260
30261 @example
30262 17
30263
30264 foo + 7 => foo + 7
30265 @end example
30266
30267 The right thing to do is first to use a selection command (@kbd{j 2}
30268 will do the trick) to select the righthand side of the assignment.
30269 Then, @kbd{17 @key{TAB} @key{DEL}} will swap the 17 into place (@pxref{Selecting
30270 Subformulas}, to see how this works).
30271
30272 @kindex M-# j
30273 @pindex calc-embedded-select
30274 The @kbd{M-# j} (@code{calc-embedded-select}) command provides an
30275 easy way to operate on assignments. It is just like @kbd{M-# e},
30276 except that if the enabled formula is an assignment, it uses
30277 @kbd{j 2} to select the righthand side. If the enabled formula
30278 is an evaluates-to, it uses @kbd{j 1} to select the lefthand side.
30279 A formula can also be a combination of both:
30280
30281 @example
30282 bar := foo + 3 => 20
30283 @end example
30284
30285 @noindent
30286 in which case @kbd{M-# j} will select the middle part (@samp{foo + 3}).
30287
30288 The formula is automatically deselected when you leave Embedded
30289 mode.
30290
30291 @kindex M-# u
30292 @kindex M-# =
30293 @pindex calc-embedded-update
30294 Another way to change the assignment to @code{foo} would simply be
30295 to edit the number using regular Emacs editing rather than Embedded
30296 mode. Then, we have to find a way to get Embedded mode to notice
30297 the change. The @kbd{M-# u} or @kbd{M-# =}
30298 (@code{calc-embedded-update-formula}) command is a convenient way
30299 to do this.
30300
30301 @example
30302 foo := 6
30303
30304 foo + 7 => 13
30305 @end example
30306
30307 Pressing @kbd{M-# u} is much like pressing @kbd{M-# e = M-# e}, that
30308 is, temporarily enabling Embedded mode for the formula under the
30309 cursor and then evaluating it with @kbd{=}. But @kbd{M-# u} does
30310 not actually use @kbd{M-# e}, and in fact another formula somewhere
30311 else can be enabled in Embedded mode while you use @kbd{M-# u} and
30312 that formula will not be disturbed.
30313
30314 With a numeric prefix argument, @kbd{M-# u} updates all active
30315 @samp{=>} formulas in the buffer. Formulas which have not yet
30316 been activated in Embedded mode, and formulas which do not have
30317 @samp{=>} as their top-level operator, are not affected by this.
30318 (This is useful only if you have used @kbd{m C}; see below.)
30319
30320 With a plain @kbd{C-u} prefix, @kbd{C-u M-# u} updates only in the
30321 region between mark and point rather than in the whole buffer.
30322
30323 @kbd{M-# u} is also a handy way to activate a formula, such as an
30324 @samp{=>} formula that has freshly been typed in or loaded from a
30325 file.
30326
30327 @kindex M-# a
30328 @pindex calc-embedded-activate
30329 The @kbd{M-# a} (@code{calc-embedded-activate}) command scans
30330 through the current buffer and activates all embedded formulas
30331 that contain @samp{:=} or @samp{=>} symbols. This does not mean
30332 that Embedded mode is actually turned on, but only that the
30333 formulas' positions are registered with Embedded mode so that
30334 the @samp{=>} values can be properly updated as assignments are
30335 changed.
30336
30337 It is a good idea to type @kbd{M-# a} right after loading a file
30338 that uses embedded @samp{=>} operators. Emacs includes a nifty
30339 ``buffer-local variables'' feature that you can use to do this
30340 automatically. The idea is to place near the end of your file
30341 a few lines that look like this:
30342
30343 @example
30344 --- Local Variables: ---
30345 --- eval:(calc-embedded-activate) ---
30346 --- End: ---
30347 @end example
30348
30349 @noindent
30350 where the leading and trailing @samp{---} can be replaced by
30351 any suitable strings (which must be the same on all three lines)
30352 or omitted altogether; in a @TeX{} or La@TeX{} file, @samp{%} would be a good
30353 leading string and no trailing string would be necessary. In a
30354 C program, @samp{/*} and @samp{*/} would be good leading and
30355 trailing strings.
30356
30357 When Emacs loads a file into memory, it checks for a Local Variables
30358 section like this one at the end of the file. If it finds this
30359 section, it does the specified things (in this case, running
30360 @kbd{M-# a} automatically) before editing of the file begins.
30361 The Local Variables section must be within 3000 characters of the
30362 end of the file for Emacs to find it, and it must be in the last
30363 page of the file if the file has any page separators.
30364 @xref{File Variables, , Local Variables in Files, emacs, the
30365 Emacs manual}.
30366
30367 Note that @kbd{M-# a} does not update the formulas it finds.
30368 To do this, type, say, @kbd{M-1 M-# u} after @w{@kbd{M-# a}}.
30369 Generally this should not be a problem, though, because the
30370 formulas will have been up-to-date already when the file was
30371 saved.
30372
30373 Normally, @kbd{M-# a} activates all the formulas it finds, but
30374 any previous active formulas remain active as well. With a
30375 positive numeric prefix argument, @kbd{M-# a} first deactivates
30376 all current active formulas, then actives the ones it finds in
30377 its scan of the buffer. With a negative prefix argument,
30378 @kbd{M-# a} simply deactivates all formulas.
30379
30380 Embedded mode has two symbols, @samp{Active} and @samp{~Active},
30381 which it puts next to the major mode name in a buffer's mode line.
30382 It puts @samp{Active} if it has reason to believe that all
30383 formulas in the buffer are active, because you have typed @kbd{M-# a}
30384 and Calc has not since had to deactivate any formulas (which can
30385 happen if Calc goes to update an @samp{=>} formula somewhere because
30386 a variable changed, and finds that the formula is no longer there
30387 due to some kind of editing outside of Embedded mode). Calc puts
30388 @samp{~Active} in the mode line if some, but probably not all,
30389 formulas in the buffer are active. This happens if you activate
30390 a few formulas one at a time but never use @kbd{M-# a}, or if you
30391 used @kbd{M-# a} but then Calc had to deactivate a formula
30392 because it lost track of it. If neither of these symbols appears
30393 in the mode line, no embedded formulas are active in the buffer
30394 (e.g., before Embedded mode has been used, or after a @kbd{M-- M-# a}).
30395
30396 Embedded formulas can refer to assignments both before and after them
30397 in the buffer. If there are several assignments to a variable, the
30398 nearest preceding assignment is used if there is one, otherwise the
30399 following assignment is used.
30400
30401 @example
30402 x => 1
30403
30404 x := 1
30405
30406 x => 1
30407
30408 x := 2
30409
30410 x => 2
30411 @end example
30412
30413 As well as simple variables, you can also assign to subscript
30414 expressions of the form @samp{@var{var}_@var{number}} (as in
30415 @code{x_0}), or @samp{@var{var}_@var{var}} (as in @code{x_max}).
30416 Assignments to other kinds of objects can be represented by Calc,
30417 but the automatic linkage between assignments and references works
30418 only for plain variables and these two kinds of subscript expressions.
30419
30420 If there are no assignments to a given variable, the global
30421 stored value for the variable is used (@pxref{Storing Variables}),
30422 or, if no value is stored, the variable is left in symbolic form.
30423 Note that global stored values will be lost when the file is saved
30424 and loaded in a later Emacs session, unless you have used the
30425 @kbd{s p} (@code{calc-permanent-variable}) command to save them;
30426 @pxref{Operations on Variables}.
30427
30428 The @kbd{m C} (@code{calc-auto-recompute}) command turns automatic
30429 recomputation of @samp{=>} forms on and off. If you turn automatic
30430 recomputation off, you will have to use @kbd{M-# u} to update these
30431 formulas manually after an assignment has been changed. If you
30432 plan to change several assignments at once, it may be more efficient
30433 to type @kbd{m C}, change all the assignments, then use @kbd{M-1 M-# u}
30434 to update the entire buffer afterwards. The @kbd{m C} command also
30435 controls @samp{=>} formulas on the stack; @pxref{Evaluates-To
30436 Operator}. When you turn automatic recomputation back on, the
30437 stack will be updated but the Embedded buffer will not; you must
30438 use @kbd{M-# u} to update the buffer by hand.
30439
30440 @node Mode Settings in Embedded Mode, Customizing Embedded Mode, Assignments in Embedded Mode, Embedded Mode
30441 @section Mode Settings in Embedded Mode
30442
30443 @noindent
30444 The mode settings can be changed while Calc is in embedded mode, but
30445 will revert to their original values when embedded mode is ended
30446 (except for the modes saved when the mode-recording mode is
30447 @code{Save}; see below).
30448
30449 Embedded mode has a rather complicated mechanism for handling mode
30450 settings in Embedded formulas. It is possible to put annotations
30451 in the file that specify mode settings either global to the entire
30452 file or local to a particular formula or formulas. In the latter
30453 case, different modes can be specified for use when a formula
30454 is the enabled Embedded mode formula.
30455
30456 When you give any mode-setting command, like @kbd{m f} (for Fraction
30457 mode) or @kbd{d s} (for scientific notation), Embedded mode adds
30458 a line like the following one to the file just before the opening
30459 delimiter of the formula.
30460
30461 @example
30462 % [calc-mode: fractions: t]
30463 % [calc-mode: float-format: (sci 0)]
30464 @end example
30465
30466 When Calc interprets an embedded formula, it scans the text before
30467 the formula for mode-setting annotations like these and sets the
30468 Calc buffer to match these modes. Modes not explicitly described
30469 in the file are not changed. Calc scans all the way to the top of
30470 the file, or up to a line of the form
30471
30472 @example
30473 % [calc-defaults]
30474 @end example
30475
30476 @noindent
30477 which you can insert at strategic places in the file if this backward
30478 scan is getting too slow, or just to provide a barrier between one
30479 ``zone'' of mode settings and another.
30480
30481 If the file contains several annotations for the same mode, the
30482 closest one before the formula is used. Annotations after the
30483 formula are never used (except for global annotations, described
30484 below).
30485
30486 The scan does not look for the leading @samp{% }, only for the
30487 square brackets and the text they enclose. You can edit the mode
30488 annotations to a style that works better in context if you wish.
30489 @xref{Customizing Embedded Mode}, to see how to change the style
30490 that Calc uses when it generates the annotations. You can write
30491 mode annotations into the file yourself if you know the syntax;
30492 the easiest way to find the syntax for a given mode is to let
30493 Calc write the annotation for it once and see what it does.
30494
30495 If you give a mode-changing command for a mode that already has
30496 a suitable annotation just above the current formula, Calc will
30497 modify that annotation rather than generating a new, conflicting
30498 one.
30499
30500 Mode annotations have three parts, separated by colons. (Spaces
30501 after the colons are optional.) The first identifies the kind
30502 of mode setting, the second is a name for the mode itself, and
30503 the third is the value in the form of a Lisp symbol, number,
30504 or list. Annotations with unrecognizable text in the first or
30505 second parts are ignored. The third part is not checked to make
30506 sure the value is of a valid type or range; if you write an
30507 annotation by hand, be sure to give a proper value or results
30508 will be unpredictable. Mode-setting annotations are case-sensitive.
30509
30510 While Embedded mode is enabled, the word @code{Local} appears in
30511 the mode line. This is to show that mode setting commands generate
30512 annotations that are ``local'' to the current formula or set of
30513 formulas. The @kbd{m R} (@code{calc-mode-record-mode}) command
30514 causes Calc to generate different kinds of annotations. Pressing
30515 @kbd{m R} repeatedly cycles through the possible modes.
30516
30517 @code{LocEdit} and @code{LocPerm} modes generate annotations
30518 that look like this, respectively:
30519
30520 @example
30521 % [calc-edit-mode: float-format: (sci 0)]
30522 % [calc-perm-mode: float-format: (sci 5)]
30523 @end example
30524
30525 The first kind of annotation will be used only while a formula
30526 is enabled in Embedded mode. The second kind will be used only
30527 when the formula is @emph{not} enabled. (Whether the formula
30528 is ``active'' or not, i.e., whether Calc has seen this formula
30529 yet, is not relevant here.)
30530
30531 @code{Global} mode generates an annotation like this at the end
30532 of the file:
30533
30534 @example
30535 % [calc-global-mode: fractions t]
30536 @end example
30537
30538 Global mode annotations affect all formulas throughout the file,
30539 and may appear anywhere in the file. This allows you to tuck your
30540 mode annotations somewhere out of the way, say, on a new page of
30541 the file, as long as those mode settings are suitable for all
30542 formulas in the file.
30543
30544 Enabling a formula with @kbd{M-# e} causes a fresh scan for local
30545 mode annotations; you will have to use this after adding annotations
30546 above a formula by hand to get the formula to notice them. Updating
30547 a formula with @kbd{M-# u} will also re-scan the local modes, but
30548 global modes are only re-scanned by @kbd{M-# a}.
30549
30550 Another way that modes can get out of date is if you add a local
30551 mode annotation to a formula that has another formula after it.
30552 In this example, we have used the @kbd{d s} command while the
30553 first of the two embedded formulas is active. But the second
30554 formula has not changed its style to match, even though by the
30555 rules of reading annotations the @samp{(sci 0)} applies to it, too.
30556
30557 @example
30558 % [calc-mode: float-format: (sci 0)]
30559 1.23e2
30560
30561 456.
30562 @end example
30563
30564 We would have to go down to the other formula and press @kbd{M-# u}
30565 on it in order to get it to notice the new annotation.
30566
30567 Two more mode-recording modes selectable by @kbd{m R} are available
30568 which are also available outside of Embedded mode.
30569 (@pxref{General Mode Commands}.) They are @code{Save}, in which mode
30570 settings are recorded permanently in your Calc init file (the file given
30571 by the variable @code{calc-settings-file}, typically @file{~/.calc.el})
30572 rather than by annotating the current document, and no-recording
30573 mode (where there is no symbol like @code{Save} or @code{Local} in
30574 the mode line), in which mode-changing commands do not leave any
30575 annotations at all.
30576
30577 When Embedded mode is not enabled, mode-recording modes except
30578 for @code{Save} have no effect.
30579
30580 @node Customizing Embedded Mode, , Mode Settings in Embedded Mode, Embedded Mode
30581 @section Customizing Embedded Mode
30582
30583 @noindent
30584 You can modify Embedded mode's behavior by setting various Lisp
30585 variables described here. Use @kbd{M-x set-variable} or
30586 @kbd{M-x edit-options} to adjust a variable on the fly, or
30587 put a suitable @code{setq} statement in your Calc init file (or
30588 @file{~/.emacs}) to set a variable permanently. (Another possibility would
30589 be to use a file-local variable annotation at the end of the
30590 file; @pxref{File Variables, , Local Variables in Files, emacs, the
30591 Emacs manual}.)
30592
30593 While none of these variables will be buffer-local by default, you
30594 can make any of them local to any Embedded mode buffer. (Their
30595 values in the @samp{*Calculator*} buffer are never used.)
30596
30597 @vindex calc-embedded-open-formula
30598 The @code{calc-embedded-open-formula} variable holds a regular
30599 expression for the opening delimiter of a formula. @xref{Regexp Search,
30600 , Regular Expression Search, emacs, the Emacs manual}, to see
30601 how regular expressions work. Basically, a regular expression is a
30602 pattern that Calc can search for. A regular expression that considers
30603 blank lines, @samp{$}, and @samp{$$} to be opening delimiters is
30604 @code{"\\`\\|^\n\\|\\$\\$?"}. Just in case the meaning of this
30605 regular expression is not completely plain, let's go through it
30606 in detail.
30607
30608 The surrounding @samp{" "} marks quote the text between them as a
30609 Lisp string. If you left them off, @code{set-variable} or
30610 @code{edit-options} would try to read the regular expression as a
30611 Lisp program.
30612
30613 The most obvious property of this regular expression is that it
30614 contains indecently many backslashes. There are actually two levels
30615 of backslash usage going on here. First, when Lisp reads a quoted
30616 string, all pairs of characters beginning with a backslash are
30617 interpreted as special characters. Here, @code{\n} changes to a
30618 new-line character, and @code{\\} changes to a single backslash.
30619 So the actual regular expression seen by Calc is
30620 @samp{\`\|^ @r{(newline)} \|\$\$?}.
30621
30622 Regular expressions also consider pairs beginning with backslash
30623 to have special meanings. Sometimes the backslash is used to quote
30624 a character that otherwise would have a special meaning in a regular
30625 expression, like @samp{$}, which normally means ``end-of-line,''
30626 or @samp{?}, which means that the preceding item is optional. So
30627 @samp{\$\$?} matches either one or two dollar signs.
30628
30629 The other codes in this regular expression are @samp{^}, which matches
30630 ``beginning-of-line,'' @samp{\|}, which means ``or,'' and @samp{\`},
30631 which matches ``beginning-of-buffer.'' So the whole pattern means
30632 that a formula begins at the beginning of the buffer, or on a newline
30633 that occurs at the beginning of a line (i.e., a blank line), or at
30634 one or two dollar signs.
30635
30636 The default value of @code{calc-embedded-open-formula} looks just
30637 like this example, with several more alternatives added on to
30638 recognize various other common kinds of delimiters.
30639
30640 By the way, the reason to use @samp{^\n} rather than @samp{^$}
30641 or @samp{\n\n}, which also would appear to match blank lines,
30642 is that the former expression actually ``consumes'' only one
30643 newline character as @emph{part of} the delimiter, whereas the
30644 latter expressions consume zero or two newlines, respectively.
30645 The former choice gives the most natural behavior when Calc
30646 must operate on a whole formula including its delimiters.
30647
30648 See the Emacs manual for complete details on regular expressions.
30649 But just for your convenience, here is a list of all characters
30650 which must be quoted with backslash (like @samp{\$}) to avoid
30651 some special interpretation: @samp{. * + ? [ ] ^ $ \}. (Note
30652 the backslash in this list; for example, to match @samp{\[} you
30653 must use @code{"\\\\\\["}. An exercise for the reader is to
30654 account for each of these six backslashes!)
30655
30656 @vindex calc-embedded-close-formula
30657 The @code{calc-embedded-close-formula} variable holds a regular
30658 expression for the closing delimiter of a formula. A closing
30659 regular expression to match the above example would be
30660 @code{"\\'\\|\n$\\|\\$\\$?"}. This is almost the same as the
30661 other one, except it now uses @samp{\'} (``end-of-buffer'') and
30662 @samp{\n$} (newline occurring at end of line, yet another way
30663 of describing a blank line that is more appropriate for this
30664 case).
30665
30666 @vindex calc-embedded-open-word
30667 @vindex calc-embedded-close-word
30668 The @code{calc-embedded-open-word} and @code{calc-embedded-close-word}
30669 variables are similar expressions used when you type @kbd{M-# w}
30670 instead of @kbd{M-# e} to enable Embedded mode.
30671
30672 @vindex calc-embedded-open-plain
30673 The @code{calc-embedded-open-plain} variable is a string which
30674 begins a ``plain'' formula written in front of the formatted
30675 formula when @kbd{d p} mode is turned on. Note that this is an
30676 actual string, not a regular expression, because Calc must be able
30677 to write this string into a buffer as well as to recognize it.
30678 The default string is @code{"%%% "} (note the trailing space).
30679
30680 @vindex calc-embedded-close-plain
30681 The @code{calc-embedded-close-plain} variable is a string which
30682 ends a ``plain'' formula. The default is @code{" %%%\n"}. Without
30683 the trailing newline here, the first line of a Big mode formula
30684 that followed might be shifted over with respect to the other lines.
30685
30686 @vindex calc-embedded-open-new-formula
30687 The @code{calc-embedded-open-new-formula} variable is a string
30688 which is inserted at the front of a new formula when you type
30689 @kbd{M-# f}. Its default value is @code{"\n\n"}. If this
30690 string begins with a newline character and the @kbd{M-# f} is
30691 typed at the beginning of a line, @kbd{M-# f} will skip this
30692 first newline to avoid introducing unnecessary blank lines in
30693 the file.
30694
30695 @vindex calc-embedded-close-new-formula
30696 The @code{calc-embedded-close-new-formula} variable is the corresponding
30697 string which is inserted at the end of a new formula. Its default
30698 value is also @code{"\n\n"}. The final newline is omitted by
30699 @w{@kbd{M-# f}} if typed at the end of a line. (It follows that if
30700 @kbd{M-# f} is typed on a blank line, both a leading opening
30701 newline and a trailing closing newline are omitted.)
30702
30703 @vindex calc-embedded-announce-formula
30704 The @code{calc-embedded-announce-formula} variable is a regular
30705 expression which is sure to be followed by an embedded formula.
30706 The @kbd{M-# a} command searches for this pattern as well as for
30707 @samp{=>} and @samp{:=} operators. Note that @kbd{M-# a} will
30708 not activate just anything surrounded by formula delimiters; after
30709 all, blank lines are considered formula delimiters by default!
30710 But if your language includes a delimiter which can only occur
30711 actually in front of a formula, you can take advantage of it here.
30712 The default pattern is @code{"%Embed\n\\(% .*\n\\)*"}, which
30713 checks for @samp{%Embed} followed by any number of lines beginning
30714 with @samp{%} and a space. This last is important to make Calc
30715 consider mode annotations part of the pattern, so that the formula's
30716 opening delimiter really is sure to follow the pattern.
30717
30718 @vindex calc-embedded-open-mode
30719 The @code{calc-embedded-open-mode} variable is a string (not a
30720 regular expression) which should precede a mode annotation.
30721 Calc never scans for this string; Calc always looks for the
30722 annotation itself. But this is the string that is inserted before
30723 the opening bracket when Calc adds an annotation on its own.
30724 The default is @code{"% "}.
30725
30726 @vindex calc-embedded-close-mode
30727 The @code{calc-embedded-close-mode} variable is a string which
30728 follows a mode annotation written by Calc. Its default value
30729 is simply a newline, @code{"\n"}. If you change this, it is a
30730 good idea still to end with a newline so that mode annotations
30731 will appear on lines by themselves.
30732
30733 @node Programming, Installation, Embedded Mode, Top
30734 @chapter Programming
30735
30736 @noindent
30737 There are several ways to ``program'' the Emacs Calculator, depending
30738 on the nature of the problem you need to solve.
30739
30740 @enumerate
30741 @item
30742 @dfn{Keyboard macros} allow you to record a sequence of keystrokes
30743 and play them back at a later time. This is just the standard Emacs
30744 keyboard macro mechanism, dressed up with a few more features such
30745 as loops and conditionals.
30746
30747 @item
30748 @dfn{Algebraic definitions} allow you to use any formula to define a
30749 new function. This function can then be used in algebraic formulas or
30750 as an interactive command.
30751
30752 @item
30753 @dfn{Rewrite rules} are discussed in the section on algebra commands.
30754 @xref{Rewrite Rules}. If you put your rewrite rules in the variable
30755 @code{EvalRules}, they will be applied automatically to all Calc
30756 results in just the same way as an internal ``rule'' is applied to
30757 evaluate @samp{sqrt(9)} to 3 and so on. @xref{Automatic Rewrites}.
30758
30759 @item
30760 @dfn{Lisp} is the programming language that Calc (and most of Emacs)
30761 is written in. If the above techniques aren't powerful enough, you
30762 can write Lisp functions to do anything that built-in Calc commands
30763 can do. Lisp code is also somewhat faster than keyboard macros or
30764 rewrite rules.
30765 @end enumerate
30766
30767 @kindex z
30768 Programming features are available through the @kbd{z} and @kbd{Z}
30769 prefix keys. New commands that you define are two-key sequences
30770 beginning with @kbd{z}. Commands for managing these definitions
30771 use the shift-@kbd{Z} prefix. (The @kbd{Z T} (@code{calc-timing})
30772 command is described elsewhere; @pxref{Troubleshooting Commands}.
30773 The @kbd{Z C} (@code{calc-user-define-composition}) command is also
30774 described elsewhere; @pxref{User-Defined Compositions}.)
30775
30776 @menu
30777 * Creating User Keys::
30778 * Keyboard Macros::
30779 * Invocation Macros::
30780 * Algebraic Definitions::
30781 * Lisp Definitions::
30782 @end menu
30783
30784 @node Creating User Keys, Keyboard Macros, Programming, Programming
30785 @section Creating User Keys
30786
30787 @noindent
30788 @kindex Z D
30789 @pindex calc-user-define
30790 Any Calculator command may be bound to a key using the @kbd{Z D}
30791 (@code{calc-user-define}) command. Actually, it is bound to a two-key
30792 sequence beginning with the lower-case @kbd{z} prefix.
30793
30794 The @kbd{Z D} command first prompts for the key to define. For example,
30795 press @kbd{Z D a} to define the new key sequence @kbd{z a}. You are then
30796 prompted for the name of the Calculator command that this key should
30797 run. For example, the @code{calc-sincos} command is not normally
30798 available on a key. Typing @kbd{Z D s sincos @key{RET}} programs the
30799 @kbd{z s} key sequence to run @code{calc-sincos}. This definition will remain
30800 in effect for the rest of this Emacs session, or until you redefine
30801 @kbd{z s} to be something else.
30802
30803 You can actually bind any Emacs command to a @kbd{z} key sequence by
30804 backspacing over the @samp{calc-} when you are prompted for the command name.
30805
30806 As with any other prefix key, you can type @kbd{z ?} to see a list of
30807 all the two-key sequences you have defined that start with @kbd{z}.
30808 Initially, no @kbd{z} sequences (except @kbd{z ?} itself) are defined.
30809
30810 User keys are typically letters, but may in fact be any key.
30811 (@key{META}-keys are not permitted, nor are a terminal's special
30812 function keys which generate multi-character sequences when pressed.)
30813 You can define different commands on the shifted and unshifted versions
30814 of a letter if you wish.
30815
30816 @kindex Z U
30817 @pindex calc-user-undefine
30818 The @kbd{Z U} (@code{calc-user-undefine}) command unbinds a user key.
30819 For example, the key sequence @kbd{Z U s} will undefine the @code{sincos}
30820 key we defined above.
30821
30822 @kindex Z P
30823 @pindex calc-user-define-permanent
30824 @cindex Storing user definitions
30825 @cindex Permanent user definitions
30826 @cindex Calc init file, user-defined commands
30827 The @kbd{Z P} (@code{calc-user-define-permanent}) command makes a key
30828 binding permanent so that it will remain in effect even in future Emacs
30829 sessions. (It does this by adding a suitable bit of Lisp code into
30830 your Calc init file; that is, the file given by the variable
30831 @code{calc-settings-file}, typically @file{~/.calc.el}.) For example,
30832 @kbd{Z P s} would register our @code{sincos} command permanently. If
30833 you later wish to unregister this command you must edit your Calc init
30834 file by hand. (@xref{General Mode Commands}, for a way to tell Calc to
30835 use a different file for the Calc init file.)
30836
30837 The @kbd{Z P} command also saves the user definition, if any, for the
30838 command bound to the key. After @kbd{Z F} and @kbd{Z C}, a given user
30839 key could invoke a command, which in turn calls an algebraic function,
30840 which might have one or more special display formats. A single @kbd{Z P}
30841 command will save all of these definitions.
30842 To save an algebraic function, type @kbd{'} (the apostrophe)
30843 when prompted for a key, and type the function name. To save a command
30844 without its key binding, type @kbd{M-x} and enter a function name. (The
30845 @samp{calc-} prefix will automatically be inserted for you.)
30846 (If the command you give implies a function, the function will be saved,
30847 and if the function has any display formats, those will be saved, but
30848 not the other way around: Saving a function will not save any commands
30849 or key bindings associated with the function.)
30850
30851 @kindex Z E
30852 @pindex calc-user-define-edit
30853 @cindex Editing user definitions
30854 The @kbd{Z E} (@code{calc-user-define-edit}) command edits the definition
30855 of a user key. This works for keys that have been defined by either
30856 keyboard macros or formulas; further details are contained in the relevant
30857 following sections.
30858
30859 @node Keyboard Macros, Invocation Macros, Creating User Keys, Programming
30860 @section Programming with Keyboard Macros
30861
30862 @noindent
30863 @kindex X
30864 @cindex Programming with keyboard macros
30865 @cindex Keyboard macros
30866 The easiest way to ``program'' the Emacs Calculator is to use standard
30867 keyboard macros. Press @w{@kbd{C-x (}} to begin recording a macro. From
30868 this point on, keystrokes you type will be saved away as well as
30869 performing their usual functions. Press @kbd{C-x )} to end recording.
30870 Press shift-@kbd{X} (or the standard Emacs key sequence @kbd{C-x e}) to
30871 execute your keyboard macro by replaying the recorded keystrokes.
30872 @xref{Keyboard Macros, , , emacs, the Emacs Manual}, for further
30873 information.
30874
30875 When you use @kbd{X} to invoke a keyboard macro, the entire macro is
30876 treated as a single command by the undo and trail features. The stack
30877 display buffer is not updated during macro execution, but is instead
30878 fixed up once the macro completes. Thus, commands defined with keyboard
30879 macros are convenient and efficient. The @kbd{C-x e} command, on the
30880 other hand, invokes the keyboard macro with no special treatment: Each
30881 command in the macro will record its own undo information and trail entry,
30882 and update the stack buffer accordingly. If your macro uses features
30883 outside of Calc's control to operate on the contents of the Calc stack
30884 buffer, or if it includes Undo, Redo, or last-arguments commands, you
30885 must use @kbd{C-x e} to make sure the buffer and undo list are up-to-date
30886 at all times. You could also consider using @kbd{K} (@code{calc-keep-args})
30887 instead of @kbd{M-@key{RET}} (@code{calc-last-args}).
30888
30889 Calc extends the standard Emacs keyboard macros in several ways.
30890 Keyboard macros can be used to create user-defined commands. Keyboard
30891 macros can include conditional and iteration structures, somewhat
30892 analogous to those provided by a traditional programmable calculator.
30893
30894 @menu
30895 * Naming Keyboard Macros::
30896 * Conditionals in Macros::
30897 * Loops in Macros::
30898 * Local Values in Macros::
30899 * Queries in Macros::
30900 @end menu
30901
30902 @node Naming Keyboard Macros, Conditionals in Macros, Keyboard Macros, Keyboard Macros
30903 @subsection Naming Keyboard Macros
30904
30905 @noindent
30906 @kindex Z K
30907 @pindex calc-user-define-kbd-macro
30908 Once you have defined a keyboard macro, you can bind it to a @kbd{z}
30909 key sequence with the @kbd{Z K} (@code{calc-user-define-kbd-macro}) command.
30910 This command prompts first for a key, then for a command name. For
30911 example, if you type @kbd{C-x ( n @key{TAB} n @key{TAB} C-x )} you will
30912 define a keyboard macro which negates the top two numbers on the stack
30913 (@key{TAB} swaps the top two stack elements). Now you can type
30914 @kbd{Z K n @key{RET}} to define this keyboard macro onto the @kbd{z n} key
30915 sequence. The default command name (if you answer the second prompt with
30916 just the @key{RET} key as in this example) will be something like
30917 @samp{calc-User-n}. The keyboard macro will now be available as both
30918 @kbd{z n} and @kbd{M-x calc-User-n}. You can backspace and enter a more
30919 descriptive command name if you wish.
30920
30921 Macros defined by @kbd{Z K} act like single commands; they are executed
30922 in the same way as by the @kbd{X} key. If you wish to define the macro
30923 as a standard no-frills Emacs macro (to be executed as if by @kbd{C-x e}),
30924 give a negative prefix argument to @kbd{Z K}.
30925
30926 Once you have bound your keyboard macro to a key, you can use
30927 @kbd{Z P} to register it permanently with Emacs. @xref{Creating User Keys}.
30928
30929 @cindex Keyboard macros, editing
30930 The @kbd{Z E} (@code{calc-user-define-edit}) command on a key that has
30931 been defined by a keyboard macro tries to use the @code{edmacro} package
30932 edit the macro. Type @kbd{C-c C-c} to finish editing and update
30933 the definition stored on the key, or, to cancel the edit, kill the
30934 buffer with @kbd{C-x k}.
30935 The special characters @code{RET}, @code{LFD}, @code{TAB}, @code{SPC},
30936 @code{DEL}, and @code{NUL} must be entered as these three character
30937 sequences, written in all uppercase, as must the prefixes @code{C-} and
30938 @code{M-}. Spaces and line breaks are ignored. Other characters are
30939 copied verbatim into the keyboard macro. Basically, the notation is the
30940 same as is used in all of this manual's examples, except that the manual
30941 takes some liberties with spaces: When we say @kbd{' [1 2 3] @key{RET}},
30942 we take it for granted that it is clear we really mean
30943 @kbd{' [1 @key{SPC} 2 @key{SPC} 3] @key{RET}}.
30944
30945 @kindex M-# m
30946 @pindex read-kbd-macro
30947 The @kbd{M-# m} (@code{read-kbd-macro}) command reads an Emacs ``region''
30948 of spelled-out keystrokes and defines it as the current keyboard macro.
30949 It is a convenient way to define a keyboard macro that has been stored
30950 in a file, or to define a macro without executing it at the same time.
30951
30952 @node Conditionals in Macros, Loops in Macros, Naming Keyboard Macros, Keyboard Macros
30953 @subsection Conditionals in Keyboard Macros
30954
30955 @noindent
30956 @kindex Z [
30957 @kindex Z ]
30958 @pindex calc-kbd-if
30959 @pindex calc-kbd-else
30960 @pindex calc-kbd-else-if
30961 @pindex calc-kbd-end-if
30962 @cindex Conditional structures
30963 The @kbd{Z [} (@code{calc-kbd-if}) and @kbd{Z ]} (@code{calc-kbd-end-if})
30964 commands allow you to put simple tests in a keyboard macro. When Calc
30965 sees the @kbd{Z [}, it pops an object from the stack and, if the object is
30966 a non-zero value, continues executing keystrokes. But if the object is
30967 zero, or if it is not provably nonzero, Calc skips ahead to the matching
30968 @kbd{Z ]} keystroke. @xref{Logical Operations}, for a set of commands for
30969 performing tests which conveniently produce 1 for true and 0 for false.
30970
30971 For example, @kbd{@key{RET} 0 a < Z [ n Z ]} implements an absolute-value
30972 function in the form of a keyboard macro. This macro duplicates the
30973 number on the top of the stack, pushes zero and compares using @kbd{a <}
30974 (@code{calc-less-than}), then, if the number was less than zero,
30975 executes @kbd{n} (@code{calc-change-sign}). Otherwise, the change-sign
30976 command is skipped.
30977
30978 To program this macro, type @kbd{C-x (}, type the above sequence of
30979 keystrokes, then type @kbd{C-x )}. Note that the keystrokes will be
30980 executed while you are making the definition as well as when you later
30981 re-execute the macro by typing @kbd{X}. Thus you should make sure a
30982 suitable number is on the stack before defining the macro so that you
30983 don't get a stack-underflow error during the definition process.
30984
30985 Conditionals can be nested arbitrarily. However, there should be exactly
30986 one @kbd{Z ]} for each @kbd{Z [} in a keyboard macro.
30987
30988 @kindex Z :
30989 The @kbd{Z :} (@code{calc-kbd-else}) command allows you to choose between
30990 two keystroke sequences. The general format is @kbd{@var{cond} Z [
30991 @var{then-part} Z : @var{else-part} Z ]}. If @var{cond} is true
30992 (i.e., if the top of stack contains a non-zero number after @var{cond}
30993 has been executed), the @var{then-part} will be executed and the
30994 @var{else-part} will be skipped. Otherwise, the @var{then-part} will
30995 be skipped and the @var{else-part} will be executed.
30996
30997 @kindex Z |
30998 The @kbd{Z |} (@code{calc-kbd-else-if}) command allows you to choose
30999 between any number of alternatives. For example,
31000 @kbd{@var{cond1} Z [ @var{part1} Z : @var{cond2} Z | @var{part2} Z :
31001 @var{part3} Z ]} will execute @var{part1} if @var{cond1} is true,
31002 otherwise it will execute @var{part2} if @var{cond2} is true, otherwise
31003 it will execute @var{part3}.
31004
31005 More precisely, @kbd{Z [} pops a number and conditionally skips to the
31006 next matching @kbd{Z :} or @kbd{Z ]} key. @w{@kbd{Z ]}} has no effect when
31007 actually executed. @kbd{Z :} skips to the next matching @kbd{Z ]}.
31008 @kbd{Z |} pops a number and conditionally skips to the next matching
31009 @kbd{Z :} or @kbd{Z ]}; thus, @kbd{Z [} and @kbd{Z |} are functionally
31010 equivalent except that @kbd{Z [} participates in nesting but @kbd{Z |}
31011 does not.
31012
31013 Calc's conditional and looping constructs work by scanning the
31014 keyboard macro for occurrences of character sequences like @samp{Z:}
31015 and @samp{Z]}. One side-effect of this is that if you use these
31016 constructs you must be careful that these character pairs do not
31017 occur by accident in other parts of the macros. Since Calc rarely
31018 uses shift-@kbd{Z} for any purpose except as a prefix character, this
31019 is not likely to be a problem. Another side-effect is that it will
31020 not work to define your own custom key bindings for these commands.
31021 Only the standard shift-@kbd{Z} bindings will work correctly.
31022
31023 @kindex Z C-g
31024 If Calc gets stuck while skipping characters during the definition of a
31025 macro, type @kbd{Z C-g} to cancel the definition. (Typing plain @kbd{C-g}
31026 actually adds a @kbd{C-g} keystroke to the macro.)
31027
31028 @node Loops in Macros, Local Values in Macros, Conditionals in Macros, Keyboard Macros
31029 @subsection Loops in Keyboard Macros
31030
31031 @noindent
31032 @kindex Z <
31033 @kindex Z >
31034 @pindex calc-kbd-repeat
31035 @pindex calc-kbd-end-repeat
31036 @cindex Looping structures
31037 @cindex Iterative structures
31038 The @kbd{Z <} (@code{calc-kbd-repeat}) and @kbd{Z >}
31039 (@code{calc-kbd-end-repeat}) commands pop a number from the stack,
31040 which must be an integer, then repeat the keystrokes between the brackets
31041 the specified number of times. If the integer is zero or negative, the
31042 body is skipped altogether. For example, @kbd{1 @key{TAB} Z < 2 * Z >}
31043 computes two to a nonnegative integer power. First, we push 1 on the
31044 stack and then swap the integer argument back to the top. The @kbd{Z <}
31045 pops that argument leaving the 1 back on top of the stack. Then, we
31046 repeat a multiply-by-two step however many times.
31047
31048 Once again, the keyboard macro is executed as it is being entered.
31049 In this case it is especially important to set up reasonable initial
31050 conditions before making the definition: Suppose the integer 1000 just
31051 happened to be sitting on the stack before we typed the above definition!
31052 Another approach is to enter a harmless dummy definition for the macro,
31053 then go back and edit in the real one with a @kbd{Z E} command. Yet
31054 another approach is to type the macro as written-out keystroke names
31055 in a buffer, then use @kbd{M-# m} (@code{read-kbd-macro}) to read the
31056 macro.
31057
31058 @kindex Z /
31059 @pindex calc-break
31060 The @kbd{Z /} (@code{calc-kbd-break}) command allows you to break out
31061 of a keyboard macro loop prematurely. It pops an object from the stack;
31062 if that object is true (a non-zero number), control jumps out of the
31063 innermost enclosing @kbd{Z <} @dots{} @kbd{Z >} loop and continues
31064 after the @kbd{Z >}. If the object is false, the @kbd{Z /} has no
31065 effect. Thus @kbd{@var{cond} Z /} is similar to @samp{if (@var{cond}) break;}
31066 in the C language.
31067
31068 @kindex Z (
31069 @kindex Z )
31070 @pindex calc-kbd-for
31071 @pindex calc-kbd-end-for
31072 The @kbd{Z (} (@code{calc-kbd-for}) and @kbd{Z )} (@code{calc-kbd-end-for})
31073 commands are similar to @kbd{Z <} and @kbd{Z >}, except that they make the
31074 value of the counter available inside the loop. The general layout is
31075 @kbd{@var{init} @var{final} Z ( @var{body} @var{step} Z )}. The @kbd{Z (}
31076 command pops initial and final values from the stack. It then creates
31077 a temporary internal counter and initializes it with the value @var{init}.
31078 The @kbd{Z (} command then repeatedly pushes the counter value onto the
31079 stack and executes @var{body} and @var{step}, adding @var{step} to the
31080 counter each time until the loop finishes.
31081
31082 @cindex Summations (by keyboard macros)
31083 By default, the loop finishes when the counter becomes greater than (or
31084 less than) @var{final}, assuming @var{initial} is less than (greater
31085 than) @var{final}. If @var{initial} is equal to @var{final}, the body
31086 executes exactly once. The body of the loop always executes at least
31087 once. For example, @kbd{0 1 10 Z ( 2 ^ + 1 Z )} computes the sum of the
31088 squares of the integers from 1 to 10, in steps of 1.
31089
31090 If you give a numeric prefix argument of 1 to @kbd{Z (}, the loop is
31091 forced to use upward-counting conventions. In this case, if @var{initial}
31092 is greater than @var{final} the body will not be executed at all.
31093 Note that @var{step} may still be negative in this loop; the prefix
31094 argument merely constrains the loop-finished test. Likewise, a prefix
31095 argument of @mathit{-1} forces downward-counting conventions.
31096
31097 @kindex Z @{
31098 @kindex Z @}
31099 @pindex calc-kbd-loop
31100 @pindex calc-kbd-end-loop
31101 The @kbd{Z @{} (@code{calc-kbd-loop}) and @kbd{Z @}}
31102 (@code{calc-kbd-end-loop}) commands are similar to @kbd{Z <} and
31103 @kbd{Z >}, except that they do not pop a count from the stack---they
31104 effectively create an infinite loop. Every @kbd{Z @{} @dots{} @kbd{Z @}}
31105 loop ought to include at least one @kbd{Z /} to make sure the loop
31106 doesn't run forever. (If any error message occurs which causes Emacs
31107 to beep, the keyboard macro will also be halted; this is a standard
31108 feature of Emacs. You can also generally press @kbd{C-g} to halt a
31109 running keyboard macro, although not all versions of Unix support
31110 this feature.)
31111
31112 The conditional and looping constructs are not actually tied to
31113 keyboard macros, but they are most often used in that context.
31114 For example, the keystrokes @kbd{10 Z < 23 @key{RET} Z >} push
31115 ten copies of 23 onto the stack. This can be typed ``live'' just
31116 as easily as in a macro definition.
31117
31118 @xref{Conditionals in Macros}, for some additional notes about
31119 conditional and looping commands.
31120
31121 @node Local Values in Macros, Queries in Macros, Loops in Macros, Keyboard Macros
31122 @subsection Local Values in Macros
31123
31124 @noindent
31125 @cindex Local variables
31126 @cindex Restoring saved modes
31127 Keyboard macros sometimes want to operate under known conditions
31128 without affecting surrounding conditions. For example, a keyboard
31129 macro may wish to turn on Fraction mode, or set a particular
31130 precision, independent of the user's normal setting for those
31131 modes.
31132
31133 @kindex Z `
31134 @kindex Z '
31135 @pindex calc-kbd-push
31136 @pindex calc-kbd-pop
31137 Macros also sometimes need to use local variables. Assignments to
31138 local variables inside the macro should not affect any variables
31139 outside the macro. The @kbd{Z `} (@code{calc-kbd-push}) and @kbd{Z '}
31140 (@code{calc-kbd-pop}) commands give you both of these capabilities.
31141
31142 When you type @kbd{Z `} (with a backquote or accent grave character),
31143 the values of various mode settings are saved away. The ten ``quick''
31144 variables @code{q0} through @code{q9} are also saved. When
31145 you type @w{@kbd{Z '}} (with an apostrophe), these values are restored.
31146 Pairs of @kbd{Z `} and @kbd{Z '} commands may be nested.
31147
31148 If a keyboard macro halts due to an error in between a @kbd{Z `} and
31149 a @kbd{Z '}, the saved values will be restored correctly even though
31150 the macro never reaches the @kbd{Z '} command. Thus you can use
31151 @kbd{Z `} and @kbd{Z '} without having to worry about what happens
31152 in exceptional conditions.
31153
31154 If you type @kbd{Z `} ``live'' (not in a keyboard macro), Calc puts
31155 you into a ``recursive edit.'' You can tell you are in a recursive
31156 edit because there will be extra square brackets in the mode line,
31157 as in @samp{[(Calculator)]}. These brackets will go away when you
31158 type the matching @kbd{Z '} command. The modes and quick variables
31159 will be saved and restored in just the same way as if actual keyboard
31160 macros were involved.
31161
31162 The modes saved by @kbd{Z `} and @kbd{Z '} are the current precision
31163 and binary word size, the angular mode (Deg, Rad, or HMS), the
31164 simplification mode, Algebraic mode, Symbolic mode, Infinite mode,
31165 Matrix or Scalar mode, Fraction mode, and the current complex mode
31166 (Polar or Rectangular). The ten ``quick'' variables' values (or lack
31167 thereof) are also saved.
31168
31169 Most mode-setting commands act as toggles, but with a numeric prefix
31170 they force the mode either on (positive prefix) or off (negative
31171 or zero prefix). Since you don't know what the environment might
31172 be when you invoke your macro, it's best to use prefix arguments
31173 for all mode-setting commands inside the macro.
31174
31175 In fact, @kbd{C-u Z `} is like @kbd{Z `} except that it sets the modes
31176 listed above to their default values. As usual, the matching @kbd{Z '}
31177 will restore the modes to their settings from before the @kbd{C-u Z `}.
31178 Also, @w{@kbd{Z `}} with a negative prefix argument resets the algebraic mode
31179 to its default (off) but leaves the other modes the same as they were
31180 outside the construct.
31181
31182 The contents of the stack and trail, values of non-quick variables, and
31183 other settings such as the language mode and the various display modes,
31184 are @emph{not} affected by @kbd{Z `} and @kbd{Z '}.
31185
31186 @node Queries in Macros, , Local Values in Macros, Keyboard Macros
31187 @subsection Queries in Keyboard Macros
31188
31189 @noindent
31190 @kindex Z =
31191 @pindex calc-kbd-report
31192 The @kbd{Z =} (@code{calc-kbd-report}) command displays an informative
31193 message including the value on the top of the stack. You are prompted
31194 to enter a string. That string, along with the top-of-stack value,
31195 is displayed unless @kbd{m w} (@code{calc-working}) has been used
31196 to turn such messages off.
31197
31198 @kindex Z #
31199 @pindex calc-kbd-query
31200 The @kbd{Z #} (@code{calc-kbd-query}) command displays a prompt message
31201 (which you enter during macro definition), then does an algebraic entry
31202 which takes its input from the keyboard, even during macro execution.
31203 This command allows your keyboard macros to accept numbers or formulas
31204 as interactive input. All the normal conventions of algebraic input,
31205 including the use of @kbd{$} characters, are supported.
31206
31207 @xref{Keyboard Macro Query, , , emacs, the Emacs Manual}, for a description of
31208 @kbd{C-x q} (@code{kbd-macro-query}), the standard Emacs way to accept
31209 keyboard input during a keyboard macro. In particular, you can use
31210 @kbd{C-x q} to enter a recursive edit, which allows the user to perform
31211 any Calculator operations interactively before pressing @kbd{C-M-c} to
31212 return control to the keyboard macro.
31213
31214 @node Invocation Macros, Algebraic Definitions, Keyboard Macros, Programming
31215 @section Invocation Macros
31216
31217 @kindex M-# z
31218 @kindex Z I
31219 @pindex calc-user-invocation
31220 @pindex calc-user-define-invocation
31221 Calc provides one special keyboard macro, called up by @kbd{M-# z}
31222 (@code{calc-user-invocation}), that is intended to allow you to define
31223 your own special way of starting Calc. To define this ``invocation
31224 macro,'' create the macro in the usual way with @kbd{C-x (} and
31225 @kbd{C-x )}, then type @kbd{Z I} (@code{calc-user-define-invocation}).
31226 There is only one invocation macro, so you don't need to type any
31227 additional letters after @kbd{Z I}. From now on, you can type
31228 @kbd{M-# z} at any time to execute your invocation macro.
31229
31230 For example, suppose you find yourself often grabbing rectangles of
31231 numbers into Calc and multiplying their columns. You can do this
31232 by typing @kbd{M-# r} to grab, and @kbd{V R : *} to multiply columns.
31233 To make this into an invocation macro, just type @kbd{C-x ( M-# r
31234 V R : * C-x )}, then @kbd{Z I}. Then, to multiply a rectangle of data,
31235 just mark the data in its buffer in the usual way and type @kbd{M-# z}.
31236
31237 Invocation macros are treated like regular Emacs keyboard macros;
31238 all the special features described above for @kbd{Z K}-style macros
31239 do not apply. @kbd{M-# z} is just like @kbd{C-x e}, except that it
31240 uses the macro that was last stored by @kbd{Z I}. (In fact, the
31241 macro does not even have to have anything to do with Calc!)
31242
31243 The @kbd{m m} command saves the last invocation macro defined by
31244 @kbd{Z I} along with all the other Calc mode settings.
31245 @xref{General Mode Commands}.
31246
31247 @node Algebraic Definitions, Lisp Definitions, Invocation Macros, Programming
31248 @section Programming with Formulas
31249
31250 @noindent
31251 @kindex Z F
31252 @pindex calc-user-define-formula
31253 @cindex Programming with algebraic formulas
31254 Another way to create a new Calculator command uses algebraic formulas.
31255 The @kbd{Z F} (@code{calc-user-define-formula}) command stores the
31256 formula at the top of the stack as the definition for a key. This
31257 command prompts for five things: The key, the command name, the function
31258 name, the argument list, and the behavior of the command when given
31259 non-numeric arguments.
31260
31261 For example, suppose we type @kbd{' a+2b @key{RET}} to push the formula
31262 @samp{a + 2*b} onto the stack. We now type @kbd{Z F m} to define this
31263 formula on the @kbd{z m} key sequence. The next prompt is for a command
31264 name, beginning with @samp{calc-}, which should be the long (@kbd{M-x}) form
31265 for the new command. If you simply press @key{RET}, a default name like
31266 @code{calc-User-m} will be constructed. In our example, suppose we enter
31267 @kbd{spam @key{RET}} to define the new command as @code{calc-spam}.
31268
31269 If you want to give the formula a long-style name only, you can press
31270 @key{SPC} or @key{RET} when asked which single key to use. For example
31271 @kbd{Z F @key{RET} spam @key{RET}} defines the new command as
31272 @kbd{M-x calc-spam}, with no keyboard equivalent.
31273
31274 The third prompt is for an algebraic function name. The default is to
31275 use the same name as the command name but without the @samp{calc-}
31276 prefix. (If this is of the form @samp{User-m}, the hyphen is removed so
31277 it won't be taken for a minus sign in algebraic formulas.)
31278 This is the name you will use if you want to enter your
31279 new function in an algebraic formula. Suppose we enter @kbd{yow @key{RET}}.
31280 Then the new function can be invoked by pushing two numbers on the
31281 stack and typing @kbd{z m} or @kbd{x spam}, or by entering the algebraic
31282 formula @samp{yow(x,y)}.
31283
31284 The fourth prompt is for the function's argument list. This is used to
31285 associate values on the stack with the variables that appear in the formula.
31286 The default is a list of all variables which appear in the formula, sorted
31287 into alphabetical order. In our case, the default would be @samp{(a b)}.
31288 This means that, when the user types @kbd{z m}, the Calculator will remove
31289 two numbers from the stack, substitute these numbers for @samp{a} and
31290 @samp{b} (respectively) in the formula, then simplify the formula and
31291 push the result on the stack. In other words, @kbd{10 @key{RET} 100 z m}
31292 would replace the 10 and 100 on the stack with the number 210, which is
31293 @expr{a + 2 b} with @expr{a=10} and @expr{b=100}. Likewise, the formula
31294 @samp{yow(10, 100)} will be evaluated by substituting @expr{a=10} and
31295 @expr{b=100} in the definition.
31296
31297 You can rearrange the order of the names before pressing @key{RET} to
31298 control which stack positions go to which variables in the formula. If
31299 you remove a variable from the argument list, that variable will be left
31300 in symbolic form by the command. Thus using an argument list of @samp{(b)}
31301 for our function would cause @kbd{10 z m} to replace the 10 on the stack
31302 with the formula @samp{a + 20}. If we had used an argument list of
31303 @samp{(b a)}, the result with inputs 10 and 100 would have been 120.
31304
31305 You can also put a nameless function on the stack instead of just a
31306 formula, as in @samp{<a, b : a + 2 b>}. @xref{Specifying Operators}.
31307 In this example, the command will be defined by the formula @samp{a + 2 b}
31308 using the argument list @samp{(a b)}.
31309
31310 The final prompt is a y-or-n question concerning what to do if symbolic
31311 arguments are given to your function. If you answer @kbd{y}, then
31312 executing @kbd{z m} (using the original argument list @samp{(a b)}) with
31313 arguments @expr{10} and @expr{x} will leave the function in symbolic
31314 form, i.e., @samp{yow(10,x)}. On the other hand, if you answer @kbd{n},
31315 then the formula will always be expanded, even for non-constant
31316 arguments: @samp{10 + 2 x}. If you never plan to feed algebraic
31317 formulas to your new function, it doesn't matter how you answer this
31318 question.
31319
31320 If you answered @kbd{y} to this question you can still cause a function
31321 call to be expanded by typing @kbd{a "} (@code{calc-expand-formula}).
31322 Also, Calc will expand the function if necessary when you take a
31323 derivative or integral or solve an equation involving the function.
31324
31325 @kindex Z G
31326 @pindex calc-get-user-defn
31327 Once you have defined a formula on a key, you can retrieve this formula
31328 with the @kbd{Z G} (@code{calc-user-define-get-defn}) command. Press a
31329 key, and this command pushes the formula that was used to define that
31330 key onto the stack. Actually, it pushes a nameless function that
31331 specifies both the argument list and the defining formula. You will get
31332 an error message if the key is undefined, or if the key was not defined
31333 by a @kbd{Z F} command.
31334
31335 The @kbd{Z E} (@code{calc-user-define-edit}) command on a key that has
31336 been defined by a formula uses a variant of the @code{calc-edit} command
31337 to edit the defining formula. Press @kbd{C-c C-c} to finish editing and
31338 store the new formula back in the definition, or kill the buffer with
31339 @kbd{C-x k} to
31340 cancel the edit. (The argument list and other properties of the
31341 definition are unchanged; to adjust the argument list, you can use
31342 @kbd{Z G} to grab the function onto the stack, edit with @kbd{`}, and
31343 then re-execute the @kbd{Z F} command.)
31344
31345 As usual, the @kbd{Z P} command records your definition permanently.
31346 In this case it will permanently record all three of the relevant
31347 definitions: the key, the command, and the function.
31348
31349 You may find it useful to turn off the default simplifications with
31350 @kbd{m O} (@code{calc-no-simplify-mode}) when entering a formula to be
31351 used as a function definition. For example, the formula @samp{deriv(a^2,v)}
31352 which might be used to define a new function @samp{dsqr(a,v)} will be
31353 ``simplified'' to 0 immediately upon entry since @code{deriv} considers
31354 @expr{a} to be constant with respect to @expr{v}. Turning off
31355 default simplifications cures this problem: The definition will be stored
31356 in symbolic form without ever activating the @code{deriv} function. Press
31357 @kbd{m D} to turn the default simplifications back on afterwards.
31358
31359 @node Lisp Definitions, , Algebraic Definitions, Programming
31360 @section Programming with Lisp
31361
31362 @noindent
31363 The Calculator can be programmed quite extensively in Lisp. All you
31364 do is write a normal Lisp function definition, but with @code{defmath}
31365 in place of @code{defun}. This has the same form as @code{defun}, but it
31366 automagically replaces calls to standard Lisp functions like @code{+} and
31367 @code{zerop} with calls to the corresponding functions in Calc's own library.
31368 Thus you can write natural-looking Lisp code which operates on all of the
31369 standard Calculator data types. You can then use @kbd{Z D} if you wish to
31370 bind your new command to a @kbd{z}-prefix key sequence. The @kbd{Z E} command
31371 will not edit a Lisp-based definition.
31372
31373 Emacs Lisp is described in the GNU Emacs Lisp Reference Manual. This section
31374 assumes a familiarity with Lisp programming concepts; if you do not know
31375 Lisp, you may find keyboard macros or rewrite rules to be an easier way
31376 to program the Calculator.
31377
31378 This section first discusses ways to write commands, functions, or
31379 small programs to be executed inside of Calc. Then it discusses how
31380 your own separate programs are able to call Calc from the outside.
31381 Finally, there is a list of internal Calc functions and data structures
31382 for the true Lisp enthusiast.
31383
31384 @menu
31385 * Defining Functions::
31386 * Defining Simple Commands::
31387 * Defining Stack Commands::
31388 * Argument Qualifiers::
31389 * Example Definitions::
31390
31391 * Calling Calc from Your Programs::
31392 * Internals::
31393 @end menu
31394
31395 @node Defining Functions, Defining Simple Commands, Lisp Definitions, Lisp Definitions
31396 @subsection Defining New Functions
31397
31398 @noindent
31399 @findex defmath
31400 The @code{defmath} function (actually a Lisp macro) is like @code{defun}
31401 except that code in the body of the definition can make use of the full
31402 range of Calculator data types. The prefix @samp{calcFunc-} is added
31403 to the specified name to get the actual Lisp function name. As a simple
31404 example,
31405
31406 @example
31407 (defmath myfact (n)
31408 (if (> n 0)
31409 (* n (myfact (1- n)))
31410 1))
31411 @end example
31412
31413 @noindent
31414 This actually expands to the code,
31415
31416 @example
31417 (defun calcFunc-myfact (n)
31418 (if (math-posp n)
31419 (math-mul n (calcFunc-myfact (math-add n -1)))
31420 1))
31421 @end example
31422
31423 @noindent
31424 This function can be used in algebraic expressions, e.g., @samp{myfact(5)}.
31425
31426 The @samp{myfact} function as it is defined above has the bug that an
31427 expression @samp{myfact(a+b)} will be simplified to 1 because the
31428 formula @samp{a+b} is not considered to be @code{posp}. A robust
31429 factorial function would be written along the following lines:
31430
31431 @smallexample
31432 (defmath myfact (n)
31433 (if (> n 0)
31434 (* n (myfact (1- n)))
31435 (if (= n 0)
31436 1
31437 nil))) ; this could be simplified as: (and (= n 0) 1)
31438 @end smallexample
31439
31440 If a function returns @code{nil}, it is left unsimplified by the Calculator
31441 (except that its arguments will be simplified). Thus, @samp{myfact(a+1+2)}
31442 will be simplified to @samp{myfact(a+3)} but no further. Beware that every
31443 time the Calculator reexamines this formula it will attempt to resimplify
31444 it, so your function ought to detect the returning-@code{nil} case as
31445 efficiently as possible.
31446
31447 The following standard Lisp functions are treated by @code{defmath}:
31448 @code{+}, @code{-}, @code{*}, @code{/}, @code{%}, @code{^} or
31449 @code{expt}, @code{=}, @code{<}, @code{>}, @code{<=}, @code{>=},
31450 @code{/=}, @code{1+}, @code{1-}, @code{logand}, @code{logior}, @code{logxor},
31451 @code{logandc2}, @code{lognot}. Also, @code{~=} is an abbreviation for
31452 @code{math-nearly-equal}, which is useful in implementing Taylor series.
31453
31454 For other functions @var{func}, if a function by the name
31455 @samp{calcFunc-@var{func}} exists it is used, otherwise if a function by the
31456 name @samp{math-@var{func}} exists it is used, otherwise if @var{func} itself
31457 is defined as a function it is used, otherwise @samp{calcFunc-@var{func}} is
31458 used on the assumption that this is a to-be-defined math function. Also, if
31459 the function name is quoted as in @samp{('integerp a)} the function name is
31460 always used exactly as written (but not quoted).
31461
31462 Variable names have @samp{var-} prepended to them unless they appear in
31463 the function's argument list or in an enclosing @code{let}, @code{let*},
31464 @code{for}, or @code{foreach} form,
31465 or their names already contain a @samp{-} character. Thus a reference to
31466 @samp{foo} is the same as a reference to @samp{var-foo}.
31467
31468 A few other Lisp extensions are available in @code{defmath} definitions:
31469
31470 @itemize @bullet
31471 @item
31472 The @code{elt} function accepts any number of index variables.
31473 Note that Calc vectors are stored as Lisp lists whose first
31474 element is the symbol @code{vec}; thus, @samp{(elt v 2)} yields
31475 the second element of vector @code{v}, and @samp{(elt m i j)}
31476 yields one element of a Calc matrix.
31477
31478 @item
31479 The @code{setq} function has been extended to act like the Common
31480 Lisp @code{setf} function. (The name @code{setf} is recognized as
31481 a synonym of @code{setq}.) Specifically, the first argument of
31482 @code{setq} can be an @code{nth}, @code{elt}, @code{car}, or @code{cdr} form,
31483 in which case the effect is to store into the specified
31484 element of a list. Thus, @samp{(setq (elt m i j) x)} stores @expr{x}
31485 into one element of a matrix.
31486
31487 @item
31488 A @code{for} looping construct is available. For example,
31489 @samp{(for ((i 0 10)) body)} executes @code{body} once for each
31490 binding of @expr{i} from zero to 10. This is like a @code{let}
31491 form in that @expr{i} is temporarily bound to the loop count
31492 without disturbing its value outside the @code{for} construct.
31493 Nested loops, as in @samp{(for ((i 0 10) (j 0 (1- i) 2)) body)},
31494 are also available. For each value of @expr{i} from zero to 10,
31495 @expr{j} counts from 0 to @expr{i-1} in steps of two. Note that
31496 @code{for} has the same general outline as @code{let*}, except
31497 that each element of the header is a list of three or four
31498 things, not just two.
31499
31500 @item
31501 The @code{foreach} construct loops over elements of a list.
31502 For example, @samp{(foreach ((x (cdr v))) body)} executes
31503 @code{body} with @expr{x} bound to each element of Calc vector
31504 @expr{v} in turn. The purpose of @code{cdr} here is to skip over
31505 the initial @code{vec} symbol in the vector.
31506
31507 @item
31508 The @code{break} function breaks out of the innermost enclosing
31509 @code{while}, @code{for}, or @code{foreach} loop. If given a
31510 value, as in @samp{(break x)}, this value is returned by the
31511 loop. (Lisp loops otherwise always return @code{nil}.)
31512
31513 @item
31514 The @code{return} function prematurely returns from the enclosing
31515 function. For example, @samp{(return (+ x y))} returns @expr{x+y}
31516 as the value of a function. You can use @code{return} anywhere
31517 inside the body of the function.
31518 @end itemize
31519
31520 Non-integer numbers (and extremely large integers) cannot be included
31521 directly into a @code{defmath} definition. This is because the Lisp
31522 reader will fail to parse them long before @code{defmath} ever gets control.
31523 Instead, use the notation, @samp{:"3.1415"}. In fact, any algebraic
31524 formula can go between the quotes. For example,
31525
31526 @smallexample
31527 (defmath sqexp (x) ; sqexp(x) == sqrt(exp(x)) == exp(x*0.5)
31528 (and (numberp x)
31529 (exp :"x * 0.5")))
31530 @end smallexample
31531
31532 expands to
31533
31534 @smallexample
31535 (defun calcFunc-sqexp (x)
31536 (and (math-numberp x)
31537 (calcFunc-exp (math-mul x '(float 5 -1)))))
31538 @end smallexample
31539
31540 Note the use of @code{numberp} as a guard to ensure that the argument is
31541 a number first, returning @code{nil} if not. The exponential function
31542 could itself have been included in the expression, if we had preferred:
31543 @samp{:"exp(x * 0.5)"}. As another example, the multiplication-and-recursion
31544 step of @code{myfact} could have been written
31545
31546 @example
31547 :"n * myfact(n-1)"
31548 @end example
31549
31550 A good place to put your @code{defmath} commands is your Calc init file
31551 (the file given by @code{calc-settings-file}, typically
31552 @file{~/.calc.el}), which will not be loaded until Calc starts.
31553 If a file named @file{.emacs} exists in your home directory, Emacs reads
31554 and executes the Lisp forms in this file as it starts up. While it may
31555 seem reasonable to put your favorite @code{defmath} commands there,
31556 this has the unfortunate side-effect that parts of the Calculator must be
31557 loaded in to process the @code{defmath} commands whether or not you will
31558 actually use the Calculator! If you want to put the @code{defmath}
31559 commands there (for example, if you redefine @code{calc-settings-file}
31560 to be @file{.emacs}), a better effect can be had by writing
31561
31562 @example
31563 (put 'calc-define 'thing '(progn
31564 (defmath ... )
31565 (defmath ... )
31566 ))
31567 @end example
31568
31569 @noindent
31570 @vindex calc-define
31571 The @code{put} function adds a @dfn{property} to a symbol. Each Lisp
31572 symbol has a list of properties associated with it. Here we add a
31573 property with a name of @code{thing} and a @samp{(progn ...)} form as
31574 its value. When Calc starts up, and at the start of every Calc command,
31575 the property list for the symbol @code{calc-define} is checked and the
31576 values of any properties found are evaluated as Lisp forms. The
31577 properties are removed as they are evaluated. The property names
31578 (like @code{thing}) are not used; you should choose something like the
31579 name of your project so as not to conflict with other properties.
31580
31581 The net effect is that you can put the above code in your @file{.emacs}
31582 file and it will not be executed until Calc is loaded. Or, you can put
31583 that same code in another file which you load by hand either before or
31584 after Calc itself is loaded.
31585
31586 The properties of @code{calc-define} are evaluated in the same order
31587 that they were added. They can assume that the Calc modules @file{calc.el},
31588 @file{calc-ext.el}, and @file{calc-macs.el} have been fully loaded, and
31589 that the @samp{*Calculator*} buffer will be the current buffer.
31590
31591 If your @code{calc-define} property only defines algebraic functions,
31592 you can be sure that it will have been evaluated before Calc tries to
31593 call your function, even if the file defining the property is loaded
31594 after Calc is loaded. But if the property defines commands or key
31595 sequences, it may not be evaluated soon enough. (Suppose it defines the
31596 new command @code{tweak-calc}; the user can load your file, then type
31597 @kbd{M-x tweak-calc} before Calc has had chance to do anything.) To
31598 protect against this situation, you can put
31599
31600 @example
31601 (run-hooks 'calc-check-defines)
31602 @end example
31603
31604 @findex calc-check-defines
31605 @noindent
31606 at the end of your file. The @code{calc-check-defines} function is what
31607 looks for and evaluates properties on @code{calc-define}; @code{run-hooks}
31608 has the advantage that it is quietly ignored if @code{calc-check-defines}
31609 is not yet defined because Calc has not yet been loaded.
31610
31611 Examples of things that ought to be enclosed in a @code{calc-define}
31612 property are @code{defmath} calls, @code{define-key} calls that modify
31613 the Calc key map, and any calls that redefine things defined inside Calc.
31614 Ordinary @code{defun}s need not be enclosed with @code{calc-define}.
31615
31616 @node Defining Simple Commands, Defining Stack Commands, Defining Functions, Lisp Definitions
31617 @subsection Defining New Simple Commands
31618
31619 @noindent
31620 @findex interactive
31621 If a @code{defmath} form contains an @code{interactive} clause, it defines
31622 a Calculator command. Actually such a @code{defmath} results in @emph{two}
31623 function definitions: One, a @samp{calcFunc-} function as was just described,
31624 with the @code{interactive} clause removed. Two, a @samp{calc-} function
31625 with a suitable @code{interactive} clause and some sort of wrapper to make
31626 the command work in the Calc environment.
31627
31628 In the simple case, the @code{interactive} clause has the same form as
31629 for normal Emacs Lisp commands:
31630
31631 @smallexample
31632 (defmath increase-precision (delta)
31633 "Increase precision by DELTA." ; This is the "documentation string"
31634 (interactive "p") ; Register this as a M-x-able command
31635 (setq calc-internal-prec (+ calc-internal-prec delta)))
31636 @end smallexample
31637
31638 This expands to the pair of definitions,
31639
31640 @smallexample
31641 (defun calc-increase-precision (delta)
31642 "Increase precision by DELTA."
31643 (interactive "p")
31644 (calc-wrapper
31645 (setq calc-internal-prec (math-add calc-internal-prec delta))))
31646
31647 (defun calcFunc-increase-precision (delta)
31648 "Increase precision by DELTA."
31649 (setq calc-internal-prec (math-add calc-internal-prec delta)))
31650 @end smallexample
31651
31652 @noindent
31653 where in this case the latter function would never really be used! Note
31654 that since the Calculator stores small integers as plain Lisp integers,
31655 the @code{math-add} function will work just as well as the native
31656 @code{+} even when the intent is to operate on native Lisp integers.
31657
31658 @findex calc-wrapper
31659 The @samp{calc-wrapper} call invokes a macro which surrounds the body of
31660 the function with code that looks roughly like this:
31661
31662 @smallexample
31663 (let ((calc-command-flags nil))
31664 (unwind-protect
31665 (save-excursion
31666 (calc-select-buffer)
31667 @emph{body of function}
31668 @emph{renumber stack}
31669 @emph{clear} Working @emph{message})
31670 @emph{realign cursor and window}
31671 @emph{clear Inverse, Hyperbolic, and Keep Args flags}
31672 @emph{update Emacs mode line}))
31673 @end smallexample
31674
31675 @findex calc-select-buffer
31676 The @code{calc-select-buffer} function selects the @samp{*Calculator*}
31677 buffer if necessary, say, because the command was invoked from inside
31678 the @samp{*Calc Trail*} window.
31679
31680 @findex calc-set-command-flag
31681 You can call, for example, @code{(calc-set-command-flag 'no-align)} to
31682 set the above-mentioned command flags. Calc routines recognize the
31683 following command flags:
31684
31685 @table @code
31686 @item renum-stack
31687 Stack line numbers @samp{1:}, @samp{2:}, and so on must be renumbered
31688 after this command completes. This is set by routines like
31689 @code{calc-push}.
31690
31691 @item clear-message
31692 Calc should call @samp{(message "")} if this command completes normally
31693 (to clear a ``Working@dots{}'' message out of the echo area).
31694
31695 @item no-align
31696 Do not move the cursor back to the @samp{.} top-of-stack marker.
31697
31698 @item position-point
31699 Use the variables @code{calc-position-point-line} and
31700 @code{calc-position-point-column} to position the cursor after
31701 this command finishes.
31702
31703 @item keep-flags
31704 Do not clear @code{calc-inverse-flag}, @code{calc-hyperbolic-flag},
31705 and @code{calc-keep-args-flag} at the end of this command.
31706
31707 @item do-edit
31708 Switch to buffer @samp{*Calc Edit*} after this command.
31709
31710 @item hold-trail
31711 Do not move trail pointer to end of trail when something is recorded
31712 there.
31713 @end table
31714
31715 @kindex Y
31716 @kindex Y ?
31717 @vindex calc-Y-help-msgs
31718 Calc reserves a special prefix key, shift-@kbd{Y}, for user-written
31719 extensions to Calc. There are no built-in commands that work with
31720 this prefix key; you must call @code{define-key} from Lisp (probably
31721 from inside a @code{calc-define} property) to add to it. Initially only
31722 @kbd{Y ?} is defined; it takes help messages from a list of strings
31723 (initially @code{nil}) in the variable @code{calc-Y-help-msgs}. All
31724 other undefined keys except for @kbd{Y} are reserved for use by
31725 future versions of Calc.
31726
31727 If you are writing a Calc enhancement which you expect to give to
31728 others, it is best to minimize the number of @kbd{Y}-key sequences
31729 you use. In fact, if you have more than one key sequence you should
31730 consider defining three-key sequences with a @kbd{Y}, then a key that
31731 stands for your package, then a third key for the particular command
31732 within your package.
31733
31734 Users may wish to install several Calc enhancements, and it is possible
31735 that several enhancements will choose to use the same key. In the
31736 example below, a variable @code{inc-prec-base-key} has been defined
31737 to contain the key that identifies the @code{inc-prec} package. Its
31738 value is initially @code{"P"}, but a user can change this variable
31739 if necessary without having to modify the file.
31740
31741 Here is a complete file, @file{inc-prec.el}, which makes a @kbd{Y P I}
31742 command that increases the precision, and a @kbd{Y P D} command that
31743 decreases the precision.
31744
31745 @smallexample
31746 ;;; Increase and decrease Calc precision. Dave Gillespie, 5/31/91.
31747 ;;; (Include copyright or copyleft stuff here.)
31748
31749 (defvar inc-prec-base-key "P"
31750 "Base key for inc-prec.el commands.")
31751
31752 (put 'calc-define 'inc-prec '(progn
31753
31754 (define-key calc-mode-map (format "Y%sI" inc-prec-base-key)
31755 'increase-precision)
31756 (define-key calc-mode-map (format "Y%sD" inc-prec-base-key)
31757 'decrease-precision)
31758
31759 (setq calc-Y-help-msgs
31760 (cons (format "%s + Inc-prec, Dec-prec" inc-prec-base-key)
31761 calc-Y-help-msgs))
31762
31763 (defmath increase-precision (delta)
31764 "Increase precision by DELTA."
31765 (interactive "p")
31766 (setq calc-internal-prec (+ calc-internal-prec delta)))
31767
31768 (defmath decrease-precision (delta)
31769 "Decrease precision by DELTA."
31770 (interactive "p")
31771 (setq calc-internal-prec (- calc-internal-prec delta)))
31772
31773 )) ; end of calc-define property
31774
31775 (run-hooks 'calc-check-defines)
31776 @end smallexample
31777
31778 @node Defining Stack Commands, Argument Qualifiers, Defining Simple Commands, Lisp Definitions
31779 @subsection Defining New Stack-Based Commands
31780
31781 @noindent
31782 To define a new computational command which takes and/or leaves arguments
31783 on the stack, a special form of @code{interactive} clause is used.
31784
31785 @example
31786 (interactive @var{num} @var{tag})
31787 @end example
31788
31789 @noindent
31790 where @var{num} is an integer, and @var{tag} is a string. The effect is
31791 to pop @var{num} values off the stack, resimplify them by calling
31792 @code{calc-normalize}, and hand them to your function according to the
31793 function's argument list. Your function may include @code{&optional} and
31794 @code{&rest} parameters, so long as calling the function with @var{num}
31795 parameters is valid.
31796
31797 Your function must return either a number or a formula in a form
31798 acceptable to Calc, or a list of such numbers or formulas. These value(s)
31799 are pushed onto the stack when the function completes. They are also
31800 recorded in the Calc Trail buffer on a line beginning with @var{tag},
31801 a string of (normally) four characters or less. If you omit @var{tag}
31802 or use @code{nil} as a tag, the result is not recorded in the trail.
31803
31804 As an example, the definition
31805
31806 @smallexample
31807 (defmath myfact (n)
31808 "Compute the factorial of the integer at the top of the stack."
31809 (interactive 1 "fact")
31810 (if (> n 0)
31811 (* n (myfact (1- n)))
31812 (and (= n 0) 1)))
31813 @end smallexample
31814
31815 @noindent
31816 is a version of the factorial function shown previously which can be used
31817 as a command as well as an algebraic function. It expands to
31818
31819 @smallexample
31820 (defun calc-myfact ()
31821 "Compute the factorial of the integer at the top of the stack."
31822 (interactive)
31823 (calc-slow-wrapper
31824 (calc-enter-result 1 "fact"
31825 (cons 'calcFunc-myfact (calc-top-list-n 1)))))
31826
31827 (defun calcFunc-myfact (n)
31828 "Compute the factorial of the integer at the top of the stack."
31829 (if (math-posp n)
31830 (math-mul n (calcFunc-myfact (math-add n -1)))
31831 (and (math-zerop n) 1)))
31832 @end smallexample
31833
31834 @findex calc-slow-wrapper
31835 The @code{calc-slow-wrapper} function is a version of @code{calc-wrapper}
31836 that automatically puts up a @samp{Working...} message before the
31837 computation begins. (This message can be turned off by the user
31838 with an @kbd{m w} (@code{calc-working}) command.)
31839
31840 @findex calc-top-list-n
31841 The @code{calc-top-list-n} function returns a list of the specified number
31842 of values from the top of the stack. It resimplifies each value by
31843 calling @code{calc-normalize}. If its argument is zero it returns an
31844 empty list. It does not actually remove these values from the stack.
31845
31846 @findex calc-enter-result
31847 The @code{calc-enter-result} function takes an integer @var{num} and string
31848 @var{tag} as described above, plus a third argument which is either a
31849 Calculator data object or a list of such objects. These objects are
31850 resimplified and pushed onto the stack after popping the specified number
31851 of values from the stack. If @var{tag} is non-@code{nil}, the values
31852 being pushed are also recorded in the trail.
31853
31854 Note that if @code{calcFunc-myfact} returns @code{nil} this represents
31855 ``leave the function in symbolic form.'' To return an actual empty list,
31856 in the sense that @code{calc-enter-result} will push zero elements back
31857 onto the stack, you should return the special value @samp{'(nil)}, a list
31858 containing the single symbol @code{nil}.
31859
31860 The @code{interactive} declaration can actually contain a limited
31861 Emacs-style code string as well which comes just before @var{num} and
31862 @var{tag}. Currently the only Emacs code supported is @samp{"p"}, as in
31863
31864 @example
31865 (defmath foo (a b &optional c)
31866 (interactive "p" 2 "foo")
31867 @var{body})
31868 @end example
31869
31870 In this example, the command @code{calc-foo} will evaluate the expression
31871 @samp{foo(a,b)} if executed with no argument, or @samp{foo(a,b,n)} if
31872 executed with a numeric prefix argument of @expr{n}.
31873
31874 The other code string allowed is @samp{"m"} (unrelated to the usual @samp{"m"}
31875 code as used with @code{defun}). It uses the numeric prefix argument as the
31876 number of objects to remove from the stack and pass to the function.
31877 In this case, the integer @var{num} serves as a default number of
31878 arguments to be used when no prefix is supplied.
31879
31880 @node Argument Qualifiers, Example Definitions, Defining Stack Commands, Lisp Definitions
31881 @subsection Argument Qualifiers
31882
31883 @noindent
31884 Anywhere a parameter name can appear in the parameter list you can also use
31885 an @dfn{argument qualifier}. Thus the general form of a definition is:
31886
31887 @example
31888 (defmath @var{name} (@var{param} @var{param...}
31889 &optional @var{param} @var{param...}
31890 &rest @var{param})
31891 @var{body})
31892 @end example
31893
31894 @noindent
31895 where each @var{param} is either a symbol or a list of the form
31896
31897 @example
31898 (@var{qual} @var{param})
31899 @end example
31900
31901 The following qualifiers are recognized:
31902
31903 @table @samp
31904 @item complete
31905 @findex complete
31906 The argument must not be an incomplete vector, interval, or complex number.
31907 (This is rarely needed since the Calculator itself will never call your
31908 function with an incomplete argument. But there is nothing stopping your
31909 own Lisp code from calling your function with an incomplete argument.)
31910
31911 @item integer
31912 @findex integer
31913 The argument must be an integer. If it is an integer-valued float
31914 it will be accepted but converted to integer form. Non-integers and
31915 formulas are rejected.
31916
31917 @item natnum
31918 @findex natnum
31919 Like @samp{integer}, but the argument must be non-negative.
31920
31921 @item fixnum
31922 @findex fixnum
31923 Like @samp{integer}, but the argument must fit into a native Lisp integer,
31924 which on most systems means less than 2^23 in absolute value. The
31925 argument is converted into Lisp-integer form if necessary.
31926
31927 @item float
31928 @findex float
31929 The argument is converted to floating-point format if it is a number or
31930 vector. If it is a formula it is left alone. (The argument is never
31931 actually rejected by this qualifier.)
31932
31933 @item @var{pred}
31934 The argument must satisfy predicate @var{pred}, which is one of the
31935 standard Calculator predicates. @xref{Predicates}.
31936
31937 @item not-@var{pred}
31938 The argument must @emph{not} satisfy predicate @var{pred}.
31939 @end table
31940
31941 For example,
31942
31943 @example
31944 (defmath foo (a (constp (not-matrixp b)) &optional (float c)
31945 &rest (integer d))
31946 @var{body})
31947 @end example
31948
31949 @noindent
31950 expands to
31951
31952 @example
31953 (defun calcFunc-foo (a b &optional c &rest d)
31954 (and (math-matrixp b)
31955 (math-reject-arg b 'not-matrixp))
31956 (or (math-constp b)
31957 (math-reject-arg b 'constp))
31958 (and c (setq c (math-check-float c)))
31959 (setq d (mapcar 'math-check-integer d))
31960 @var{body})
31961 @end example
31962
31963 @noindent
31964 which performs the necessary checks and conversions before executing the
31965 body of the function.
31966
31967 @node Example Definitions, Calling Calc from Your Programs, Argument Qualifiers, Lisp Definitions
31968 @subsection Example Definitions
31969
31970 @noindent
31971 This section includes some Lisp programming examples on a larger scale.
31972 These programs make use of some of the Calculator's internal functions;
31973 @pxref{Internals}.
31974
31975 @menu
31976 * Bit Counting Example::
31977 * Sine Example::
31978 @end menu
31979
31980 @node Bit Counting Example, Sine Example, Example Definitions, Example Definitions
31981 @subsubsection Bit-Counting
31982
31983 @noindent
31984 @ignore
31985 @starindex
31986 @end ignore
31987 @tindex bcount
31988 Calc does not include a built-in function for counting the number of
31989 ``one'' bits in a binary integer. It's easy to invent one using @kbd{b u}
31990 to convert the integer to a set, and @kbd{V #} to count the elements of
31991 that set; let's write a function that counts the bits without having to
31992 create an intermediate set.
31993
31994 @smallexample
31995 (defmath bcount ((natnum n))
31996 (interactive 1 "bcnt")
31997 (let ((count 0))
31998 (while (> n 0)
31999 (if (oddp n)
32000 (setq count (1+ count)))
32001 (setq n (lsh n -1)))
32002 count))
32003 @end smallexample
32004
32005 @noindent
32006 When this is expanded by @code{defmath}, it will become the following
32007 Emacs Lisp function:
32008
32009 @smallexample
32010 (defun calcFunc-bcount (n)
32011 (setq n (math-check-natnum n))
32012 (let ((count 0))
32013 (while (math-posp n)
32014 (if (math-oddp n)
32015 (setq count (math-add count 1)))
32016 (setq n (calcFunc-lsh n -1)))
32017 count))
32018 @end smallexample
32019
32020 If the input numbers are large, this function involves a fair amount
32021 of arithmetic. A binary right shift is essentially a division by two;
32022 recall that Calc stores integers in decimal form so bit shifts must
32023 involve actual division.
32024
32025 To gain a bit more efficiency, we could divide the integer into
32026 @var{n}-bit chunks, each of which can be handled quickly because
32027 they fit into Lisp integers. It turns out that Calc's arithmetic
32028 routines are especially fast when dividing by an integer less than
32029 1000, so we can set @var{n = 9} bits and use repeated division by 512:
32030
32031 @smallexample
32032 (defmath bcount ((natnum n))
32033 (interactive 1 "bcnt")
32034 (let ((count 0))
32035 (while (not (fixnump n))
32036 (let ((qr (idivmod n 512)))
32037 (setq count (+ count (bcount-fixnum (cdr qr)))
32038 n (car qr))))
32039 (+ count (bcount-fixnum n))))
32040
32041 (defun bcount-fixnum (n)
32042 (let ((count 0))
32043 (while (> n 0)
32044 (setq count (+ count (logand n 1))
32045 n (lsh n -1)))
32046 count))
32047 @end smallexample
32048
32049 @noindent
32050 Note that the second function uses @code{defun}, not @code{defmath}.
32051 Because this function deals only with native Lisp integers (``fixnums''),
32052 it can use the actual Emacs @code{+} and related functions rather
32053 than the slower but more general Calc equivalents which @code{defmath}
32054 uses.
32055
32056 The @code{idivmod} function does an integer division, returning both
32057 the quotient and the remainder at once. Again, note that while it
32058 might seem that @samp{(logand n 511)} and @samp{(lsh n -9)} are
32059 more efficient ways to split off the bottom nine bits of @code{n},
32060 actually they are less efficient because each operation is really
32061 a division by 512 in disguise; @code{idivmod} allows us to do the
32062 same thing with a single division by 512.
32063
32064 @node Sine Example, , Bit Counting Example, Example Definitions
32065 @subsubsection The Sine Function
32066
32067 @noindent
32068 @ignore
32069 @starindex
32070 @end ignore
32071 @tindex mysin
32072 A somewhat limited sine function could be defined as follows, using the
32073 well-known Taylor series expansion for
32074 @texline @math{\sin x}:
32075 @infoline @samp{sin(x)}:
32076
32077 @smallexample
32078 (defmath mysin ((float (anglep x)))
32079 (interactive 1 "mysn")
32080 (setq x (to-radians x)) ; Convert from current angular mode.
32081 (let ((sum x) ; Initial term of Taylor expansion of sin.
32082 newsum
32083 (nfact 1) ; "nfact" equals "n" factorial at all times.
32084 (xnegsqr :"-(x^2)")) ; "xnegsqr" equals -x^2.
32085 (for ((n 3 100 2)) ; Upper limit of 100 is a good precaution.
32086 (working "mysin" sum) ; Display "Working" message, if enabled.
32087 (setq nfact (* nfact (1- n) n)
32088 x (* x xnegsqr)
32089 newsum (+ sum (/ x nfact)))
32090 (if (~= newsum sum) ; If newsum is "nearly equal to" sum,
32091 (break)) ; then we are done.
32092 (setq sum newsum))
32093 sum))
32094 @end smallexample
32095
32096 The actual @code{sin} function in Calc works by first reducing the problem
32097 to a sine or cosine of a nonnegative number less than @cpiover{4}. This
32098 ensures that the Taylor series will converge quickly. Also, the calculation
32099 is carried out with two extra digits of precision to guard against cumulative
32100 round-off in @samp{sum}. Finally, complex arguments are allowed and handled
32101 by a separate algorithm.
32102
32103 @smallexample
32104 (defmath mysin ((float (scalarp x)))
32105 (interactive 1 "mysn")
32106 (setq x (to-radians x)) ; Convert from current angular mode.
32107 (with-extra-prec 2 ; Evaluate with extra precision.
32108 (cond ((complexp x)
32109 (mysin-complex x))
32110 ((< x 0)
32111 (- (mysin-raw (- x))) ; Always call mysin-raw with x >= 0.
32112 (t (mysin-raw x))))))
32113
32114 (defmath mysin-raw (x)
32115 (cond ((>= x 7)
32116 (mysin-raw (% x (two-pi)))) ; Now x < 7.
32117 ((> x (pi-over-2))
32118 (- (mysin-raw (- x (pi))))) ; Now -pi/2 <= x <= pi/2.
32119 ((> x (pi-over-4))
32120 (mycos-raw (- x (pi-over-2)))) ; Now -pi/2 <= x <= pi/4.
32121 ((< x (- (pi-over-4)))
32122 (- (mycos-raw (+ x (pi-over-2))))) ; Now -pi/4 <= x <= pi/4,
32123 (t (mysin-series x)))) ; so the series will be efficient.
32124 @end smallexample
32125
32126 @noindent
32127 where @code{mysin-complex} is an appropriate function to handle complex
32128 numbers, @code{mysin-series} is the routine to compute the sine Taylor
32129 series as before, and @code{mycos-raw} is a function analogous to
32130 @code{mysin-raw} for cosines.
32131
32132 The strategy is to ensure that @expr{x} is nonnegative before calling
32133 @code{mysin-raw}. This function then recursively reduces its argument
32134 to a suitable range, namely, plus-or-minus @cpiover{4}. Note that each
32135 test, and particularly the first comparison against 7, is designed so
32136 that small roundoff errors cannot produce an infinite loop. (Suppose
32137 we compared with @samp{(two-pi)} instead; if due to roundoff problems
32138 the modulo operator ever returned @samp{(two-pi)} exactly, an infinite
32139 recursion could result!) We use modulo only for arguments that will
32140 clearly get reduced, knowing that the next rule will catch any reductions
32141 that this rule misses.
32142
32143 If a program is being written for general use, it is important to code
32144 it carefully as shown in this second example. For quick-and-dirty programs,
32145 when you know that your own use of the sine function will never encounter
32146 a large argument, a simpler program like the first one shown is fine.
32147
32148 @node Calling Calc from Your Programs, Internals, Example Definitions, Lisp Definitions
32149 @subsection Calling Calc from Your Lisp Programs
32150
32151 @noindent
32152 A later section (@pxref{Internals}) gives a full description of
32153 Calc's internal Lisp functions. It's not hard to call Calc from
32154 inside your programs, but the number of these functions can be daunting.
32155 So Calc provides one special ``programmer-friendly'' function called
32156 @code{calc-eval} that can be made to do just about everything you
32157 need. It's not as fast as the low-level Calc functions, but it's
32158 much simpler to use!
32159
32160 It may seem that @code{calc-eval} itself has a daunting number of
32161 options, but they all stem from one simple operation.
32162
32163 In its simplest manifestation, @samp{(calc-eval "1+2")} parses the
32164 string @code{"1+2"} as if it were a Calc algebraic entry and returns
32165 the result formatted as a string: @code{"3"}.
32166
32167 Since @code{calc-eval} is on the list of recommended @code{autoload}
32168 functions, you don't need to make any special preparations to load
32169 Calc before calling @code{calc-eval} the first time. Calc will be
32170 loaded and initialized for you.
32171
32172 All the Calc modes that are currently in effect will be used when
32173 evaluating the expression and formatting the result.
32174
32175 @ifinfo
32176 @example
32177
32178 @end example
32179 @end ifinfo
32180 @subsubsection Additional Arguments to @code{calc-eval}
32181
32182 @noindent
32183 If the input string parses to a list of expressions, Calc returns
32184 the results separated by @code{", "}. You can specify a different
32185 separator by giving a second string argument to @code{calc-eval}:
32186 @samp{(calc-eval "1+2,3+4" ";")} returns @code{"3;7"}.
32187
32188 The ``separator'' can also be any of several Lisp symbols which
32189 request other behaviors from @code{calc-eval}. These are discussed
32190 one by one below.
32191
32192 You can give additional arguments to be substituted for
32193 @samp{$}, @samp{$$}, and so on in the main expression. For
32194 example, @samp{(calc-eval "$/$$" nil "7" "1+1")} evaluates the
32195 expression @code{"7/(1+1)"} to yield the result @code{"3.5"}
32196 (assuming Fraction mode is not in effect). Note the @code{nil}
32197 used as a placeholder for the item-separator argument.
32198
32199 @ifinfo
32200 @example
32201
32202 @end example
32203 @end ifinfo
32204 @subsubsection Error Handling
32205
32206 @noindent
32207 If @code{calc-eval} encounters an error, it returns a list containing
32208 the character position of the error, plus a suitable message as a
32209 string. Note that @samp{1 / 0} is @emph{not} an error by Calc's
32210 standards; it simply returns the string @code{"1 / 0"} which is the
32211 division left in symbolic form. But @samp{(calc-eval "1/")} will
32212 return the list @samp{(2 "Expected a number")}.
32213
32214 If you bind the variable @code{calc-eval-error} to @code{t}
32215 using a @code{let} form surrounding the call to @code{calc-eval},
32216 errors instead call the Emacs @code{error} function which aborts
32217 to the Emacs command loop with a beep and an error message.
32218
32219 If you bind this variable to the symbol @code{string}, error messages
32220 are returned as strings instead of lists. The character position is
32221 ignored.
32222
32223 As a courtesy to other Lisp code which may be using Calc, be sure
32224 to bind @code{calc-eval-error} using @code{let} rather than changing
32225 it permanently with @code{setq}.
32226
32227 @ifinfo
32228 @example
32229
32230 @end example
32231 @end ifinfo
32232 @subsubsection Numbers Only
32233
32234 @noindent
32235 Sometimes it is preferable to treat @samp{1 / 0} as an error
32236 rather than returning a symbolic result. If you pass the symbol
32237 @code{num} as the second argument to @code{calc-eval}, results
32238 that are not constants are treated as errors. The error message
32239 reported is the first @code{calc-why} message if there is one,
32240 or otherwise ``Number expected.''
32241
32242 A result is ``constant'' if it is a number, vector, or other
32243 object that does not include variables or function calls. If it
32244 is a vector, the components must themselves be constants.
32245
32246 @ifinfo
32247 @example
32248
32249 @end example
32250 @end ifinfo
32251 @subsubsection Default Modes
32252
32253 @noindent
32254 If the first argument to @code{calc-eval} is a list whose first
32255 element is a formula string, then @code{calc-eval} sets all the
32256 various Calc modes to their default values while the formula is
32257 evaluated and formatted. For example, the precision is set to 12
32258 digits, digit grouping is turned off, and the Normal language
32259 mode is used.
32260
32261 This same principle applies to the other options discussed below.
32262 If the first argument would normally be @var{x}, then it can also
32263 be the list @samp{(@var{x})} to use the default mode settings.
32264
32265 If there are other elements in the list, they are taken as
32266 variable-name/value pairs which override the default mode
32267 settings. Look at the documentation at the front of the
32268 @file{calc.el} file to find the names of the Lisp variables for
32269 the various modes. The mode settings are restored to their
32270 original values when @code{calc-eval} is done.
32271
32272 For example, @samp{(calc-eval '("$+$$" calc-internal-prec 8) 'num a b)}
32273 computes the sum of two numbers, requiring a numeric result, and
32274 using default mode settings except that the precision is 8 instead
32275 of the default of 12.
32276
32277 It's usually best to use this form of @code{calc-eval} unless your
32278 program actually considers the interaction with Calc's mode settings
32279 to be a feature. This will avoid all sorts of potential ``gotchas'';
32280 consider what happens with @samp{(calc-eval "sqrt(2)" 'num)}
32281 when the user has left Calc in Symbolic mode or No-Simplify mode.
32282
32283 As another example, @samp{(equal (calc-eval '("$<$$") nil a b) "1")}
32284 checks if the number in string @expr{a} is less than the one in
32285 string @expr{b}. Without using a list, the integer 1 might
32286 come out in a variety of formats which would be hard to test for
32287 conveniently: @code{"1"}, @code{"8#1"}, @code{"00001"}. (But
32288 see ``Predicates'' mode, below.)
32289
32290 @ifinfo
32291 @example
32292
32293 @end example
32294 @end ifinfo
32295 @subsubsection Raw Numbers
32296
32297 @noindent
32298 Normally all input and output for @code{calc-eval} is done with strings.
32299 You can do arithmetic with, say, @samp{(calc-eval "$+$$" nil a b)}
32300 in place of @samp{(+ a b)}, but this is very inefficient since the
32301 numbers must be converted to and from string format as they are passed
32302 from one @code{calc-eval} to the next.
32303
32304 If the separator is the symbol @code{raw}, the result will be returned
32305 as a raw Calc data structure rather than a string. You can read about
32306 how these objects look in the following sections, but usually you can
32307 treat them as ``black box'' objects with no important internal
32308 structure.
32309
32310 There is also a @code{rawnum} symbol, which is a combination of
32311 @code{raw} (returning a raw Calc object) and @code{num} (signaling
32312 an error if that object is not a constant).
32313
32314 You can pass a raw Calc object to @code{calc-eval} in place of a
32315 string, either as the formula itself or as one of the @samp{$}
32316 arguments. Thus @samp{(calc-eval "$+$$" 'raw a b)} is an
32317 addition function that operates on raw Calc objects. Of course
32318 in this case it would be easier to call the low-level @code{math-add}
32319 function in Calc, if you can remember its name.
32320
32321 In particular, note that a plain Lisp integer is acceptable to Calc
32322 as a raw object. (All Lisp integers are accepted on input, but
32323 integers of more than six decimal digits are converted to ``big-integer''
32324 form for output. @xref{Data Type Formats}.)
32325
32326 When it comes time to display the object, just use @samp{(calc-eval a)}
32327 to format it as a string.
32328
32329 It is an error if the input expression evaluates to a list of
32330 values. The separator symbol @code{list} is like @code{raw}
32331 except that it returns a list of one or more raw Calc objects.
32332
32333 Note that a Lisp string is not a valid Calc object, nor is a list
32334 containing a string. Thus you can still safely distinguish all the
32335 various kinds of error returns discussed above.
32336
32337 @ifinfo
32338 @example
32339
32340 @end example
32341 @end ifinfo
32342 @subsubsection Predicates
32343
32344 @noindent
32345 If the separator symbol is @code{pred}, the result of the formula is
32346 treated as a true/false value; @code{calc-eval} returns @code{t} or
32347 @code{nil}, respectively. A value is considered ``true'' if it is a
32348 non-zero number, or false if it is zero or if it is not a number.
32349
32350 For example, @samp{(calc-eval "$<$$" 'pred a b)} tests whether
32351 one value is less than another.
32352
32353 As usual, it is also possible for @code{calc-eval} to return one of
32354 the error indicators described above. Lisp will interpret such an
32355 indicator as ``true'' if you don't check for it explicitly. If you
32356 wish to have an error register as ``false'', use something like
32357 @samp{(eq (calc-eval ...) t)}.
32358
32359 @ifinfo
32360 @example
32361
32362 @end example
32363 @end ifinfo
32364 @subsubsection Variable Values
32365
32366 @noindent
32367 Variables in the formula passed to @code{calc-eval} are not normally
32368 replaced by their values. If you wish this, you can use the
32369 @code{evalv} function (@pxref{Algebraic Manipulation}). For example,
32370 if 4 is stored in Calc variable @code{a} (i.e., in Lisp variable
32371 @code{var-a}), then @samp{(calc-eval "a+pi")} will return the
32372 formula @code{"a + pi"}, but @samp{(calc-eval "evalv(a+pi)")}
32373 will return @code{"7.14159265359"}.
32374
32375 To store in a Calc variable, just use @code{setq} to store in the
32376 corresponding Lisp variable. (This is obtained by prepending
32377 @samp{var-} to the Calc variable name.) Calc routines will
32378 understand either string or raw form values stored in variables,
32379 although raw data objects are much more efficient. For example,
32380 to increment the Calc variable @code{a}:
32381
32382 @example
32383 (setq var-a (calc-eval "evalv(a+1)" 'raw))
32384 @end example
32385
32386 @ifinfo
32387 @example
32388
32389 @end example
32390 @end ifinfo
32391 @subsubsection Stack Access
32392
32393 @noindent
32394 If the separator symbol is @code{push}, the formula argument is
32395 evaluated (with possible @samp{$} expansions, as usual). The
32396 result is pushed onto the Calc stack. The return value is @code{nil}
32397 (unless there is an error from evaluating the formula, in which
32398 case the return value depends on @code{calc-eval-error} in the
32399 usual way).
32400
32401 If the separator symbol is @code{pop}, the first argument to
32402 @code{calc-eval} must be an integer instead of a string. That
32403 many values are popped from the stack and thrown away. A negative
32404 argument deletes the entry at that stack level. The return value
32405 is the number of elements remaining in the stack after popping;
32406 @samp{(calc-eval 0 'pop)} is a good way to measure the size of
32407 the stack.
32408
32409 If the separator symbol is @code{top}, the first argument to
32410 @code{calc-eval} must again be an integer. The value at that
32411 stack level is formatted as a string and returned. Thus
32412 @samp{(calc-eval 1 'top)} returns the top-of-stack value. If the
32413 integer is out of range, @code{nil} is returned.
32414
32415 The separator symbol @code{rawtop} is just like @code{top} except
32416 that the stack entry is returned as a raw Calc object instead of
32417 as a string.
32418
32419 In all of these cases the first argument can be made a list in
32420 order to force the default mode settings, as described above.
32421 Thus @samp{(calc-eval '(2 calc-number-radix 16) 'top)} returns the
32422 second-to-top stack entry, formatted as a string using the default
32423 instead of current display modes, except that the radix is
32424 hexadecimal instead of decimal.
32425
32426 It is, of course, polite to put the Calc stack back the way you
32427 found it when you are done, unless the user of your program is
32428 actually expecting it to affect the stack.
32429
32430 Note that you do not actually have to switch into the @samp{*Calculator*}
32431 buffer in order to use @code{calc-eval}; it temporarily switches into
32432 the stack buffer if necessary.
32433
32434 @ifinfo
32435 @example
32436
32437 @end example
32438 @end ifinfo
32439 @subsubsection Keyboard Macros
32440
32441 @noindent
32442 If the separator symbol is @code{macro}, the first argument must be a
32443 string of characters which Calc can execute as a sequence of keystrokes.
32444 This switches into the Calc buffer for the duration of the macro.
32445 For example, @samp{(calc-eval "vx5\rVR+" 'macro)} pushes the
32446 vector @samp{[1,2,3,4,5]} on the stack and then replaces it
32447 with the sum of those numbers. Note that @samp{\r} is the Lisp
32448 notation for the carriage-return, @key{RET}, character.
32449
32450 If your keyboard macro wishes to pop the stack, @samp{\C-d} is
32451 safer than @samp{\177} (the @key{DEL} character) because some
32452 installations may have switched the meanings of @key{DEL} and
32453 @kbd{C-h}. Calc always interprets @kbd{C-d} as a synonym for
32454 ``pop-stack'' regardless of key mapping.
32455
32456 If you provide a third argument to @code{calc-eval}, evaluation
32457 of the keyboard macro will leave a record in the Trail using
32458 that argument as a tag string. Normally the Trail is unaffected.
32459
32460 The return value in this case is always @code{nil}.
32461
32462 @ifinfo
32463 @example
32464
32465 @end example
32466 @end ifinfo
32467 @subsubsection Lisp Evaluation
32468
32469 @noindent
32470 Finally, if the separator symbol is @code{eval}, then the Lisp
32471 @code{eval} function is called on the first argument, which must
32472 be a Lisp expression rather than a Calc formula. Remember to
32473 quote the expression so that it is not evaluated until inside
32474 @code{calc-eval}.
32475
32476 The difference from plain @code{eval} is that @code{calc-eval}
32477 switches to the Calc buffer before evaluating the expression.
32478 For example, @samp{(calc-eval '(setq calc-internal-prec 17) 'eval)}
32479 will correctly affect the buffer-local Calc precision variable.
32480
32481 An alternative would be @samp{(calc-eval '(calc-precision 17) 'eval)}.
32482 This is evaluating a call to the function that is normally invoked
32483 by the @kbd{p} key, giving it 17 as its ``numeric prefix argument.''
32484 Note that this function will leave a message in the echo area as
32485 a side effect. Also, all Calc functions switch to the Calc buffer
32486 automatically if not invoked from there, so the above call is
32487 also equivalent to @samp{(calc-precision 17)} by itself.
32488 In all cases, Calc uses @code{save-excursion} to switch back to
32489 your original buffer when it is done.
32490
32491 As usual the first argument can be a list that begins with a Lisp
32492 expression to use default instead of current mode settings.
32493
32494 The result of @code{calc-eval} in this usage is just the result
32495 returned by the evaluated Lisp expression.
32496
32497 @ifinfo
32498 @example
32499
32500 @end example
32501 @end ifinfo
32502 @subsubsection Example
32503
32504 @noindent
32505 @findex convert-temp
32506 Here is a sample Emacs command that uses @code{calc-eval}. Suppose
32507 you have a document with lots of references to temperatures on the
32508 Fahrenheit scale, say ``98.6 F'', and you wish to convert these
32509 references to Centigrade. The following command does this conversion.
32510 Place the Emacs cursor right after the letter ``F'' and invoke the
32511 command to change ``98.6 F'' to ``37 C''. Or, if the temperature is
32512 already in Centigrade form, the command changes it back to Fahrenheit.
32513
32514 @example
32515 (defun convert-temp ()
32516 (interactive)
32517 (save-excursion
32518 (re-search-backward "[^-.0-9]\\([-.0-9]+\\) *\\([FC]\\)")
32519 (let* ((top1 (match-beginning 1))
32520 (bot1 (match-end 1))
32521 (number (buffer-substring top1 bot1))
32522 (top2 (match-beginning 2))
32523 (bot2 (match-end 2))
32524 (type (buffer-substring top2 bot2)))
32525 (if (equal type "F")
32526 (setq type "C"
32527 number (calc-eval "($ - 32)*5/9" nil number))
32528 (setq type "F"
32529 number (calc-eval "$*9/5 + 32" nil number)))
32530 (goto-char top2)
32531 (delete-region top2 bot2)
32532 (insert-before-markers type)
32533 (goto-char top1)
32534 (delete-region top1 bot1)
32535 (if (string-match "\\.$" number) ; change "37." to "37"
32536 (setq number (substring number 0 -1)))
32537 (insert number))))
32538 @end example
32539
32540 Note the use of @code{insert-before-markers} when changing between
32541 ``F'' and ``C'', so that the character winds up before the cursor
32542 instead of after it.
32543
32544 @node Internals, , Calling Calc from Your Programs, Lisp Definitions
32545 @subsection Calculator Internals
32546
32547 @noindent
32548 This section describes the Lisp functions defined by the Calculator that
32549 may be of use to user-written Calculator programs (as described in the
32550 rest of this chapter). These functions are shown by their names as they
32551 conventionally appear in @code{defmath}. Their full Lisp names are
32552 generally gotten by prepending @samp{calcFunc-} or @samp{math-} to their
32553 apparent names. (Names that begin with @samp{calc-} are already in
32554 their full Lisp form.) You can use the actual full names instead if you
32555 prefer them, or if you are calling these functions from regular Lisp.
32556
32557 The functions described here are scattered throughout the various
32558 Calc component files. Note that @file{calc.el} includes @code{autoload}s
32559 for only a few component files; when Calc wants to call an advanced
32560 function it calls @samp{(calc-extensions)} first; this function
32561 autoloads @file{calc-ext.el}, which in turn autoloads all the functions
32562 in the remaining component files.
32563
32564 Because @code{defmath} itself uses the extensions, user-written code
32565 generally always executes with the extensions already loaded, so
32566 normally you can use any Calc function and be confident that it will
32567 be autoloaded for you when necessary. If you are doing something
32568 special, check carefully to make sure each function you are using is
32569 from @file{calc.el} or its components, and call @samp{(calc-extensions)}
32570 before using any function based in @file{calc-ext.el} if you can't
32571 prove this file will already be loaded.
32572
32573 @menu
32574 * Data Type Formats::
32575 * Interactive Lisp Functions::
32576 * Stack Lisp Functions::
32577 * Predicates::
32578 * Computational Lisp Functions::
32579 * Vector Lisp Functions::
32580 * Symbolic Lisp Functions::
32581 * Formatting Lisp Functions::
32582 * Hooks::
32583 @end menu
32584
32585 @node Data Type Formats, Interactive Lisp Functions, Internals, Internals
32586 @subsubsection Data Type Formats
32587
32588 @noindent
32589 Integers are stored in either of two ways, depending on their magnitude.
32590 Integers less than one million in absolute value are stored as standard
32591 Lisp integers. This is the only storage format for Calc data objects
32592 which is not a Lisp list.
32593
32594 Large integers are stored as lists of the form @samp{(bigpos @var{d0}
32595 @var{d1} @var{d2} @dots{})} for positive integers 1000000 or more, or
32596 @samp{(bigneg @var{d0} @var{d1} @var{d2} @dots{})} for negative integers
32597 @mathit{-1000000} or less. Each @var{d} is a base-1000 ``digit,'' a Lisp integer
32598 from 0 to 999. The least significant digit is @var{d0}; the last digit,
32599 @var{dn}, which is always nonzero, is the most significant digit. For
32600 example, the integer @mathit{-12345678} is stored as @samp{(bigneg 678 345 12)}.
32601
32602 The distinction between small and large integers is entirely hidden from
32603 the user. In @code{defmath} definitions, the Lisp predicate @code{integerp}
32604 returns true for either kind of integer, and in general both big and small
32605 integers are accepted anywhere the word ``integer'' is used in this manual.
32606 If the distinction must be made, native Lisp integers are called @dfn{fixnums}
32607 and large integers are called @dfn{bignums}.
32608
32609 Fractions are stored as a list of the form, @samp{(frac @var{n} @var{d})}
32610 where @var{n} is an integer (big or small) numerator, @var{d} is an
32611 integer denominator greater than one, and @var{n} and @var{d} are relatively
32612 prime. Note that fractions where @var{d} is one are automatically converted
32613 to plain integers by all math routines; fractions where @var{d} is negative
32614 are normalized by negating the numerator and denominator.
32615
32616 Floating-point numbers are stored in the form, @samp{(float @var{mant}
32617 @var{exp})}, where @var{mant} (the ``mantissa'') is an integer less than
32618 @samp{10^@var{p}} in absolute value (@var{p} represents the current
32619 precision), and @var{exp} (the ``exponent'') is a fixnum. The value of
32620 the float is @samp{@var{mant} * 10^@var{exp}}. For example, the number
32621 @mathit{-3.14} is stored as @samp{(float -314 -2) = -314*10^-2}. Other constraints
32622 are that the number 0.0 is always stored as @samp{(float 0 0)}, and,
32623 except for the 0.0 case, the rightmost base-10 digit of @var{mant} is
32624 always nonzero. (If the rightmost digit is zero, the number is
32625 rearranged by dividing @var{mant} by ten and incrementing @var{exp}.)
32626
32627 Rectangular complex numbers are stored in the form @samp{(cplx @var{re}
32628 @var{im})}, where @var{re} and @var{im} are each real numbers, either
32629 integers, fractions, or floats. The value is @samp{@var{re} + @var{im}i}.
32630 The @var{im} part is nonzero; complex numbers with zero imaginary
32631 components are converted to real numbers automatically.
32632
32633 Polar complex numbers are stored in the form @samp{(polar @var{r}
32634 @var{theta})}, where @var{r} is a positive real value and @var{theta}
32635 is a real value or HMS form representing an angle. This angle is
32636 usually normalized to lie in the interval @samp{(-180 ..@: 180)} degrees,
32637 or @samp{(-pi ..@: pi)} radians, according to the current angular mode.
32638 If the angle is 0 the value is converted to a real number automatically.
32639 (If the angle is 180 degrees, the value is usually also converted to a
32640 negative real number.)
32641
32642 Hours-minutes-seconds forms are stored as @samp{(hms @var{h} @var{m}
32643 @var{s})}, where @var{h} is an integer or an integer-valued float (i.e.,
32644 a float with @samp{@var{exp} >= 0}), @var{m} is an integer or integer-valued
32645 float in the range @w{@samp{[0 ..@: 60)}}, and @var{s} is any real number
32646 in the range @samp{[0 ..@: 60)}.
32647
32648 Date forms are stored as @samp{(date @var{n})}, where @var{n} is
32649 a real number that counts days since midnight on the morning of
32650 January 1, 1 AD. If @var{n} is an integer, this is a pure date
32651 form. If @var{n} is a fraction or float, this is a date/time form.
32652
32653 Modulo forms are stored as @samp{(mod @var{n} @var{m})}, where @var{m} is a
32654 positive real number or HMS form, and @var{n} is a real number or HMS
32655 form in the range @samp{[0 ..@: @var{m})}.
32656
32657 Error forms are stored as @samp{(sdev @var{x} @var{sigma})}, where @var{x}
32658 is the mean value and @var{sigma} is the standard deviation. Each
32659 component is either a number, an HMS form, or a symbolic object
32660 (a variable or function call). If @var{sigma} is zero, the value is
32661 converted to a plain real number. If @var{sigma} is negative or
32662 complex, it is automatically normalized to be a positive real.
32663
32664 Interval forms are stored as @samp{(intv @var{mask} @var{lo} @var{hi})},
32665 where @var{mask} is one of the integers 0, 1, 2, or 3, and @var{lo} and
32666 @var{hi} are real numbers, HMS forms, or symbolic objects. The @var{mask}
32667 is a binary integer where 1 represents the fact that the interval is
32668 closed on the high end, and 2 represents the fact that it is closed on
32669 the low end. (Thus 3 represents a fully closed interval.) The interval
32670 @w{@samp{(intv 3 @var{x} @var{x})}} is converted to the plain number @var{x};
32671 intervals @samp{(intv @var{mask} @var{x} @var{x})} for any other @var{mask}
32672 represent empty intervals. If @var{hi} is less than @var{lo}, the interval
32673 is converted to a standard empty interval by replacing @var{hi} with @var{lo}.
32674
32675 Vectors are stored as @samp{(vec @var{v1} @var{v2} @dots{})}, where @var{v1}
32676 is the first element of the vector, @var{v2} is the second, and so on.
32677 An empty vector is stored as @samp{(vec)}. A matrix is simply a vector
32678 where all @var{v}'s are themselves vectors of equal lengths. Note that
32679 Calc vectors are unrelated to the Emacs Lisp ``vector'' type, which is
32680 generally unused by Calc data structures.
32681
32682 Variables are stored as @samp{(var @var{name} @var{sym})}, where
32683 @var{name} is a Lisp symbol whose print name is used as the visible name
32684 of the variable, and @var{sym} is a Lisp symbol in which the variable's
32685 value is actually stored. Thus, @samp{(var pi var-pi)} represents the
32686 special constant @samp{pi}. Almost always, the form is @samp{(var
32687 @var{v} var-@var{v})}. If the variable name was entered with @code{#}
32688 signs (which are converted to hyphens internally), the form is
32689 @samp{(var @var{u} @var{v})}, where @var{u} is a symbol whose name
32690 contains @code{#} characters, and @var{v} is a symbol that contains
32691 @code{-} characters instead. The value of a variable is the Calc
32692 object stored in its @var{sym} symbol's value cell. If the symbol's
32693 value cell is void or if it contains @code{nil}, the variable has no
32694 value. Special constants have the form @samp{(special-const
32695 @var{value})} stored in their value cell, where @var{value} is a formula
32696 which is evaluated when the constant's value is requested. Variables
32697 which represent units are not stored in any special way; they are units
32698 only because their names appear in the units table. If the value
32699 cell contains a string, it is parsed to get the variable's value when
32700 the variable is used.
32701
32702 A Lisp list with any other symbol as the first element is a function call.
32703 The symbols @code{+}, @code{-}, @code{*}, @code{/}, @code{%}, @code{^},
32704 and @code{|} represent special binary operators; these lists are always
32705 of the form @samp{(@var{op} @var{lhs} @var{rhs})} where @var{lhs} is the
32706 sub-formula on the lefthand side and @var{rhs} is the sub-formula on the
32707 right. The symbol @code{neg} represents unary negation; this list is always
32708 of the form @samp{(neg @var{arg})}. Any other symbol @var{func} represents a
32709 function that would be displayed in function-call notation; the symbol
32710 @var{func} is in general always of the form @samp{calcFunc-@var{name}}.
32711 The function cell of the symbol @var{func} should contain a Lisp function
32712 for evaluating a call to @var{func}. This function is passed the remaining
32713 elements of the list (themselves already evaluated) as arguments; such
32714 functions should return @code{nil} or call @code{reject-arg} to signify
32715 that they should be left in symbolic form, or they should return a Calc
32716 object which represents their value, or a list of such objects if they
32717 wish to return multiple values. (The latter case is allowed only for
32718 functions which are the outer-level call in an expression whose value is
32719 about to be pushed on the stack; this feature is considered obsolete
32720 and is not used by any built-in Calc functions.)
32721
32722 @node Interactive Lisp Functions, Stack Lisp Functions, Data Type Formats, Internals
32723 @subsubsection Interactive Functions
32724
32725 @noindent
32726 The functions described here are used in implementing interactive Calc
32727 commands. Note that this list is not exhaustive! If there is an
32728 existing command that behaves similarly to the one you want to define,
32729 you may find helpful tricks by checking the source code for that command.
32730
32731 @defun calc-set-command-flag flag
32732 Set the command flag @var{flag}. This is generally a Lisp symbol, but
32733 may in fact be anything. The effect is to add @var{flag} to the list
32734 stored in the variable @code{calc-command-flags}, unless it is already
32735 there. @xref{Defining Simple Commands}.
32736 @end defun
32737
32738 @defun calc-clear-command-flag flag
32739 If @var{flag} appears among the list of currently-set command flags,
32740 remove it from that list.
32741 @end defun
32742
32743 @defun calc-record-undo rec
32744 Add the ``undo record'' @var{rec} to the list of steps to take if the
32745 current operation should need to be undone. Stack push and pop functions
32746 automatically call @code{calc-record-undo}, so the kinds of undo records
32747 you might need to create take the form @samp{(set @var{sym} @var{value})},
32748 which says that the Lisp variable @var{sym} was changed and had previously
32749 contained @var{value}; @samp{(store @var{var} @var{value})} which says that
32750 the Calc variable @var{var} (a string which is the name of the symbol that
32751 contains the variable's value) was stored and its previous value was
32752 @var{value} (either a Calc data object, or @code{nil} if the variable was
32753 previously void); or @samp{(eval @var{undo} @var{redo} @var{args} @dots{})},
32754 which means that to undo requires calling the function @samp{(@var{undo}
32755 @var{args} @dots{})} and, if the undo is later redone, calling
32756 @samp{(@var{redo} @var{args} @dots{})}.
32757 @end defun
32758
32759 @defun calc-record-why msg args
32760 Record the error or warning message @var{msg}, which is normally a string.
32761 This message will be replayed if the user types @kbd{w} (@code{calc-why});
32762 if the message string begins with a @samp{*}, it is considered important
32763 enough to display even if the user doesn't type @kbd{w}. If one or more
32764 @var{args} are present, the displayed message will be of the form,
32765 @samp{@var{msg}: @var{arg1}, @var{arg2}, @dots{}}, where the arguments are
32766 formatted on the assumption that they are either strings or Calc objects of
32767 some sort. If @var{msg} is a symbol, it is the name of a Calc predicate
32768 (such as @code{integerp} or @code{numvecp}) which the arguments did not
32769 satisfy; it is expanded to a suitable string such as ``Expected an
32770 integer.'' The @code{reject-arg} function calls @code{calc-record-why}
32771 automatically; @pxref{Predicates}.
32772 @end defun
32773
32774 @defun calc-is-inverse
32775 This predicate returns true if the current command is inverse,
32776 i.e., if the Inverse (@kbd{I} key) flag was set.
32777 @end defun
32778
32779 @defun calc-is-hyperbolic
32780 This predicate is the analogous function for the @kbd{H} key.
32781 @end defun
32782
32783 @node Stack Lisp Functions, Predicates, Interactive Lisp Functions, Internals
32784 @subsubsection Stack-Oriented Functions
32785
32786 @noindent
32787 The functions described here perform various operations on the Calc
32788 stack and trail. They are to be used in interactive Calc commands.
32789
32790 @defun calc-push-list vals n
32791 Push the Calc objects in list @var{vals} onto the stack at stack level
32792 @var{n}. If @var{n} is omitted it defaults to 1, so that the elements
32793 are pushed at the top of the stack. If @var{n} is greater than 1, the
32794 elements will be inserted into the stack so that the last element will
32795 end up at level @var{n}, the next-to-last at level @var{n}+1, etc.
32796 The elements of @var{vals} are assumed to be valid Calc objects, and
32797 are not evaluated, rounded, or renormalized in any way. If @var{vals}
32798 is an empty list, nothing happens.
32799
32800 The stack elements are pushed without any sub-formula selections.
32801 You can give an optional third argument to this function, which must
32802 be a list the same size as @var{vals} of selections. Each selection
32803 must be @code{eq} to some sub-formula of the corresponding formula
32804 in @var{vals}, or @code{nil} if that formula should have no selection.
32805 @end defun
32806
32807 @defun calc-top-list n m
32808 Return a list of the @var{n} objects starting at level @var{m} of the
32809 stack. If @var{m} is omitted it defaults to 1, so that the elements are
32810 taken from the top of the stack. If @var{n} is omitted, it also
32811 defaults to 1, so that the top stack element (in the form of a
32812 one-element list) is returned. If @var{m} is greater than 1, the
32813 @var{m}th stack element will be at the end of the list, the @var{m}+1st
32814 element will be next-to-last, etc. If @var{n} or @var{m} are out of
32815 range, the command is aborted with a suitable error message. If @var{n}
32816 is zero, the function returns an empty list. The stack elements are not
32817 evaluated, rounded, or renormalized.
32818
32819 If any stack elements contain selections, and selections have not
32820 been disabled by the @kbd{j e} (@code{calc-enable-selections}) command,
32821 this function returns the selected portions rather than the entire
32822 stack elements. It can be given a third ``selection-mode'' argument
32823 which selects other behaviors. If it is the symbol @code{t}, then
32824 a selection in any of the requested stack elements produces an
32825 ``invalid operation on selections'' error. If it is the symbol @code{full},
32826 the whole stack entry is always returned regardless of selections.
32827 If it is the symbol @code{sel}, the selected portion is always returned,
32828 or @code{nil} if there is no selection. (This mode ignores the @kbd{j e}
32829 command.) If the symbol is @code{entry}, the complete stack entry in
32830 list form is returned; the first element of this list will be the whole
32831 formula, and the third element will be the selection (or @code{nil}).
32832 @end defun
32833
32834 @defun calc-pop-stack n m
32835 Remove the specified elements from the stack. The parameters @var{n}
32836 and @var{m} are defined the same as for @code{calc-top-list}. The return
32837 value of @code{calc-pop-stack} is uninteresting.
32838
32839 If there are any selected sub-formulas among the popped elements, and
32840 @kbd{j e} has not been used to disable selections, this produces an
32841 error without changing the stack. If you supply an optional third
32842 argument of @code{t}, the stack elements are popped even if they
32843 contain selections.
32844 @end defun
32845
32846 @defun calc-record-list vals tag
32847 This function records one or more results in the trail. The @var{vals}
32848 are a list of strings or Calc objects. The @var{tag} is the four-character
32849 tag string to identify the values. If @var{tag} is omitted, a blank tag
32850 will be used.
32851 @end defun
32852
32853 @defun calc-normalize n
32854 This function takes a Calc object and ``normalizes'' it. At the very
32855 least this involves re-rounding floating-point values according to the
32856 current precision and other similar jobs. Also, unless the user has
32857 selected No-Simplify mode (@pxref{Simplification Modes}), this involves
32858 actually evaluating a formula object by executing the function calls
32859 it contains, and possibly also doing algebraic simplification, etc.
32860 @end defun
32861
32862 @defun calc-top-list-n n m
32863 This function is identical to @code{calc-top-list}, except that it calls
32864 @code{calc-normalize} on the values that it takes from the stack. They
32865 are also passed through @code{check-complete}, so that incomplete
32866 objects will be rejected with an error message. All computational
32867 commands should use this in preference to @code{calc-top-list}; the only
32868 standard Calc commands that operate on the stack without normalizing
32869 are stack management commands like @code{calc-enter} and @code{calc-roll-up}.
32870 This function accepts the same optional selection-mode argument as
32871 @code{calc-top-list}.
32872 @end defun
32873
32874 @defun calc-top-n m
32875 This function is a convenient form of @code{calc-top-list-n} in which only
32876 a single element of the stack is taken and returned, rather than a list
32877 of elements. This also accepts an optional selection-mode argument.
32878 @end defun
32879
32880 @defun calc-enter-result n tag vals
32881 This function is a convenient interface to most of the above functions.
32882 The @var{vals} argument should be either a single Calc object, or a list
32883 of Calc objects; the object or objects are normalized, and the top @var{n}
32884 stack entries are replaced by the normalized objects. If @var{tag} is
32885 non-@code{nil}, the normalized objects are also recorded in the trail.
32886 A typical stack-based computational command would take the form,
32887
32888 @smallexample
32889 (calc-enter-result @var{n} @var{tag} (cons 'calcFunc-@var{func}
32890 (calc-top-list-n @var{n})))
32891 @end smallexample
32892
32893 If any of the @var{n} stack elements replaced contain sub-formula
32894 selections, and selections have not been disabled by @kbd{j e},
32895 this function takes one of two courses of action. If @var{n} is
32896 equal to the number of elements in @var{vals}, then each element of
32897 @var{vals} is spliced into the corresponding selection; this is what
32898 happens when you use the @key{TAB} key, or when you use a unary
32899 arithmetic operation like @code{sqrt}. If @var{vals} has only one
32900 element but @var{n} is greater than one, there must be only one
32901 selection among the top @var{n} stack elements; the element from
32902 @var{vals} is spliced into that selection. This is what happens when
32903 you use a binary arithmetic operation like @kbd{+}. Any other
32904 combination of @var{n} and @var{vals} is an error when selections
32905 are present.
32906 @end defun
32907
32908 @defun calc-unary-op tag func arg
32909 This function implements a unary operator that allows a numeric prefix
32910 argument to apply the operator over many stack entries. If the prefix
32911 argument @var{arg} is @code{nil}, this uses @code{calc-enter-result}
32912 as outlined above. Otherwise, it maps the function over several stack
32913 elements; @pxref{Prefix Arguments}. For example,
32914
32915 @smallexample
32916 (defun calc-zeta (arg)
32917 (interactive "P")
32918 (calc-unary-op "zeta" 'calcFunc-zeta arg))
32919 @end smallexample
32920 @end defun
32921
32922 @defun calc-binary-op tag func arg ident unary
32923 This function implements a binary operator, analogously to
32924 @code{calc-unary-op}. The optional @var{ident} and @var{unary}
32925 arguments specify the behavior when the prefix argument is zero or
32926 one, respectively. If the prefix is zero, the value @var{ident}
32927 is pushed onto the stack, if specified, otherwise an error message
32928 is displayed. If the prefix is one, the unary function @var{unary}
32929 is applied to the top stack element, or, if @var{unary} is not
32930 specified, nothing happens. When the argument is two or more,
32931 the binary function @var{func} is reduced across the top @var{arg}
32932 stack elements; when the argument is negative, the function is
32933 mapped between the next-to-top @mathit{-@var{arg}} stack elements and the
32934 top element.
32935 @end defun
32936
32937 @defun calc-stack-size
32938 Return the number of elements on the stack as an integer. This count
32939 does not include elements that have been temporarily hidden by stack
32940 truncation; @pxref{Truncating the Stack}.
32941 @end defun
32942
32943 @defun calc-cursor-stack-index n
32944 Move the point to the @var{n}th stack entry. If @var{n} is zero, this
32945 will be the @samp{.} line. If @var{n} is from 1 to the current stack size,
32946 this will be the beginning of the first line of that stack entry's display.
32947 If line numbers are enabled, this will move to the first character of the
32948 line number, not the stack entry itself.
32949 @end defun
32950
32951 @defun calc-substack-height n
32952 Return the number of lines between the beginning of the @var{n}th stack
32953 entry and the bottom of the buffer. If @var{n} is zero, this
32954 will be one (assuming no stack truncation). If all stack entries are
32955 one line long (i.e., no matrices are displayed), the return value will
32956 be equal @var{n}+1 as long as @var{n} is in range. (Note that in Big
32957 mode, the return value includes the blank lines that separate stack
32958 entries.)
32959 @end defun
32960
32961 @defun calc-refresh
32962 Erase the @code{*Calculator*} buffer and reformat its contents from memory.
32963 This must be called after changing any parameter, such as the current
32964 display radix, which might change the appearance of existing stack
32965 entries. (During a keyboard macro invoked by the @kbd{X} key, refreshing
32966 is suppressed, but a flag is set so that the entire stack will be refreshed
32967 rather than just the top few elements when the macro finishes.)
32968 @end defun
32969
32970 @node Predicates, Computational Lisp Functions, Stack Lisp Functions, Internals
32971 @subsubsection Predicates
32972
32973 @noindent
32974 The functions described here are predicates, that is, they return a
32975 true/false value where @code{nil} means false and anything else means
32976 true. These predicates are expanded by @code{defmath}, for example,
32977 from @code{zerop} to @code{math-zerop}. In many cases they correspond
32978 to native Lisp functions by the same name, but are extended to cover
32979 the full range of Calc data types.
32980
32981 @defun zerop x
32982 Returns true if @var{x} is numerically zero, in any of the Calc data
32983 types. (Note that for some types, such as error forms and intervals,
32984 it never makes sense to return true.) In @code{defmath}, the expression
32985 @samp{(= x 0)} will automatically be converted to @samp{(math-zerop x)},
32986 and @samp{(/= x 0)} will be converted to @samp{(not (math-zerop x))}.
32987 @end defun
32988
32989 @defun negp x
32990 Returns true if @var{x} is negative. This accepts negative real numbers
32991 of various types, negative HMS and date forms, and intervals in which
32992 all included values are negative. In @code{defmath}, the expression
32993 @samp{(< x 0)} will automatically be converted to @samp{(math-negp x)},
32994 and @samp{(>= x 0)} will be converted to @samp{(not (math-negp x))}.
32995 @end defun
32996
32997 @defun posp x
32998 Returns true if @var{x} is positive (and non-zero). For complex
32999 numbers, none of these three predicates will return true.
33000 @end defun
33001
33002 @defun looks-negp x
33003 Returns true if @var{x} is ``negative-looking.'' This returns true if
33004 @var{x} is a negative number, or a formula with a leading minus sign
33005 such as @samp{-a/b}. In other words, this is an object which can be
33006 made simpler by calling @code{(- @var{x})}.
33007 @end defun
33008
33009 @defun integerp x
33010 Returns true if @var{x} is an integer of any size.
33011 @end defun
33012
33013 @defun fixnump x
33014 Returns true if @var{x} is a native Lisp integer.
33015 @end defun
33016
33017 @defun natnump x
33018 Returns true if @var{x} is a nonnegative integer of any size.
33019 @end defun
33020
33021 @defun fixnatnump x
33022 Returns true if @var{x} is a nonnegative Lisp integer.
33023 @end defun
33024
33025 @defun num-integerp x
33026 Returns true if @var{x} is numerically an integer, i.e., either a
33027 true integer or a float with no significant digits to the right of
33028 the decimal point.
33029 @end defun
33030
33031 @defun messy-integerp x
33032 Returns true if @var{x} is numerically, but not literally, an integer.
33033 A value is @code{num-integerp} if it is @code{integerp} or
33034 @code{messy-integerp} (but it is never both at once).
33035 @end defun
33036
33037 @defun num-natnump x
33038 Returns true if @var{x} is numerically a nonnegative integer.
33039 @end defun
33040
33041 @defun evenp x
33042 Returns true if @var{x} is an even integer.
33043 @end defun
33044
33045 @defun looks-evenp x
33046 Returns true if @var{x} is an even integer, or a formula with a leading
33047 multiplicative coefficient which is an even integer.
33048 @end defun
33049
33050 @defun oddp x
33051 Returns true if @var{x} is an odd integer.
33052 @end defun
33053
33054 @defun ratp x
33055 Returns true if @var{x} is a rational number, i.e., an integer or a
33056 fraction.
33057 @end defun
33058
33059 @defun realp x
33060 Returns true if @var{x} is a real number, i.e., an integer, fraction,
33061 or floating-point number.
33062 @end defun
33063
33064 @defun anglep x
33065 Returns true if @var{x} is a real number or HMS form.
33066 @end defun
33067
33068 @defun floatp x
33069 Returns true if @var{x} is a float, or a complex number, error form,
33070 interval, date form, or modulo form in which at least one component
33071 is a float.
33072 @end defun
33073
33074 @defun complexp x
33075 Returns true if @var{x} is a rectangular or polar complex number
33076 (but not a real number).
33077 @end defun
33078
33079 @defun rect-complexp x
33080 Returns true if @var{x} is a rectangular complex number.
33081 @end defun
33082
33083 @defun polar-complexp x
33084 Returns true if @var{x} is a polar complex number.
33085 @end defun
33086
33087 @defun numberp x
33088 Returns true if @var{x} is a real number or a complex number.
33089 @end defun
33090
33091 @defun scalarp x
33092 Returns true if @var{x} is a real or complex number or an HMS form.
33093 @end defun
33094
33095 @defun vectorp x
33096 Returns true if @var{x} is a vector (this simply checks if its argument
33097 is a list whose first element is the symbol @code{vec}).
33098 @end defun
33099
33100 @defun numvecp x
33101 Returns true if @var{x} is a number or vector.
33102 @end defun
33103
33104 @defun matrixp x
33105 Returns true if @var{x} is a matrix, i.e., a vector of one or more vectors,
33106 all of the same size.
33107 @end defun
33108
33109 @defun square-matrixp x
33110 Returns true if @var{x} is a square matrix.
33111 @end defun
33112
33113 @defun objectp x
33114 Returns true if @var{x} is any numeric Calc object, including real and
33115 complex numbers, HMS forms, date forms, error forms, intervals, and
33116 modulo forms. (Note that error forms and intervals may include formulas
33117 as their components; see @code{constp} below.)
33118 @end defun
33119
33120 @defun objvecp x
33121 Returns true if @var{x} is an object or a vector. This also accepts
33122 incomplete objects, but it rejects variables and formulas (except as
33123 mentioned above for @code{objectp}).
33124 @end defun
33125
33126 @defun primp x
33127 Returns true if @var{x} is a ``primitive'' or ``atomic'' Calc object,
33128 i.e., one whose components cannot be regarded as sub-formulas. This
33129 includes variables, and all @code{objectp} types except error forms
33130 and intervals.
33131 @end defun
33132
33133 @defun constp x
33134 Returns true if @var{x} is constant, i.e., a real or complex number,
33135 HMS form, date form, or error form, interval, or vector all of whose
33136 components are @code{constp}.
33137 @end defun
33138
33139 @defun lessp x y
33140 Returns true if @var{x} is numerically less than @var{y}. Returns false
33141 if @var{x} is greater than or equal to @var{y}, or if the order is
33142 undefined or cannot be determined. Generally speaking, this works
33143 by checking whether @samp{@var{x} - @var{y}} is @code{negp}. In
33144 @code{defmath}, the expression @samp{(< x y)} will automatically be
33145 converted to @samp{(lessp x y)}; expressions involving @code{>}, @code{<=},
33146 and @code{>=} are similarly converted in terms of @code{lessp}.
33147 @end defun
33148
33149 @defun beforep x y
33150 Returns true if @var{x} comes before @var{y} in a canonical ordering
33151 of Calc objects. If @var{x} and @var{y} are both real numbers, this
33152 will be the same as @code{lessp}. But whereas @code{lessp} considers
33153 other types of objects to be unordered, @code{beforep} puts any two
33154 objects into a definite, consistent order. The @code{beforep}
33155 function is used by the @kbd{V S} vector-sorting command, and also
33156 by @kbd{a s} to put the terms of a product into canonical order:
33157 This allows @samp{x y + y x} to be simplified easily to @samp{2 x y}.
33158 @end defun
33159
33160 @defun equal x y
33161 This is the standard Lisp @code{equal} predicate; it returns true if
33162 @var{x} and @var{y} are structurally identical. This is the usual way
33163 to compare numbers for equality, but note that @code{equal} will treat
33164 0 and 0.0 as different.
33165 @end defun
33166
33167 @defun math-equal x y
33168 Returns true if @var{x} and @var{y} are numerically equal, either because
33169 they are @code{equal}, or because their difference is @code{zerop}. In
33170 @code{defmath}, the expression @samp{(= x y)} will automatically be
33171 converted to @samp{(math-equal x y)}.
33172 @end defun
33173
33174 @defun equal-int x n
33175 Returns true if @var{x} and @var{n} are numerically equal, where @var{n}
33176 is a fixnum which is not a multiple of 10. This will automatically be
33177 used by @code{defmath} in place of the more general @code{math-equal}
33178 whenever possible.
33179 @end defun
33180
33181 @defun nearly-equal x y
33182 Returns true if @var{x} and @var{y}, as floating-point numbers, are
33183 equal except possibly in the last decimal place. For example,
33184 314.159 and 314.166 are considered nearly equal if the current
33185 precision is 6 (since they differ by 7 units), but not if the current
33186 precision is 7 (since they differ by 70 units). Most functions which
33187 use series expansions use @code{with-extra-prec} to evaluate the
33188 series with 2 extra digits of precision, then use @code{nearly-equal}
33189 to decide when the series has converged; this guards against cumulative
33190 error in the series evaluation without doing extra work which would be
33191 lost when the result is rounded back down to the current precision.
33192 In @code{defmath}, this can be written @samp{(~= @var{x} @var{y})}.
33193 The @var{x} and @var{y} can be numbers of any kind, including complex.
33194 @end defun
33195
33196 @defun nearly-zerop x y
33197 Returns true if @var{x} is nearly zero, compared to @var{y}. This
33198 checks whether @var{x} plus @var{y} would by be @code{nearly-equal}
33199 to @var{y} itself, to within the current precision, in other words,
33200 if adding @var{x} to @var{y} would have a negligible effect on @var{y}
33201 due to roundoff error. @var{X} may be a real or complex number, but
33202 @var{y} must be real.
33203 @end defun
33204
33205 @defun is-true x
33206 Return true if the formula @var{x} represents a true value in
33207 Calc, not Lisp, terms. It tests if @var{x} is a non-zero number
33208 or a provably non-zero formula.
33209 @end defun
33210
33211 @defun reject-arg val pred
33212 Abort the current function evaluation due to unacceptable argument values.
33213 This calls @samp{(calc-record-why @var{pred} @var{val})}, then signals a
33214 Lisp error which @code{normalize} will trap. The net effect is that the
33215 function call which led here will be left in symbolic form.
33216 @end defun
33217
33218 @defun inexact-value
33219 If Symbolic mode is enabled, this will signal an error that causes
33220 @code{normalize} to leave the formula in symbolic form, with the message
33221 ``Inexact result.'' (This function has no effect when not in Symbolic mode.)
33222 Note that if your function calls @samp{(sin 5)} in Symbolic mode, the
33223 @code{sin} function will call @code{inexact-value}, which will cause your
33224 function to be left unsimplified. You may instead wish to call
33225 @samp{(normalize (list 'calcFunc-sin 5))}, which in Symbolic mode will
33226 return the formula @samp{sin(5)} to your function.
33227 @end defun
33228
33229 @defun overflow
33230 This signals an error that will be reported as a floating-point overflow.
33231 @end defun
33232
33233 @defun underflow
33234 This signals a floating-point underflow.
33235 @end defun
33236
33237 @node Computational Lisp Functions, Vector Lisp Functions, Predicates, Internals
33238 @subsubsection Computational Functions
33239
33240 @noindent
33241 The functions described here do the actual computational work of the
33242 Calculator. In addition to these, note that any function described in
33243 the main body of this manual may be called from Lisp; for example, if
33244 the documentation refers to the @code{calc-sqrt} [@code{sqrt}] command,
33245 this means @code{calc-sqrt} is an interactive stack-based square-root
33246 command and @code{sqrt} (which @code{defmath} expands to @code{calcFunc-sqrt})
33247 is the actual Lisp function for taking square roots.
33248
33249 The functions @code{math-add}, @code{math-sub}, @code{math-mul},
33250 @code{math-div}, @code{math-mod}, and @code{math-neg} are not included
33251 in this list, since @code{defmath} allows you to write native Lisp
33252 @code{+}, @code{-}, @code{*}, @code{/}, @code{%}, and unary @code{-},
33253 respectively, instead.
33254
33255 @defun normalize val
33256 (Full form: @code{math-normalize}.)
33257 Reduce the value @var{val} to standard form. For example, if @var{val}
33258 is a fixnum, it will be converted to a bignum if it is too large, and
33259 if @var{val} is a bignum it will be normalized by clipping off trailing
33260 (i.e., most-significant) zero digits and converting to a fixnum if it is
33261 small. All the various data types are similarly converted to their standard
33262 forms. Variables are left alone, but function calls are actually evaluated
33263 in formulas. For example, normalizing @samp{(+ 2 (calcFunc-abs -4))} will
33264 return 6.
33265
33266 If a function call fails, because the function is void or has the wrong
33267 number of parameters, or because it returns @code{nil} or calls
33268 @code{reject-arg} or @code{inexact-result}, @code{normalize} returns
33269 the formula still in symbolic form.
33270
33271 If the current simplification mode is ``none'' or ``numeric arguments
33272 only,'' @code{normalize} will act appropriately. However, the more
33273 powerful simplification modes (like Algebraic Simplification) are
33274 not handled by @code{normalize}. They are handled by @code{calc-normalize},
33275 which calls @code{normalize} and possibly some other routines, such
33276 as @code{simplify} or @code{simplify-units}. Programs generally will
33277 never call @code{calc-normalize} except when popping or pushing values
33278 on the stack.
33279 @end defun
33280
33281 @defun evaluate-expr expr
33282 Replace all variables in @var{expr} that have values with their values,
33283 then use @code{normalize} to simplify the result. This is what happens
33284 when you press the @kbd{=} key interactively.
33285 @end defun
33286
33287 @defmac with-extra-prec n body
33288 Evaluate the Lisp forms in @var{body} with precision increased by @var{n}
33289 digits. This is a macro which expands to
33290
33291 @smallexample
33292 (math-normalize
33293 (let ((calc-internal-prec (+ calc-internal-prec @var{n})))
33294 @var{body}))
33295 @end smallexample
33296
33297 The surrounding call to @code{math-normalize} causes a floating-point
33298 result to be rounded down to the original precision afterwards. This
33299 is important because some arithmetic operations assume a number's
33300 mantissa contains no more digits than the current precision allows.
33301 @end defmac
33302
33303 @defun make-frac n d
33304 Build a fraction @samp{@var{n}:@var{d}}. This is equivalent to calling
33305 @samp{(normalize (list 'frac @var{n} @var{d}))}, but more efficient.
33306 @end defun
33307
33308 @defun make-float mant exp
33309 Build a floating-point value out of @var{mant} and @var{exp}, both
33310 of which are arbitrary integers. This function will return a
33311 properly normalized float value, or signal an overflow or underflow
33312 if @var{exp} is out of range.
33313 @end defun
33314
33315 @defun make-sdev x sigma
33316 Build an error form out of @var{x} and the absolute value of @var{sigma}.
33317 If @var{sigma} is zero, the result is the number @var{x} directly.
33318 If @var{sigma} is negative or complex, its absolute value is used.
33319 If @var{x} or @var{sigma} is not a valid type of object for use in
33320 error forms, this calls @code{reject-arg}.
33321 @end defun
33322
33323 @defun make-intv mask lo hi
33324 Build an interval form out of @var{mask} (which is assumed to be an
33325 integer from 0 to 3), and the limits @var{lo} and @var{hi}. If
33326 @var{lo} is greater than @var{hi}, an empty interval form is returned.
33327 This calls @code{reject-arg} if @var{lo} or @var{hi} is unsuitable.
33328 @end defun
33329
33330 @defun sort-intv mask lo hi
33331 Build an interval form, similar to @code{make-intv}, except that if
33332 @var{lo} is less than @var{hi} they are simply exchanged, and the
33333 bits of @var{mask} are swapped accordingly.
33334 @end defun
33335
33336 @defun make-mod n m
33337 Build a modulo form out of @var{n} and the modulus @var{m}. Since modulo
33338 forms do not allow formulas as their components, if @var{n} or @var{m}
33339 is not a real number or HMS form the result will be a formula which
33340 is a call to @code{makemod}, the algebraic version of this function.
33341 @end defun
33342
33343 @defun float x
33344 Convert @var{x} to floating-point form. Integers and fractions are
33345 converted to numerically equivalent floats; components of complex
33346 numbers, vectors, HMS forms, date forms, error forms, intervals, and
33347 modulo forms are recursively floated. If the argument is a variable
33348 or formula, this calls @code{reject-arg}.
33349 @end defun
33350
33351 @defun compare x y
33352 Compare the numbers @var{x} and @var{y}, and return @mathit{-1} if
33353 @samp{(lessp @var{x} @var{y})}, 1 if @samp{(lessp @var{y} @var{x})},
33354 0 if @samp{(math-equal @var{x} @var{y})}, or 2 if the order is
33355 undefined or cannot be determined.
33356 @end defun
33357
33358 @defun numdigs n
33359 Return the number of digits of integer @var{n}, effectively
33360 @samp{ceil(log10(@var{n}))}, but much more efficient. Zero is
33361 considered to have zero digits.
33362 @end defun
33363
33364 @defun scale-int x n
33365 Shift integer @var{x} left @var{n} decimal digits, or right @mathit{-@var{n}}
33366 digits with truncation toward zero.
33367 @end defun
33368
33369 @defun scale-rounding x n
33370 Like @code{scale-int}, except that a right shift rounds to the nearest
33371 integer rather than truncating.
33372 @end defun
33373
33374 @defun fixnum n
33375 Return the integer @var{n} as a fixnum, i.e., a native Lisp integer.
33376 If @var{n} is outside the permissible range for Lisp integers (usually
33377 24 binary bits) the result is undefined.
33378 @end defun
33379
33380 @defun sqr x
33381 Compute the square of @var{x}; short for @samp{(* @var{x} @var{x})}.
33382 @end defun
33383
33384 @defun quotient x y
33385 Divide integer @var{x} by integer @var{y}; return an integer quotient
33386 and discard the remainder. If @var{x} or @var{y} is negative, the
33387 direction of rounding is undefined.
33388 @end defun
33389
33390 @defun idiv x y
33391 Perform an integer division; if @var{x} and @var{y} are both nonnegative
33392 integers, this uses the @code{quotient} function, otherwise it computes
33393 @samp{floor(@var{x}/@var{y})}. Thus the result is well-defined but
33394 slower than for @code{quotient}.
33395 @end defun
33396
33397 @defun imod x y
33398 Divide integer @var{x} by integer @var{y}; return the integer remainder
33399 and discard the quotient. Like @code{quotient}, this works only for
33400 integer arguments and is not well-defined for negative arguments.
33401 For a more well-defined result, use @samp{(% @var{x} @var{y})}.
33402 @end defun
33403
33404 @defun idivmod x y
33405 Divide integer @var{x} by integer @var{y}; return a cons cell whose
33406 @code{car} is @samp{(quotient @var{x} @var{y})} and whose @code{cdr}
33407 is @samp{(imod @var{x} @var{y})}.
33408 @end defun
33409
33410 @defun pow x y
33411 Compute @var{x} to the power @var{y}. In @code{defmath} code, this can
33412 also be written @samp{(^ @var{x} @var{y})} or
33413 @w{@samp{(expt @var{x} @var{y})}}.
33414 @end defun
33415
33416 @defun abs-approx x
33417 Compute a fast approximation to the absolute value of @var{x}. For
33418 example, for a rectangular complex number the result is the sum of
33419 the absolute values of the components.
33420 @end defun
33421
33422 @findex two-pi
33423 @findex pi-over-2
33424 @findex pi-over-4
33425 @findex pi-over-180
33426 @findex sqrt-two-pi
33427 @findex sqrt-e
33428 @findex e
33429 @findex ln-2
33430 @findex ln-10
33431 @defun pi
33432 The function @samp{(pi)} computes @samp{pi} to the current precision.
33433 Other related constant-generating functions are @code{two-pi},
33434 @code{pi-over-2}, @code{pi-over-4}, @code{pi-over-180}, @code{sqrt-two-pi},
33435 @code{e}, @code{sqrt-e}, @code{ln-2}, and @code{ln-10}. Each function
33436 returns a floating-point value in the current precision, and each uses
33437 caching so that all calls after the first are essentially free.
33438 @end defun
33439
33440 @defmac math-defcache @var{func} @var{initial} @var{form}
33441 This macro, usually used as a top-level call like @code{defun} or
33442 @code{defvar}, defines a new cached constant analogous to @code{pi}, etc.
33443 It defines a function @code{func} which returns the requested value;
33444 if @var{initial} is non-@code{nil} it must be a @samp{(float @dots{})}
33445 form which serves as an initial value for the cache. If @var{func}
33446 is called when the cache is empty or does not have enough digits to
33447 satisfy the current precision, the Lisp expression @var{form} is evaluated
33448 with the current precision increased by four, and the result minus its
33449 two least significant digits is stored in the cache. For example,
33450 calling @samp{(pi)} with a precision of 30 computes @samp{pi} to 34
33451 digits, rounds it down to 32 digits for future use, then rounds it
33452 again to 30 digits for use in the present request.
33453 @end defmac
33454
33455 @findex half-circle
33456 @findex quarter-circle
33457 @defun full-circle symb
33458 If the current angular mode is Degrees or HMS, this function returns the
33459 integer 360. In Radians mode, this function returns either the
33460 corresponding value in radians to the current precision, or the formula
33461 @samp{2*pi}, depending on the Symbolic mode. There are also similar
33462 function @code{half-circle} and @code{quarter-circle}.
33463 @end defun
33464
33465 @defun power-of-2 n
33466 Compute two to the integer power @var{n}, as a (potentially very large)
33467 integer. Powers of two are cached, so only the first call for a
33468 particular @var{n} is expensive.
33469 @end defun
33470
33471 @defun integer-log2 n
33472 Compute the base-2 logarithm of @var{n}, which must be an integer which
33473 is a power of two. If @var{n} is not a power of two, this function will
33474 return @code{nil}.
33475 @end defun
33476
33477 @defun div-mod a b m
33478 Divide @var{a} by @var{b}, modulo @var{m}. This returns @code{nil} if
33479 there is no solution, or if any of the arguments are not integers.
33480 @end defun
33481
33482 @defun pow-mod a b m
33483 Compute @var{a} to the power @var{b}, modulo @var{m}. If @var{a},
33484 @var{b}, and @var{m} are integers, this uses an especially efficient
33485 algorithm. Otherwise, it simply computes @samp{(% (^ a b) m)}.
33486 @end defun
33487
33488 @defun isqrt n
33489 Compute the integer square root of @var{n}. This is the square root
33490 of @var{n} rounded down toward zero, i.e., @samp{floor(sqrt(@var{n}))}.
33491 If @var{n} is itself an integer, the computation is especially efficient.
33492 @end defun
33493
33494 @defun to-hms a ang
33495 Convert the argument @var{a} into an HMS form. If @var{ang} is specified,
33496 it is the angular mode in which to interpret @var{a}, either @code{deg}
33497 or @code{rad}. Otherwise, the current angular mode is used. If @var{a}
33498 is already an HMS form it is returned as-is.
33499 @end defun
33500
33501 @defun from-hms a ang
33502 Convert the HMS form @var{a} into a real number. If @var{ang} is specified,
33503 it is the angular mode in which to express the result, otherwise the
33504 current angular mode is used. If @var{a} is already a real number, it
33505 is returned as-is.
33506 @end defun
33507
33508 @defun to-radians a
33509 Convert the number or HMS form @var{a} to radians from the current
33510 angular mode.
33511 @end defun
33512
33513 @defun from-radians a
33514 Convert the number @var{a} from radians to the current angular mode.
33515 If @var{a} is a formula, this returns the formula @samp{deg(@var{a})}.
33516 @end defun
33517
33518 @defun to-radians-2 a
33519 Like @code{to-radians}, except that in Symbolic mode a degrees to
33520 radians conversion yields a formula like @samp{@var{a}*pi/180}.
33521 @end defun
33522
33523 @defun from-radians-2 a
33524 Like @code{from-radians}, except that in Symbolic mode a radians to
33525 degrees conversion yields a formula like @samp{@var{a}*180/pi}.
33526 @end defun
33527
33528 @defun random-digit
33529 Produce a random base-1000 digit in the range 0 to 999.
33530 @end defun
33531
33532 @defun random-digits n
33533 Produce a random @var{n}-digit integer; this will be an integer
33534 in the interval @samp{[0, 10^@var{n})}.
33535 @end defun
33536
33537 @defun random-float
33538 Produce a random float in the interval @samp{[0, 1)}.
33539 @end defun
33540
33541 @defun prime-test n iters
33542 Determine whether the integer @var{n} is prime. Return a list which has
33543 one of these forms: @samp{(nil @var{f})} means the number is non-prime
33544 because it was found to be divisible by @var{f}; @samp{(nil)} means it
33545 was found to be non-prime by table look-up (so no factors are known);
33546 @samp{(nil unknown)} means it is definitely non-prime but no factors
33547 are known because @var{n} was large enough that Fermat's probabilistic
33548 test had to be used; @samp{(t)} means the number is definitely prime;
33549 and @samp{(maybe @var{i} @var{p})} means that Fermat's test, after @var{i}
33550 iterations, is @var{p} percent sure that the number is prime. The
33551 @var{iters} parameter is the number of Fermat iterations to use, in the
33552 case that this is necessary. If @code{prime-test} returns ``maybe,''
33553 you can call it again with the same @var{n} to get a greater certainty;
33554 @code{prime-test} remembers where it left off.
33555 @end defun
33556
33557 @defun to-simple-fraction f
33558 If @var{f} is a floating-point number which can be represented exactly
33559 as a small rational number. return that number, else return @var{f}.
33560 For example, 0.75 would be converted to 3:4. This function is very
33561 fast.
33562 @end defun
33563
33564 @defun to-fraction f tol
33565 Find a rational approximation to floating-point number @var{f} to within
33566 a specified tolerance @var{tol}; this corresponds to the algebraic
33567 function @code{frac}, and can be rather slow.
33568 @end defun
33569
33570 @defun quarter-integer n
33571 If @var{n} is an integer or integer-valued float, this function
33572 returns zero. If @var{n} is a half-integer (i.e., an integer plus
33573 @mathit{1:2} or 0.5), it returns 2. If @var{n} is a quarter-integer,
33574 it returns 1 or 3. If @var{n} is anything else, this function
33575 returns @code{nil}.
33576 @end defun
33577
33578 @node Vector Lisp Functions, Symbolic Lisp Functions, Computational Lisp Functions, Internals
33579 @subsubsection Vector Functions
33580
33581 @noindent
33582 The functions described here perform various operations on vectors and
33583 matrices.
33584
33585 @defun math-concat x y
33586 Do a vector concatenation; this operation is written @samp{@var{x} | @var{y}}
33587 in a symbolic formula. @xref{Building Vectors}.
33588 @end defun
33589
33590 @defun vec-length v
33591 Return the length of vector @var{v}. If @var{v} is not a vector, the
33592 result is zero. If @var{v} is a matrix, this returns the number of
33593 rows in the matrix.
33594 @end defun
33595
33596 @defun mat-dimens m
33597 Determine the dimensions of vector or matrix @var{m}. If @var{m} is not
33598 a vector, the result is an empty list. If @var{m} is a plain vector
33599 but not a matrix, the result is a one-element list containing the length
33600 of the vector. If @var{m} is a matrix with @var{r} rows and @var{c} columns,
33601 the result is the list @samp{(@var{r} @var{c})}. Higher-order tensors
33602 produce lists of more than two dimensions. Note that the object
33603 @samp{[[1, 2, 3], [4, 5]]} is a vector of vectors not all the same size,
33604 and is treated by this and other Calc routines as a plain vector of two
33605 elements.
33606 @end defun
33607
33608 @defun dimension-error
33609 Abort the current function with a message of ``Dimension error.''
33610 The Calculator will leave the function being evaluated in symbolic
33611 form; this is really just a special case of @code{reject-arg}.
33612 @end defun
33613
33614 @defun build-vector args
33615 Return a Calc vector with @var{args} as elements.
33616 For example, @samp{(build-vector 1 2 3)} returns the Calc vector
33617 @samp{[1, 2, 3]}, stored internally as the list @samp{(vec 1 2 3)}.
33618 @end defun
33619
33620 @defun make-vec obj dims
33621 Return a Calc vector or matrix all of whose elements are equal to
33622 @var{obj}. For example, @samp{(make-vec 27 3 4)} returns a 3x4 matrix
33623 filled with 27's.
33624 @end defun
33625
33626 @defun row-matrix v
33627 If @var{v} is a plain vector, convert it into a row matrix, i.e.,
33628 a matrix whose single row is @var{v}. If @var{v} is already a matrix,
33629 leave it alone.
33630 @end defun
33631
33632 @defun col-matrix v
33633 If @var{v} is a plain vector, convert it into a column matrix, i.e., a
33634 matrix with each element of @var{v} as a separate row. If @var{v} is
33635 already a matrix, leave it alone.
33636 @end defun
33637
33638 @defun map-vec f v
33639 Map the Lisp function @var{f} over the Calc vector @var{v}. For example,
33640 @samp{(map-vec 'math-floor v)} returns a vector of the floored components
33641 of vector @var{v}.
33642 @end defun
33643
33644 @defun map-vec-2 f a b
33645 Map the Lisp function @var{f} over the two vectors @var{a} and @var{b}.
33646 If @var{a} and @var{b} are vectors of equal length, the result is a
33647 vector of the results of calling @samp{(@var{f} @var{ai} @var{bi})}
33648 for each pair of elements @var{ai} and @var{bi}. If either @var{a} or
33649 @var{b} is a scalar, it is matched with each value of the other vector.
33650 For example, @samp{(map-vec-2 'math-add v 1)} returns the vector @var{v}
33651 with each element increased by one. Note that using @samp{'+} would not
33652 work here, since @code{defmath} does not expand function names everywhere,
33653 just where they are in the function position of a Lisp expression.
33654 @end defun
33655
33656 @defun reduce-vec f v
33657 Reduce the function @var{f} over the vector @var{v}. For example, if
33658 @var{v} is @samp{[10, 20, 30, 40]}, this calls @samp{(f (f (f 10 20) 30) 40)}.
33659 If @var{v} is a matrix, this reduces over the rows of @var{v}.
33660 @end defun
33661
33662 @defun reduce-cols f m
33663 Reduce the function @var{f} over the columns of matrix @var{m}. For
33664 example, if @var{m} is @samp{[[1, 2], [3, 4], [5, 6]]}, the result
33665 is a vector of the two elements @samp{(f (f 1 3) 5)} and @samp{(f (f 2 4) 6)}.
33666 @end defun
33667
33668 @defun mat-row m n
33669 Return the @var{n}th row of matrix @var{m}. This is equivalent to
33670 @samp{(elt m n)}. For a slower but safer version, use @code{mrow}.
33671 (@xref{Extracting Elements}.)
33672 @end defun
33673
33674 @defun mat-col m n
33675 Return the @var{n}th column of matrix @var{m}, in the form of a vector.
33676 The arguments are not checked for correctness.
33677 @end defun
33678
33679 @defun mat-less-row m n
33680 Return a copy of matrix @var{m} with its @var{n}th row deleted. The
33681 number @var{n} must be in range from 1 to the number of rows in @var{m}.
33682 @end defun
33683
33684 @defun mat-less-col m n
33685 Return a copy of matrix @var{m} with its @var{n}th column deleted.
33686 @end defun
33687
33688 @defun transpose m
33689 Return the transpose of matrix @var{m}.
33690 @end defun
33691
33692 @defun flatten-vector v
33693 Flatten nested vector @var{v} into a vector of scalars. For example,
33694 if @var{v} is @samp{[[1, 2, 3], [4, 5]]} the result is @samp{[1, 2, 3, 4, 5]}.
33695 @end defun
33696
33697 @defun copy-matrix m
33698 If @var{m} is a matrix, return a copy of @var{m}. This maps
33699 @code{copy-sequence} over the rows of @var{m}; in Lisp terms, each
33700 element of the result matrix will be @code{eq} to the corresponding
33701 element of @var{m}, but none of the @code{cons} cells that make up
33702 the structure of the matrix will be @code{eq}. If @var{m} is a plain
33703 vector, this is the same as @code{copy-sequence}.
33704 @end defun
33705
33706 @defun swap-rows m r1 r2
33707 Exchange rows @var{r1} and @var{r2} of matrix @var{m} in-place. In
33708 other words, unlike most of the other functions described here, this
33709 function changes @var{m} itself rather than building up a new result
33710 matrix. The return value is @var{m}, i.e., @samp{(eq (swap-rows m 1 2) m)}
33711 is true, with the side effect of exchanging the first two rows of
33712 @var{m}.
33713 @end defun
33714
33715 @node Symbolic Lisp Functions, Formatting Lisp Functions, Vector Lisp Functions, Internals
33716 @subsubsection Symbolic Functions
33717
33718 @noindent
33719 The functions described here operate on symbolic formulas in the
33720 Calculator.
33721
33722 @defun calc-prepare-selection num
33723 Prepare a stack entry for selection operations. If @var{num} is
33724 omitted, the stack entry containing the cursor is used; otherwise,
33725 it is the number of the stack entry to use. This function stores
33726 useful information about the current stack entry into a set of
33727 variables. @code{calc-selection-cache-num} contains the number of
33728 the stack entry involved (equal to @var{num} if you specified it);
33729 @code{calc-selection-cache-entry} contains the stack entry as a
33730 list (such as @code{calc-top-list} would return with @code{entry}
33731 as the selection mode); and @code{calc-selection-cache-comp} contains
33732 a special ``tagged'' composition (@pxref{Formatting Lisp Functions})
33733 which allows Calc to relate cursor positions in the buffer with
33734 their corresponding sub-formulas.
33735
33736 A slight complication arises in the selection mechanism because
33737 formulas may contain small integers. For example, in the vector
33738 @samp{[1, 2, 1]} the first and last elements are @code{eq} to each
33739 other; selections are recorded as the actual Lisp object that
33740 appears somewhere in the tree of the whole formula, but storing
33741 @code{1} would falsely select both @code{1}'s in the vector. So
33742 @code{calc-prepare-selection} also checks the stack entry and
33743 replaces any plain integers with ``complex number'' lists of the form
33744 @samp{(cplx @var{n} 0)}. This list will be displayed the same as a
33745 plain @var{n} and the change will be completely invisible to the
33746 user, but it will guarantee that no two sub-formulas of the stack
33747 entry will be @code{eq} to each other. Next time the stack entry
33748 is involved in a computation, @code{calc-normalize} will replace
33749 these lists with plain numbers again, again invisibly to the user.
33750 @end defun
33751
33752 @defun calc-encase-atoms x
33753 This modifies the formula @var{x} to ensure that each part of the
33754 formula is a unique atom, using the @samp{(cplx @var{n} 0)} trick
33755 described above. This function may use @code{setcar} to modify
33756 the formula in-place.
33757 @end defun
33758
33759 @defun calc-find-selected-part
33760 Find the smallest sub-formula of the current formula that contains
33761 the cursor. This assumes @code{calc-prepare-selection} has been
33762 called already. If the cursor is not actually on any part of the
33763 formula, this returns @code{nil}.
33764 @end defun
33765
33766 @defun calc-change-current-selection selection
33767 Change the currently prepared stack element's selection to
33768 @var{selection}, which should be @code{eq} to some sub-formula
33769 of the stack element, or @code{nil} to unselect the formula.
33770 The stack element's appearance in the Calc buffer is adjusted
33771 to reflect the new selection.
33772 @end defun
33773
33774 @defun calc-find-nth-part expr n
33775 Return the @var{n}th sub-formula of @var{expr}. This function is used
33776 by the selection commands, and (unless @kbd{j b} has been used) treats
33777 sums and products as flat many-element formulas. Thus if @var{expr}
33778 is @samp{((a + b) - c) + d}, calling @code{calc-find-nth-part} with
33779 @var{n} equal to four will return @samp{d}.
33780 @end defun
33781
33782 @defun calc-find-parent-formula expr part
33783 Return the sub-formula of @var{expr} which immediately contains
33784 @var{part}. If @var{expr} is @samp{a*b + (c+1)*d} and @var{part}
33785 is @code{eq} to the @samp{c+1} term of @var{expr}, then this function
33786 will return @samp{(c+1)*d}. If @var{part} turns out not to be a
33787 sub-formula of @var{expr}, the function returns @code{nil}. If
33788 @var{part} is @code{eq} to @var{expr}, the function returns @code{t}.
33789 This function does not take associativity into account.
33790 @end defun
33791
33792 @defun calc-find-assoc-parent-formula expr part
33793 This is the same as @code{calc-find-parent-formula}, except that
33794 (unless @kbd{j b} has been used) it continues widening the selection
33795 to contain a complete level of the formula. Given @samp{a} from
33796 @samp{((a + b) - c) + d}, @code{calc-find-parent-formula} will
33797 return @samp{a + b} but @code{calc-find-assoc-parent-formula} will
33798 return the whole expression.
33799 @end defun
33800
33801 @defun calc-grow-assoc-formula expr part
33802 This expands sub-formula @var{part} of @var{expr} to encompass a
33803 complete level of the formula. If @var{part} and its immediate
33804 parent are not compatible associative operators, or if @kbd{j b}
33805 has been used, this simply returns @var{part}.
33806 @end defun
33807
33808 @defun calc-find-sub-formula expr part
33809 This finds the immediate sub-formula of @var{expr} which contains
33810 @var{part}. It returns an index @var{n} such that
33811 @samp{(calc-find-nth-part @var{expr} @var{n})} would return @var{part}.
33812 If @var{part} is not a sub-formula of @var{expr}, it returns @code{nil}.
33813 If @var{part} is @code{eq} to @var{expr}, it returns @code{t}. This
33814 function does not take associativity into account.
33815 @end defun
33816
33817 @defun calc-replace-sub-formula expr old new
33818 This function returns a copy of formula @var{expr}, with the
33819 sub-formula that is @code{eq} to @var{old} replaced by @var{new}.
33820 @end defun
33821
33822 @defun simplify expr
33823 Simplify the expression @var{expr} by applying various algebraic rules.
33824 This is what the @w{@kbd{a s}} (@code{calc-simplify}) command uses. This
33825 always returns a copy of the expression; the structure @var{expr} points
33826 to remains unchanged in memory.
33827
33828 More precisely, here is what @code{simplify} does: The expression is
33829 first normalized and evaluated by calling @code{normalize}. If any
33830 @code{AlgSimpRules} have been defined, they are then applied. Then
33831 the expression is traversed in a depth-first, bottom-up fashion; at
33832 each level, any simplifications that can be made are made until no
33833 further changes are possible. Once the entire formula has been
33834 traversed in this way, it is compared with the original formula (from
33835 before the call to @code{normalize}) and, if it has changed,
33836 the entire procedure is repeated (starting with @code{normalize})
33837 until no further changes occur. Usually only two iterations are
33838 needed:@: one to simplify the formula, and another to verify that no
33839 further simplifications were possible.
33840 @end defun
33841
33842 @defun simplify-extended expr
33843 Simplify the expression @var{expr}, with additional rules enabled that
33844 help do a more thorough job, while not being entirely ``safe'' in all
33845 circumstances. (For example, this mode will simplify @samp{sqrt(x^2)}
33846 to @samp{x}, which is only valid when @var{x} is positive.) This is
33847 implemented by temporarily binding the variable @code{math-living-dangerously}
33848 to @code{t} (using a @code{let} form) and calling @code{simplify}.
33849 Dangerous simplification rules are written to check this variable
33850 before taking any action.
33851 @end defun
33852
33853 @defun simplify-units expr
33854 Simplify the expression @var{expr}, treating variable names as units
33855 whenever possible. This works by binding the variable
33856 @code{math-simplifying-units} to @code{t} while calling @code{simplify}.
33857 @end defun
33858
33859 @defmac math-defsimplify funcs body
33860 Register a new simplification rule; this is normally called as a top-level
33861 form, like @code{defun} or @code{defmath}. If @var{funcs} is a symbol
33862 (like @code{+} or @code{calcFunc-sqrt}), this simplification rule is
33863 applied to the formulas which are calls to the specified function. Or,
33864 @var{funcs} can be a list of such symbols; the rule applies to all
33865 functions on the list. The @var{body} is written like the body of a
33866 function with a single argument called @code{expr}. The body will be
33867 executed with @code{expr} bound to a formula which is a call to one of
33868 the functions @var{funcs}. If the function body returns @code{nil}, or
33869 if it returns a result @code{equal} to the original @code{expr}, it is
33870 ignored and Calc goes on to try the next simplification rule that applies.
33871 If the function body returns something different, that new formula is
33872 substituted for @var{expr} in the original formula.
33873
33874 At each point in the formula, rules are tried in the order of the
33875 original calls to @code{math-defsimplify}; the search stops after the
33876 first rule that makes a change. Thus later rules for that same
33877 function will not have a chance to trigger until the next iteration
33878 of the main @code{simplify} loop.
33879
33880 Note that, since @code{defmath} is not being used here, @var{body} must
33881 be written in true Lisp code without the conveniences that @code{defmath}
33882 provides. If you prefer, you can have @var{body} simply call another
33883 function (defined with @code{defmath}) which does the real work.
33884
33885 The arguments of a function call will already have been simplified
33886 before any rules for the call itself are invoked. Since a new argument
33887 list is consed up when this happens, this means that the rule's body is
33888 allowed to rearrange the function's arguments destructively if that is
33889 convenient. Here is a typical example of a simplification rule:
33890
33891 @smallexample
33892 (math-defsimplify calcFunc-arcsinh
33893 (or (and (math-looks-negp (nth 1 expr))
33894 (math-neg (list 'calcFunc-arcsinh
33895 (math-neg (nth 1 expr)))))
33896 (and (eq (car-safe (nth 1 expr)) 'calcFunc-sinh)
33897 (or math-living-dangerously
33898 (math-known-realp (nth 1 (nth 1 expr))))
33899 (nth 1 (nth 1 expr)))))
33900 @end smallexample
33901
33902 This is really a pair of rules written with one @code{math-defsimplify}
33903 for convenience; the first replaces @samp{arcsinh(-x)} with
33904 @samp{-arcsinh(x)}, and the second, which is safe only for real @samp{x},
33905 replaces @samp{arcsinh(sinh(x))} with @samp{x}.
33906 @end defmac
33907
33908 @defun common-constant-factor expr
33909 Check @var{expr} to see if it is a sum of terms all multiplied by the
33910 same rational value. If so, return this value. If not, return @code{nil}.
33911 For example, if called on @samp{6x + 9y + 12z}, it would return 3, since
33912 3 is a common factor of all the terms.
33913 @end defun
33914
33915 @defun cancel-common-factor expr factor
33916 Assuming @var{expr} is a sum with @var{factor} as a common factor,
33917 divide each term of the sum by @var{factor}. This is done by
33918 destructively modifying parts of @var{expr}, on the assumption that
33919 it is being used by a simplification rule (where such things are
33920 allowed; see above). For example, consider this built-in rule for
33921 square roots:
33922
33923 @smallexample
33924 (math-defsimplify calcFunc-sqrt
33925 (let ((fac (math-common-constant-factor (nth 1 expr))))
33926 (and fac (not (eq fac 1))
33927 (math-mul (math-normalize (list 'calcFunc-sqrt fac))
33928 (math-normalize
33929 (list 'calcFunc-sqrt
33930 (math-cancel-common-factor
33931 (nth 1 expr) fac)))))))
33932 @end smallexample
33933 @end defun
33934
33935 @defun frac-gcd a b
33936 Compute a ``rational GCD'' of @var{a} and @var{b}, which must both be
33937 rational numbers. This is the fraction composed of the GCD of the
33938 numerators of @var{a} and @var{b}, over the GCD of the denominators.
33939 It is used by @code{common-constant-factor}. Note that the standard
33940 @code{gcd} function uses the LCM to combine the denominators.
33941 @end defun
33942
33943 @defun map-tree func expr many
33944 Try applying Lisp function @var{func} to various sub-expressions of
33945 @var{expr}. Initially, call @var{func} with @var{expr} itself as an
33946 argument. If this returns an expression which is not @code{equal} to
33947 @var{expr}, apply @var{func} again until eventually it does return
33948 @var{expr} with no changes. Then, if @var{expr} is a function call,
33949 recursively apply @var{func} to each of the arguments. This keeps going
33950 until no changes occur anywhere in the expression; this final expression
33951 is returned by @code{map-tree}. Note that, unlike simplification rules,
33952 @var{func} functions may @emph{not} make destructive changes to
33953 @var{expr}. If a third argument @var{many} is provided, it is an
33954 integer which says how many times @var{func} may be applied; the
33955 default, as described above, is infinitely many times.
33956 @end defun
33957
33958 @defun compile-rewrites rules
33959 Compile the rewrite rule set specified by @var{rules}, which should
33960 be a formula that is either a vector or a variable name. If the latter,
33961 the compiled rules are saved so that later @code{compile-rules} calls
33962 for that same variable can return immediately. If there are problems
33963 with the rules, this function calls @code{error} with a suitable
33964 message.
33965 @end defun
33966
33967 @defun apply-rewrites expr crules heads
33968 Apply the compiled rewrite rule set @var{crules} to the expression
33969 @var{expr}. This will make only one rewrite and only checks at the
33970 top level of the expression. The result @code{nil} if no rules
33971 matched, or if the only rules that matched did not actually change
33972 the expression. The @var{heads} argument is optional; if is given,
33973 it should be a list of all function names that (may) appear in
33974 @var{expr}. The rewrite compiler tags each rule with the
33975 rarest-looking function name in the rule; if you specify @var{heads},
33976 @code{apply-rewrites} can use this information to narrow its search
33977 down to just a few rules in the rule set.
33978 @end defun
33979
33980 @defun rewrite-heads expr
33981 Compute a @var{heads} list for @var{expr} suitable for use with
33982 @code{apply-rewrites}, as discussed above.
33983 @end defun
33984
33985 @defun rewrite expr rules many
33986 This is an all-in-one rewrite function. It compiles the rule set
33987 specified by @var{rules}, then uses @code{map-tree} to apply the
33988 rules throughout @var{expr} up to @var{many} (default infinity)
33989 times.
33990 @end defun
33991
33992 @defun match-patterns pat vec not-flag
33993 Given a Calc vector @var{vec} and an uncompiled pattern set or
33994 pattern set variable @var{pat}, this function returns a new vector
33995 of all elements of @var{vec} which do (or don't, if @var{not-flag} is
33996 non-@code{nil}) match any of the patterns in @var{pat}.
33997 @end defun
33998
33999 @defun deriv expr var value symb
34000 Compute the derivative of @var{expr} with respect to variable @var{var}
34001 (which may actually be any sub-expression). If @var{value} is specified,
34002 the derivative is evaluated at the value of @var{var}; otherwise, the
34003 derivative is left in terms of @var{var}. If the expression contains
34004 functions for which no derivative formula is known, new derivative
34005 functions are invented by adding primes to the names; @pxref{Calculus}.
34006 However, if @var{symb} is non-@code{nil}, the presence of undifferentiable
34007 functions in @var{expr} instead cancels the whole differentiation, and
34008 @code{deriv} returns @code{nil} instead.
34009
34010 Derivatives of an @var{n}-argument function can be defined by
34011 adding a @code{math-derivative-@var{n}} property to the property list
34012 of the symbol for the function's derivative, which will be the
34013 function name followed by an apostrophe. The value of the property
34014 should be a Lisp function; it is called with the same arguments as the
34015 original function call that is being differentiated. It should return
34016 a formula for the derivative. For example, the derivative of @code{ln}
34017 is defined by
34018
34019 @smallexample
34020 (put 'calcFunc-ln\' 'math-derivative-1
34021 (function (lambda (u) (math-div 1 u))))
34022 @end smallexample
34023
34024 The two-argument @code{log} function has two derivatives,
34025 @smallexample
34026 (put 'calcFunc-log\' 'math-derivative-2 ; d(log(x,b)) / dx
34027 (function (lambda (x b) ... )))
34028 (put 'calcFunc-log\'2 'math-derivative-2 ; d(log(x,b)) / db
34029 (function (lambda (x b) ... )))
34030 @end smallexample
34031 @end defun
34032
34033 @defun tderiv expr var value symb
34034 Compute the total derivative of @var{expr}. This is the same as
34035 @code{deriv}, except that variables other than @var{var} are not
34036 assumed to be constant with respect to @var{var}.
34037 @end defun
34038
34039 @defun integ expr var low high
34040 Compute the integral of @var{expr} with respect to @var{var}.
34041 @xref{Calculus}, for further details.
34042 @end defun
34043
34044 @defmac math-defintegral funcs body
34045 Define a rule for integrating a function or functions of one argument;
34046 this macro is very similar in format to @code{math-defsimplify}.
34047 The main difference is that here @var{body} is the body of a function
34048 with a single argument @code{u} which is bound to the argument to the
34049 function being integrated, not the function call itself. Also, the
34050 variable of integration is available as @code{math-integ-var}. If
34051 evaluation of the integral requires doing further integrals, the body
34052 should call @samp{(math-integral @var{x})} to find the integral of
34053 @var{x} with respect to @code{math-integ-var}; this function returns
34054 @code{nil} if the integral could not be done. Some examples:
34055
34056 @smallexample
34057 (math-defintegral calcFunc-conj
34058 (let ((int (math-integral u)))
34059 (and int
34060 (list 'calcFunc-conj int))))
34061
34062 (math-defintegral calcFunc-cos
34063 (and (equal u math-integ-var)
34064 (math-from-radians-2 (list 'calcFunc-sin u))))
34065 @end smallexample
34066
34067 In the @code{cos} example, we define only the integral of @samp{cos(x) dx},
34068 relying on the general integration-by-substitution facility to handle
34069 cosines of more complicated arguments. An integration rule should return
34070 @code{nil} if it can't do the integral; if several rules are defined for
34071 the same function, they are tried in order until one returns a non-@code{nil}
34072 result.
34073 @end defmac
34074
34075 @defmac math-defintegral-2 funcs body
34076 Define a rule for integrating a function or functions of two arguments.
34077 This is exactly analogous to @code{math-defintegral}, except that @var{body}
34078 is written as the body of a function with two arguments, @var{u} and
34079 @var{v}.
34080 @end defmac
34081
34082 @defun solve-for lhs rhs var full
34083 Attempt to solve the equation @samp{@var{lhs} = @var{rhs}} by isolating
34084 the variable @var{var} on the lefthand side; return the resulting righthand
34085 side, or @code{nil} if the equation cannot be solved. The variable
34086 @var{var} must appear at least once in @var{lhs} or @var{rhs}. Note that
34087 the return value is a formula which does not contain @var{var}; this is
34088 different from the user-level @code{solve} and @code{finv} functions,
34089 which return a rearranged equation or a functional inverse, respectively.
34090 If @var{full} is non-@code{nil}, a full solution including dummy signs
34091 and dummy integers will be produced. User-defined inverses are provided
34092 as properties in a manner similar to derivatives:
34093
34094 @smallexample
34095 (put 'calcFunc-ln 'math-inverse
34096 (function (lambda (x) (list 'calcFunc-exp x))))
34097 @end smallexample
34098
34099 This function can call @samp{(math-solve-get-sign @var{x})} to create
34100 a new arbitrary sign variable, returning @var{x} times that sign, and
34101 @samp{(math-solve-get-int @var{x})} to create a new arbitrary integer
34102 variable multiplied by @var{x}. These functions simply return @var{x}
34103 if the caller requested a non-``full'' solution.
34104 @end defun
34105
34106 @defun solve-eqn expr var full
34107 This version of @code{solve-for} takes an expression which will
34108 typically be an equation or inequality. (If it is not, it will be
34109 interpreted as the equation @samp{@var{expr} = 0}.) It returns an
34110 equation or inequality, or @code{nil} if no solution could be found.
34111 @end defun
34112
34113 @defun solve-system exprs vars full
34114 This function solves a system of equations. Generally, @var{exprs}
34115 and @var{vars} will be vectors of equal length.
34116 @xref{Solving Systems of Equations}, for other options.
34117 @end defun
34118
34119 @defun expr-contains expr var
34120 Returns a non-@code{nil} value if @var{var} occurs as a subexpression
34121 of @var{expr}.
34122
34123 This function might seem at first to be identical to
34124 @code{calc-find-sub-formula}. The key difference is that
34125 @code{expr-contains} uses @code{equal} to test for matches, whereas
34126 @code{calc-find-sub-formula} uses @code{eq}. In the formula
34127 @samp{f(a, a)}, the two @samp{a}s will be @code{equal} but not
34128 @code{eq} to each other.
34129 @end defun
34130
34131 @defun expr-contains-count expr var
34132 Returns the number of occurrences of @var{var} as a subexpression
34133 of @var{expr}, or @code{nil} if there are no occurrences.
34134 @end defun
34135
34136 @defun expr-depends expr var
34137 Returns true if @var{expr} refers to any variable the occurs in @var{var}.
34138 In other words, it checks if @var{expr} and @var{var} have any variables
34139 in common.
34140 @end defun
34141
34142 @defun expr-contains-vars expr
34143 Return true if @var{expr} contains any variables, or @code{nil} if @var{expr}
34144 contains only constants and functions with constant arguments.
34145 @end defun
34146
34147 @defun expr-subst expr old new
34148 Returns a copy of @var{expr}, with all occurrences of @var{old} replaced
34149 by @var{new}. This treats @code{lambda} forms specially with respect
34150 to the dummy argument variables, so that the effect is always to return
34151 @var{expr} evaluated at @var{old} = @var{new}.
34152 @end defun
34153
34154 @defun multi-subst expr old new
34155 This is like @code{expr-subst}, except that @var{old} and @var{new}
34156 are lists of expressions to be substituted simultaneously. If one
34157 list is shorter than the other, trailing elements of the longer list
34158 are ignored.
34159 @end defun
34160
34161 @defun expr-weight expr
34162 Returns the ``weight'' of @var{expr}, basically a count of the total
34163 number of objects and function calls that appear in @var{expr}. For
34164 ``primitive'' objects, this will be one.
34165 @end defun
34166
34167 @defun expr-height expr
34168 Returns the ``height'' of @var{expr}, which is the deepest level to
34169 which function calls are nested. (Note that @samp{@var{a} + @var{b}}
34170 counts as a function call.) For primitive objects, this returns zero.
34171 @end defun
34172
34173 @defun polynomial-p expr var
34174 Check if @var{expr} is a polynomial in variable (or sub-expression)
34175 @var{var}. If so, return the degree of the polynomial, that is, the
34176 highest power of @var{var} that appears in @var{expr}. For example,
34177 for @samp{(x^2 + 3)^3 + 4} this would return 6. This function returns
34178 @code{nil} unless @var{expr}, when expanded out by @kbd{a x}
34179 (@code{calc-expand}), would consist of a sum of terms in which @var{var}
34180 appears only raised to nonnegative integer powers. Note that if
34181 @var{var} does not occur in @var{expr}, then @var{expr} is considered
34182 a polynomial of degree 0.
34183 @end defun
34184
34185 @defun is-polynomial expr var degree loose
34186 Check if @var{expr} is a polynomial in variable or sub-expression
34187 @var{var}, and, if so, return a list representation of the polynomial
34188 where the elements of the list are coefficients of successive powers of
34189 @var{var}: @samp{@var{a} + @var{b} x + @var{c} x^3} would produce the
34190 list @samp{(@var{a} @var{b} 0 @var{c})}, and @samp{(x + 1)^2} would
34191 produce the list @samp{(1 2 1)}. The highest element of the list will
34192 be non-zero, with the special exception that if @var{expr} is the
34193 constant zero, the returned value will be @samp{(0)}. Return @code{nil}
34194 if @var{expr} is not a polynomial in @var{var}. If @var{degree} is
34195 specified, this will not consider polynomials of degree higher than that
34196 value. This is a good precaution because otherwise an input of
34197 @samp{(x+1)^1000} will cause a huge coefficient list to be built. If
34198 @var{loose} is non-@code{nil}, then a looser definition of a polynomial
34199 is used in which coefficients are no longer required not to depend on
34200 @var{var}, but are only required not to take the form of polynomials
34201 themselves. For example, @samp{sin(x) x^2 + cos(x)} is a loose
34202 polynomial with coefficients @samp{((calcFunc-cos x) 0 (calcFunc-sin
34203 x))}. The result will never be @code{nil} in loose mode, since any
34204 expression can be interpreted as a ``constant'' loose polynomial.
34205 @end defun
34206
34207 @defun polynomial-base expr pred
34208 Check if @var{expr} is a polynomial in any variable that occurs in it;
34209 if so, return that variable. (If @var{expr} is a multivariate polynomial,
34210 this chooses one variable arbitrarily.) If @var{pred} is specified, it should
34211 be a Lisp function which is called as @samp{(@var{pred} @var{subexpr})},
34212 and which should return true if @code{mpb-top-expr} (a global name for
34213 the original @var{expr}) is a suitable polynomial in @var{subexpr}.
34214 The default predicate uses @samp{(polynomial-p mpb-top-expr @var{subexpr})};
34215 you can use @var{pred} to specify additional conditions. Or, you could
34216 have @var{pred} build up a list of every suitable @var{subexpr} that
34217 is found.
34218 @end defun
34219
34220 @defun poly-simplify poly
34221 Simplify polynomial coefficient list @var{poly} by (destructively)
34222 clipping off trailing zeros.
34223 @end defun
34224
34225 @defun poly-mix a ac b bc
34226 Mix two polynomial lists @var{a} and @var{b} (in the form returned by
34227 @code{is-polynomial}) in a linear combination with coefficient expressions
34228 @var{ac} and @var{bc}. The result is a (not necessarily simplified)
34229 polynomial list representing @samp{@var{ac} @var{a} + @var{bc} @var{b}}.
34230 @end defun
34231
34232 @defun poly-mul a b
34233 Multiply two polynomial coefficient lists @var{a} and @var{b}. The
34234 result will be in simplified form if the inputs were simplified.
34235 @end defun
34236
34237 @defun build-polynomial-expr poly var
34238 Construct a Calc formula which represents the polynomial coefficient
34239 list @var{poly} applied to variable @var{var}. The @kbd{a c}
34240 (@code{calc-collect}) command uses @code{is-polynomial} to turn an
34241 expression into a coefficient list, then @code{build-polynomial-expr}
34242 to turn the list back into an expression in regular form.
34243 @end defun
34244
34245 @defun check-unit-name var
34246 Check if @var{var} is a variable which can be interpreted as a unit
34247 name. If so, return the units table entry for that unit. This
34248 will be a list whose first element is the unit name (not counting
34249 prefix characters) as a symbol and whose second element is the
34250 Calc expression which defines the unit. (Refer to the Calc sources
34251 for details on the remaining elements of this list.) If @var{var}
34252 is not a variable or is not a unit name, return @code{nil}.
34253 @end defun
34254
34255 @defun units-in-expr-p expr sub-exprs
34256 Return true if @var{expr} contains any variables which can be
34257 interpreted as units. If @var{sub-exprs} is @code{t}, the entire
34258 expression is searched. If @var{sub-exprs} is @code{nil}, this
34259 checks whether @var{expr} is directly a units expression.
34260 @end defun
34261
34262 @defun single-units-in-expr-p expr
34263 Check whether @var{expr} contains exactly one units variable. If so,
34264 return the units table entry for the variable. If @var{expr} does
34265 not contain any units, return @code{nil}. If @var{expr} contains
34266 two or more units, return the symbol @code{wrong}.
34267 @end defun
34268
34269 @defun to-standard-units expr which
34270 Convert units expression @var{expr} to base units. If @var{which}
34271 is @code{nil}, use Calc's native base units. Otherwise, @var{which}
34272 can specify a units system, which is a list of two-element lists,
34273 where the first element is a Calc base symbol name and the second
34274 is an expression to substitute for it.
34275 @end defun
34276
34277 @defun remove-units expr
34278 Return a copy of @var{expr} with all units variables replaced by ones.
34279 This expression is generally normalized before use.
34280 @end defun
34281
34282 @defun extract-units expr
34283 Return a copy of @var{expr} with everything but units variables replaced
34284 by ones.
34285 @end defun
34286
34287 @node Formatting Lisp Functions, Hooks, Symbolic Lisp Functions, Internals
34288 @subsubsection I/O and Formatting Functions
34289
34290 @noindent
34291 The functions described here are responsible for parsing and formatting
34292 Calc numbers and formulas.
34293
34294 @defun calc-eval str sep arg1 arg2 @dots{}
34295 This is the simplest interface to the Calculator from another Lisp program.
34296 @xref{Calling Calc from Your Programs}.
34297 @end defun
34298
34299 @defun read-number str
34300 If string @var{str} contains a valid Calc number, either integer,
34301 fraction, float, or HMS form, this function parses and returns that
34302 number. Otherwise, it returns @code{nil}.
34303 @end defun
34304
34305 @defun read-expr str
34306 Read an algebraic expression from string @var{str}. If @var{str} does
34307 not have the form of a valid expression, return a list of the form
34308 @samp{(error @var{pos} @var{msg})} where @var{pos} is an integer index
34309 into @var{str} of the general location of the error, and @var{msg} is
34310 a string describing the problem.
34311 @end defun
34312
34313 @defun read-exprs str
34314 Read a list of expressions separated by commas, and return it as a
34315 Lisp list. If an error occurs in any expressions, an error list as
34316 shown above is returned instead.
34317 @end defun
34318
34319 @defun calc-do-alg-entry initial prompt no-norm
34320 Read an algebraic formula or formulas using the minibuffer. All
34321 conventions of regular algebraic entry are observed. The return value
34322 is a list of Calc formulas; there will be more than one if the user
34323 entered a list of values separated by commas. The result is @code{nil}
34324 if the user presses Return with a blank line. If @var{initial} is
34325 given, it is a string which the minibuffer will initially contain.
34326 If @var{prompt} is given, it is the prompt string to use; the default
34327 is ``Algebraic:''. If @var{no-norm} is @code{t}, the formulas will
34328 be returned exactly as parsed; otherwise, they will be passed through
34329 @code{calc-normalize} first.
34330
34331 To support the use of @kbd{$} characters in the algebraic entry, use
34332 @code{let} to bind @code{calc-dollar-values} to a list of the values
34333 to be substituted for @kbd{$}, @kbd{$$}, and so on, and bind
34334 @code{calc-dollar-used} to 0. Upon return, @code{calc-dollar-used}
34335 will have been changed to the highest number of consecutive @kbd{$}s
34336 that actually appeared in the input.
34337 @end defun
34338
34339 @defun format-number a
34340 Convert the real or complex number or HMS form @var{a} to string form.
34341 @end defun
34342
34343 @defun format-flat-expr a prec
34344 Convert the arbitrary Calc number or formula @var{a} to string form,
34345 in the style used by the trail buffer and the @code{calc-edit} command.
34346 This is a simple format designed
34347 mostly to guarantee the string is of a form that can be re-parsed by
34348 @code{read-expr}. Most formatting modes, such as digit grouping,
34349 complex number format, and point character, are ignored to ensure the
34350 result will be re-readable. The @var{prec} parameter is normally 0; if
34351 you pass a large integer like 1000 instead, the expression will be
34352 surrounded by parentheses unless it is a plain number or variable name.
34353 @end defun
34354
34355 @defun format-nice-expr a width
34356 This is like @code{format-flat-expr} (with @var{prec} equal to 0),
34357 except that newlines will be inserted to keep lines down to the
34358 specified @var{width}, and vectors that look like matrices or rewrite
34359 rules are written in a pseudo-matrix format. The @code{calc-edit}
34360 command uses this when only one stack entry is being edited.
34361 @end defun
34362
34363 @defun format-value a width
34364 Convert the Calc number or formula @var{a} to string form, using the
34365 format seen in the stack buffer. Beware the string returned may
34366 not be re-readable by @code{read-expr}, for example, because of digit
34367 grouping. Multi-line objects like matrices produce strings that
34368 contain newline characters to separate the lines. The @var{w}
34369 parameter, if given, is the target window size for which to format
34370 the expressions. If @var{w} is omitted, the width of the Calculator
34371 window is used.
34372 @end defun
34373
34374 @defun compose-expr a prec
34375 Format the Calc number or formula @var{a} according to the current
34376 language mode, returning a ``composition.'' To learn about the
34377 structure of compositions, see the comments in the Calc source code.
34378 You can specify the format of a given type of function call by putting
34379 a @code{math-compose-@var{lang}} property on the function's symbol,
34380 whose value is a Lisp function that takes @var{a} and @var{prec} as
34381 arguments and returns a composition. Here @var{lang} is a language
34382 mode name, one of @code{normal}, @code{big}, @code{c}, @code{pascal},
34383 @code{fortran}, @code{tex}, @code{eqn}, @code{math}, or @code{maple}.
34384 In Big mode, Calc actually tries @code{math-compose-big} first, then
34385 tries @code{math-compose-normal}. If this property does not exist,
34386 or if the function returns @code{nil}, the function is written in the
34387 normal function-call notation for that language.
34388 @end defun
34389
34390 @defun composition-to-string c w
34391 Convert a composition structure returned by @code{compose-expr} into
34392 a string. Multi-line compositions convert to strings containing
34393 newline characters. The target window size is given by @var{w}.
34394 The @code{format-value} function basically calls @code{compose-expr}
34395 followed by @code{composition-to-string}.
34396 @end defun
34397
34398 @defun comp-width c
34399 Compute the width in characters of composition @var{c}.
34400 @end defun
34401
34402 @defun comp-height c
34403 Compute the height in lines of composition @var{c}.
34404 @end defun
34405
34406 @defun comp-ascent c
34407 Compute the portion of the height of composition @var{c} which is on or
34408 above the baseline. For a one-line composition, this will be one.
34409 @end defun
34410
34411 @defun comp-descent c
34412 Compute the portion of the height of composition @var{c} which is below
34413 the baseline. For a one-line composition, this will be zero.
34414 @end defun
34415
34416 @defun comp-first-char c
34417 If composition @var{c} is a ``flat'' composition, return the first
34418 (leftmost) character of the composition as an integer. Otherwise,
34419 return @code{nil}.
34420 @end defun
34421
34422 @defun comp-last-char c
34423 If composition @var{c} is a ``flat'' composition, return the last
34424 (rightmost) character, otherwise return @code{nil}.
34425 @end defun
34426
34427 @comment @node Lisp Variables, Hooks, Formatting Lisp Functions, Internals
34428 @comment @subsubsection Lisp Variables
34429 @comment
34430 @comment @noindent
34431 @comment (This section is currently unfinished.)
34432
34433 @node Hooks, , Formatting Lisp Functions, Internals
34434 @subsubsection Hooks
34435
34436 @noindent
34437 Hooks are variables which contain Lisp functions (or lists of functions)
34438 which are called at various times. Calc defines a number of hooks
34439 that help you to customize it in various ways. Calc uses the Lisp
34440 function @code{run-hooks} to invoke the hooks shown below. Several
34441 other customization-related variables are also described here.
34442
34443 @defvar calc-load-hook
34444 This hook is called at the end of @file{calc.el}, after the file has
34445 been loaded, before any functions in it have been called, but after
34446 @code{calc-mode-map} and similar variables have been set up.
34447 @end defvar
34448
34449 @defvar calc-ext-load-hook
34450 This hook is called at the end of @file{calc-ext.el}.
34451 @end defvar
34452
34453 @defvar calc-start-hook
34454 This hook is called as the last step in a @kbd{M-x calc} command.
34455 At this point, the Calc buffer has been created and initialized if
34456 necessary, the Calc window and trail window have been created,
34457 and the ``Welcome to Calc'' message has been displayed.
34458 @end defvar
34459
34460 @defvar calc-mode-hook
34461 This hook is called when the Calc buffer is being created. Usually
34462 this will only happen once per Emacs session. The hook is called
34463 after Emacs has switched to the new buffer, the mode-settings file
34464 has been read if necessary, and all other buffer-local variables
34465 have been set up. After this hook returns, Calc will perform a
34466 @code{calc-refresh} operation, set up the mode line display, then
34467 evaluate any deferred @code{calc-define} properties that have not
34468 been evaluated yet.
34469 @end defvar
34470
34471 @defvar calc-trail-mode-hook
34472 This hook is called when the Calc Trail buffer is being created.
34473 It is called as the very last step of setting up the Trail buffer.
34474 Like @code{calc-mode-hook}, this will normally happen only once
34475 per Emacs session.
34476 @end defvar
34477
34478 @defvar calc-end-hook
34479 This hook is called by @code{calc-quit}, generally because the user
34480 presses @kbd{q} or @kbd{M-# c} while in Calc. The Calc buffer will
34481 be the current buffer. The hook is called as the very first
34482 step, before the Calc window is destroyed.
34483 @end defvar
34484
34485 @defvar calc-window-hook
34486 If this hook exists, it is called to create the Calc window.
34487 Upon return, this new Calc window should be the current window.
34488 (The Calc buffer will already be the current buffer when the
34489 hook is called.) If the hook is not defined, Calc will
34490 generally use @code{split-window}, @code{set-window-buffer},
34491 and @code{select-window} to create the Calc window.
34492 @end defvar
34493
34494 @defvar calc-trail-window-hook
34495 If this hook exists, it is called to create the Calc Trail window.
34496 The variable @code{calc-trail-buffer} will contain the buffer
34497 which the window should use. Unlike @code{calc-window-hook},
34498 this hook must @emph{not} switch into the new window.
34499 @end defvar
34500
34501 @defvar calc-edit-mode-hook
34502 This hook is called by @code{calc-edit} (and the other ``edit''
34503 commands) when the temporary editing buffer is being created.
34504 The buffer will have been selected and set up to be in
34505 @code{calc-edit-mode}, but will not yet have been filled with
34506 text. (In fact it may still have leftover text from a previous
34507 @code{calc-edit} command.)
34508 @end defvar
34509
34510 @defvar calc-mode-save-hook
34511 This hook is called by the @code{calc-save-modes} command,
34512 after Calc's own mode features have been inserted into the
34513 Calc init file and just before the ``End of mode settings''
34514 message is inserted.
34515 @end defvar
34516
34517 @defvar calc-reset-hook
34518 This hook is called after @kbd{M-# 0} (@code{calc-reset}) has
34519 reset all modes. The Calc buffer will be the current buffer.
34520 @end defvar
34521
34522 @defvar calc-other-modes
34523 This variable contains a list of strings. The strings are
34524 concatenated at the end of the modes portion of the Calc
34525 mode line (after standard modes such as ``Deg'', ``Inv'' and
34526 ``Hyp''). Each string should be a short, single word followed
34527 by a space. The variable is @code{nil} by default.
34528 @end defvar
34529
34530 @defvar calc-mode-map
34531 This is the keymap that is used by Calc mode. The best time
34532 to adjust it is probably in a @code{calc-mode-hook}. If the
34533 Calc extensions package (@file{calc-ext.el}) has not yet been
34534 loaded, many of these keys will be bound to @code{calc-missing-key},
34535 which is a command that loads the extensions package and
34536 ``retypes'' the key. If your @code{calc-mode-hook} rebinds
34537 one of these keys, it will probably be overridden when the
34538 extensions are loaded.
34539 @end defvar
34540
34541 @defvar calc-digit-map
34542 This is the keymap that is used during numeric entry. Numeric
34543 entry uses the minibuffer, but this map binds every non-numeric
34544 key to @code{calcDigit-nondigit} which generally calls
34545 @code{exit-minibuffer} and ``retypes'' the key.
34546 @end defvar
34547
34548 @defvar calc-alg-ent-map
34549 This is the keymap that is used during algebraic entry. This is
34550 mostly a copy of @code{minibuffer-local-map}.
34551 @end defvar
34552
34553 @defvar calc-store-var-map
34554 This is the keymap that is used during entry of variable names for
34555 commands like @code{calc-store} and @code{calc-recall}. This is
34556 mostly a copy of @code{minibuffer-local-completion-map}.
34557 @end defvar
34558
34559 @defvar calc-edit-mode-map
34560 This is the (sparse) keymap used by @code{calc-edit} and other
34561 temporary editing commands. It binds @key{RET}, @key{LFD},
34562 and @kbd{C-c C-c} to @code{calc-edit-finish}.
34563 @end defvar
34564
34565 @defvar calc-mode-var-list
34566 This is a list of variables which are saved by @code{calc-save-modes}.
34567 Each entry is a list of two items, the variable (as a Lisp symbol)
34568 and its default value. When modes are being saved, each variable
34569 is compared with its default value (using @code{equal}) and any
34570 non-default variables are written out.
34571 @end defvar
34572
34573 @defvar calc-local-var-list
34574 This is a list of variables which should be buffer-local to the
34575 Calc buffer. Each entry is a variable name (as a Lisp symbol).
34576 These variables also have their default values manipulated by
34577 the @code{calc} and @code{calc-quit} commands; @pxref{Multiple Calculators}.
34578 Since @code{calc-mode-hook} is called after this list has been
34579 used the first time, your hook should add a variable to the
34580 list and also call @code{make-local-variable} itself.
34581 @end defvar
34582
34583 @node Installation, Reporting Bugs, Programming, Top
34584 @appendix Installation
34585
34586 @noindent
34587 As of Calc 2.02g, Calc is integrated with GNU Emacs, and thus requires
34588 no separate installation of its Lisp files and this manual.
34589
34590 @appendixsec The GNUPLOT Program
34591
34592 @noindent
34593 Calc's graphing commands use the GNUPLOT program. If you have GNUPLOT
34594 but you must type some command other than @file{gnuplot} to get it,
34595 you should add a command to set the Lisp variable @code{calc-gnuplot-name}
34596 to the appropriate file name. You may also need to change the variables
34597 @code{calc-gnuplot-plot-command} and @code{calc-gnuplot-print-command} in
34598 order to get correct displays and hardcopies, respectively, of your
34599 plots.
34600
34601 @ifinfo
34602 @example
34603
34604 @end example
34605 @end ifinfo
34606 @appendixsec Printed Documentation
34607
34608 @noindent
34609 Because the Calc manual is so large, you should only make a printed
34610 copy if you really need it. To print the manual, you will need the
34611 @TeX{} typesetting program (this is a free program by Donald Knuth
34612 at Stanford University) as well as the @file{texindex} program and
34613 @file{texinfo.tex} file, both of which can be obtained from the FSF
34614 as part of the @code{texinfo} package.
34615
34616 To print the Calc manual in one huge 470 page tome, you will need the
34617 source code to this manual, @file{calc.texi}, available as part of the
34618 Emacs source. Once you have this file, type @kbd{texi2dvi calc.texi}.
34619 Alternatively, change to the @file{man} subdirectory of the Emacs
34620 source distribution, and type @kbd{make calc.dvi}. (Don't worry if you
34621 get some ``overfull box'' warnings while @TeX{} runs.)
34622
34623 The result will be a device-independent output file called
34624 @file{calc.dvi}, which you must print in whatever way is right
34625 for your system. On many systems, the command is
34626
34627 @example
34628 lpr -d calc.dvi
34629 @end example
34630
34631 @noindent
34632 or
34633
34634 @example
34635 dvips calc.dvi
34636 @end example
34637
34638 @c the bumpoddpages macro was deleted
34639 @ignore
34640 @cindex Marginal notes, adjusting
34641 Marginal notes for each function and key sequence normally alternate
34642 between the left and right sides of the page, which is correct if the
34643 manual is going to be bound as double-sided pages. Near the top of
34644 the file @file{calc.texi} you will find alternate definitions of
34645 the @code{\bumpoddpages} macro that put the marginal notes always on
34646 the same side, best if you plan to be binding single-sided pages.
34647 @end ignore
34648
34649 @appendixsec Settings File
34650
34651 @noindent
34652 @vindex calc-settings-file
34653 Another variable you might want to set is @code{calc-settings-file},
34654 which holds the file name in which commands like @kbd{m m} and @kbd{Z P}
34655 store ``permanent'' definitions. The default value for this variable
34656 is @code{"~/.calc.el"}. If @code{calc-settings-file} is not your user
34657 init file (typically @file{~/.emacs}) and if the variable
34658 @code{calc-loaded-settings-file} is @code{nil}, then Calc will
34659 automatically load your settings file (if it exists) the first time
34660 Calc is invoked.
34661
34662 @ifinfo
34663 @example
34664
34665 @end example
34666 @end ifinfo
34667 @appendixsec Testing the Installation
34668
34669 @noindent
34670 To test your installation of Calc, start a new Emacs and type @kbd{M-# c}
34671 to make sure the autoloads and key bindings work. Type @kbd{M-# i}
34672 to make sure Calc can find its Info documentation. Press @kbd{q} to
34673 exit the Info system and @kbd{M-# c} to re-enter the Calculator.
34674 Type @kbd{20 S} to compute the sine of 20 degrees; this will test the
34675 autoloading of the extensions modules. The result should be
34676 0.342020143326. Finally, press @kbd{M-# c} again to make sure the
34677 Calculator can exit.
34678
34679 You may also wish to test the GNUPLOT interface; to plot a sine wave,
34680 type @kbd{' [0 ..@: 360], sin(x) @key{RET} g f}. Type @kbd{g q} when you
34681 are done viewing the plot.
34682
34683 Calc is now ready to use. If you wish to go through the Calc Tutorial,
34684 press @kbd{M-# t} to begin.
34685 @example
34686
34687 @end example
34688 @node Reporting Bugs, Summary, Installation, Top
34689 @appendix Reporting Bugs
34690
34691 @noindent
34692 If you find a bug in Calc, send e-mail to Jay Belanger,
34693
34694 @example
34695 belanger@@truman.edu
34696 @end example
34697
34698 @noindent
34699 (In the following text, ``I'' refers to the original Calc author, Dave
34700 Gillespie).
34701
34702 While I cannot guarantee that I will have time to work on your bug,
34703 I do try to fix bugs quickly whenever I can.
34704
34705 The latest version of Calc is available from Savannah, in the Emacs
34706 CVS tree. See @uref{http://savannah.gnu.org/projects/emacs}.
34707
34708 There is an automatic command @kbd{M-x report-calc-bug} which helps
34709 you to report bugs. This command prompts you for a brief subject
34710 line, then leaves you in a mail editing buffer. Type @kbd{C-c C-c} to
34711 send your mail. Make sure your subject line indicates that you are
34712 reporting a Calc bug; this command sends mail to the maintainer's
34713 regular mailbox.
34714
34715 If you have suggestions for additional features for Calc, I would
34716 love to hear them. Some have dared to suggest that Calc is already
34717 top-heavy with features; I really don't see what they're talking
34718 about, so, if you have ideas, send them right in. (I may even have
34719 time to implement them!)
34720
34721 At the front of the source file, @file{calc.el}, is a list of ideas for
34722 future work which I have not had time to do. If any enthusiastic souls
34723 wish to take it upon themselves to work on these, I would be delighted.
34724 Please let me know if you plan to contribute to Calc so I can coordinate
34725 your efforts with mine and those of others. I will do my best to help
34726 you in whatever way I can.
34727
34728 @c [summary]
34729 @node Summary, Key Index, Reporting Bugs, Top
34730 @appendix Calc Summary
34731
34732 @noindent
34733 This section includes a complete list of Calc 2.02 keystroke commands.
34734 Each line lists the stack entries used by the command (top-of-stack
34735 last), the keystrokes themselves, the prompts asked by the command,
34736 and the result of the command (also with top-of-stack last).
34737 The result is expressed using the equivalent algebraic function.
34738 Commands which put no results on the stack show the full @kbd{M-x}
34739 command name in that position. Numbers preceding the result or
34740 command name refer to notes at the end.
34741
34742 Algebraic functions and @kbd{M-x} commands that don't have corresponding
34743 keystrokes are not listed in this summary.
34744 @xref{Command Index}. @xref{Function Index}.
34745
34746 @iftex
34747 @begingroup
34748 @tex
34749 \vskip-2\baselineskip \null
34750 \gdef\sumrow#1{\sumrowx#1\relax}%
34751 \gdef\sumrowx#1\:#2\:#3\:#4\:#5\:#6\relax{%
34752 \leavevmode%
34753 {\smallfonts
34754 \hbox to5em{\sl\hss#1}%
34755 \hbox to5em{\tt#2\hss}%
34756 \hbox to4em{\sl#3\hss}%
34757 \hbox to5em{\rm\hss#4}%
34758 \thinspace%
34759 {\tt#5}%
34760 {\sl#6}%
34761 }}%
34762 \gdef\sumlpar{{\rm(}}%
34763 \gdef\sumrpar{{\rm)}}%
34764 \gdef\sumcomma{{\rm,\thinspace}}%
34765 \gdef\sumexcl{{\rm!}}%
34766 \gdef\sumbreak{\vskip-2.5\baselineskip\goodbreak}%
34767 \gdef\minus#1{{\tt-}}%
34768 @end tex
34769 @let@:=@sumsep
34770 @let@r=@sumrow
34771 @catcode`@(=@active @let(=@sumlpar
34772 @catcode`@)=@active @let)=@sumrpar
34773 @catcode`@,=@active @let,=@sumcomma
34774 @catcode`@!=@active @let!=@sumexcl
34775 @end iftex
34776 @format
34777 @iftex
34778 @advance@baselineskip-2.5pt
34779 @let@c@sumbreak
34780 @end iftex
34781 @r{ @: M-# a @: @: 33 @:calc-embedded-activate@:}
34782 @r{ @: M-# b @: @: @:calc-big-or-small@:}
34783 @r{ @: M-# c @: @: @:calc@:}
34784 @r{ @: M-# d @: @: @:calc-embedded-duplicate@:}
34785 @r{ @: M-# e @: @: 34 @:calc-embedded@:}
34786 @r{ @: M-# f @:formula @: @:calc-embedded-new-formula@:}
34787 @r{ @: M-# g @: @: 35 @:calc-grab-region@:}
34788 @r{ @: M-# i @: @: @:calc-info@:}
34789 @r{ @: M-# j @: @: @:calc-embedded-select@:}
34790 @r{ @: M-# k @: @: @:calc-keypad@:}
34791 @r{ @: M-# l @: @: @:calc-load-everything@:}
34792 @r{ @: M-# m @: @: @:read-kbd-macro@:}
34793 @r{ @: M-# n @: @: 4 @:calc-embedded-next@:}
34794 @r{ @: M-# o @: @: @:calc-other-window@:}
34795 @r{ @: M-# p @: @: 4 @:calc-embedded-previous@:}
34796 @r{ @: M-# q @:formula @: @:quick-calc@:}
34797 @r{ @: M-# r @: @: 36 @:calc-grab-rectangle@:}
34798 @r{ @: M-# s @: @: @:calc-info-summary@:}
34799 @r{ @: M-# t @: @: @:calc-tutorial@:}
34800 @r{ @: M-# u @: @: @:calc-embedded-update@:}
34801 @r{ @: M-# w @: @: @:calc-embedded-word@:}
34802 @r{ @: M-# x @: @: @:calc-quit@:}
34803 @r{ @: M-# y @: @:1,28,49 @:calc-copy-to-buffer@:}
34804 @r{ @: M-# z @: @: @:calc-user-invocation@:}
34805 @r{ @: M-# : @: @: 36 @:calc-grab-sum-down@:}
34806 @r{ @: M-# _ @: @: 36 @:calc-grab-sum-across@:}
34807 @r{ @: M-# ` @:editing @: 30 @:calc-embedded-edit@:}
34808 @r{ @: M-# 0 @:(zero) @: @:calc-reset@:}
34809
34810 @c
34811 @r{ @: 0-9 @:number @: @:@:number}
34812 @r{ @: . @:number @: @:@:0.number}
34813 @r{ @: _ @:number @: @:-@:number}
34814 @r{ @: e @:number @: @:@:1e number}
34815 @r{ @: # @:number @: @:@:current-radix@tfn{#}number}
34816 @r{ @: P @:(in number) @: @:+/-@:}
34817 @r{ @: M @:(in number) @: @:mod@:}
34818 @r{ @: @@ ' " @: (in number)@: @:@:HMS form}
34819 @r{ @: h m s @: (in number)@: @:@:HMS form}
34820
34821 @c
34822 @r{ @: ' @:formula @: 37,46 @:@:formula}
34823 @r{ @: $ @:formula @: 37,46 @:$@:formula}
34824 @r{ @: " @:string @: 37,46 @:@:string}
34825
34826 @c
34827 @r{ a b@: + @: @: 2 @:add@:(a,b) a+b}
34828 @r{ a b@: - @: @: 2 @:sub@:(a,b) a@minus{}b}
34829 @r{ a b@: * @: @: 2 @:mul@:(a,b) a b, a*b}
34830 @r{ a b@: / @: @: 2 @:div@:(a,b) a/b}
34831 @r{ a b@: ^ @: @: 2 @:pow@:(a,b) a^b}
34832 @r{ a b@: I ^ @: @: 2 @:nroot@:(a,b) a^(1/b)}
34833 @r{ a b@: % @: @: 2 @:mod@:(a,b) a%b}
34834 @r{ a b@: \ @: @: 2 @:idiv@:(a,b) a\b}
34835 @r{ a b@: : @: @: 2 @:fdiv@:(a,b)}
34836 @r{ a b@: | @: @: 2 @:vconcat@:(a,b) a|b}
34837 @r{ a b@: I | @: @: @:vconcat@:(b,a) b|a}
34838 @r{ a b@: H | @: @: 2 @:append@:(a,b)}
34839 @r{ a b@: I H | @: @: @:append@:(b,a)}
34840 @r{ a@: & @: @: 1 @:inv@:(a) 1/a}
34841 @r{ a@: ! @: @: 1 @:fact@:(a) a!}
34842 @r{ a@: = @: @: 1 @:evalv@:(a)}
34843 @r{ a@: M-% @: @: @:percent@:(a) a%}
34844
34845 @c
34846 @r{ ... a@: @key{RET} @: @: 1 @:@:... a a}
34847 @r{ ... a@: @key{SPC} @: @: 1 @:@:... a a}
34848 @r{... a b@: @key{TAB} @: @: 3 @:@:... b a}
34849 @r{. a b c@: M-@key{TAB} @: @: 3 @:@:... b c a}
34850 @r{... a b@: @key{LFD} @: @: 1 @:@:... a b a}
34851 @r{ ... a@: @key{DEL} @: @: 1 @:@:...}
34852 @r{... a b@: M-@key{DEL} @: @: 1 @:@:... b}
34853 @r{ @: M-@key{RET} @: @: 4 @:calc-last-args@:}
34854 @r{ a@: ` @:editing @: 1,30 @:calc-edit@:}
34855
34856 @c
34857 @r{ ... a@: C-d @: @: 1 @:@:...}
34858 @r{ @: C-k @: @: 27 @:calc-kill@:}
34859 @r{ @: C-w @: @: 27 @:calc-kill-region@:}
34860 @r{ @: C-y @: @: @:calc-yank@:}
34861 @r{ @: C-_ @: @: 4 @:calc-undo@:}
34862 @r{ @: M-k @: @: 27 @:calc-copy-as-kill@:}
34863 @r{ @: M-w @: @: 27 @:calc-copy-region-as-kill@:}
34864
34865 @c
34866 @r{ @: [ @: @: @:@:[...}
34867 @r{[.. a b@: ] @: @: @:@:[a,b]}
34868 @r{ @: ( @: @: @:@:(...}
34869 @r{(.. a b@: ) @: @: @:@:(a,b)}
34870 @r{ @: , @: @: @:@:vector or rect complex}
34871 @r{ @: ; @: @: @:@:matrix or polar complex}
34872 @r{ @: .. @: @: @:@:interval}
34873
34874 @c
34875 @r{ @: ~ @: @: @:calc-num-prefix@:}
34876 @r{ @: < @: @: 4 @:calc-scroll-left@:}
34877 @r{ @: > @: @: 4 @:calc-scroll-right@:}
34878 @r{ @: @{ @: @: 4 @:calc-scroll-down@:}
34879 @r{ @: @} @: @: 4 @:calc-scroll-up@:}
34880 @r{ @: ? @: @: @:calc-help@:}
34881
34882 @c
34883 @r{ a@: n @: @: 1 @:neg@:(a) @minus{}a}
34884 @r{ @: o @: @: 4 @:calc-realign@:}
34885 @r{ @: p @:precision @: 31 @:calc-precision@:}
34886 @r{ @: q @: @: @:calc-quit@:}
34887 @r{ @: w @: @: @:calc-why@:}
34888 @r{ @: x @:command @: @:M-x calc-@:command}
34889 @r{ a@: y @: @:1,28,49 @:calc-copy-to-buffer@:}
34890
34891 @c
34892 @r{ a@: A @: @: 1 @:abs@:(a)}
34893 @r{ a b@: B @: @: 2 @:log@:(a,b)}
34894 @r{ a b@: I B @: @: 2 @:alog@:(a,b) b^a}
34895 @r{ a@: C @: @: 1 @:cos@:(a)}
34896 @r{ a@: I C @: @: 1 @:arccos@:(a)}
34897 @r{ a@: H C @: @: 1 @:cosh@:(a)}
34898 @r{ a@: I H C @: @: 1 @:arccosh@:(a)}
34899 @r{ @: D @: @: 4 @:calc-redo@:}
34900 @r{ a@: E @: @: 1 @:exp@:(a)}
34901 @r{ a@: H E @: @: 1 @:exp10@:(a) 10.^a}
34902 @r{ a@: F @: @: 1,11 @:floor@:(a,d)}
34903 @r{ a@: I F @: @: 1,11 @:ceil@:(a,d)}
34904 @r{ a@: H F @: @: 1,11 @:ffloor@:(a,d)}
34905 @r{ a@: I H F @: @: 1,11 @:fceil@:(a,d)}
34906 @r{ a@: G @: @: 1 @:arg@:(a)}
34907 @r{ @: H @:command @: 32 @:@:Hyperbolic}
34908 @r{ @: I @:command @: 32 @:@:Inverse}
34909 @r{ a@: J @: @: 1 @:conj@:(a)}
34910 @r{ @: K @:command @: 32 @:@:Keep-args}
34911 @r{ a@: L @: @: 1 @:ln@:(a)}
34912 @r{ a@: H L @: @: 1 @:log10@:(a)}
34913 @r{ @: M @: @: @:calc-more-recursion-depth@:}
34914 @r{ @: I M @: @: @:calc-less-recursion-depth@:}
34915 @r{ a@: N @: @: 5 @:evalvn@:(a)}
34916 @r{ @: P @: @: @:@:pi}
34917 @r{ @: I P @: @: @:@:gamma}
34918 @r{ @: H P @: @: @:@:e}
34919 @r{ @: I H P @: @: @:@:phi}
34920 @r{ a@: Q @: @: 1 @:sqrt@:(a)}
34921 @r{ a@: I Q @: @: 1 @:sqr@:(a) a^2}
34922 @r{ a@: R @: @: 1,11 @:round@:(a,d)}
34923 @r{ a@: I R @: @: 1,11 @:trunc@:(a,d)}
34924 @r{ a@: H R @: @: 1,11 @:fround@:(a,d)}
34925 @r{ a@: I H R @: @: 1,11 @:ftrunc@:(a,d)}
34926 @r{ a@: S @: @: 1 @:sin@:(a)}
34927 @r{ a@: I S @: @: 1 @:arcsin@:(a)}
34928 @r{ a@: H S @: @: 1 @:sinh@:(a)}
34929 @r{ a@: I H S @: @: 1 @:arcsinh@:(a)}
34930 @r{ a@: T @: @: 1 @:tan@:(a)}
34931 @r{ a@: I T @: @: 1 @:arctan@:(a)}
34932 @r{ a@: H T @: @: 1 @:tanh@:(a)}
34933 @r{ a@: I H T @: @: 1 @:arctanh@:(a)}
34934 @r{ @: U @: @: 4 @:calc-undo@:}
34935 @r{ @: X @: @: 4 @:calc-call-last-kbd-macro@:}
34936
34937 @c
34938 @r{ a b@: a = @: @: 2 @:eq@:(a,b) a=b}
34939 @r{ a b@: a # @: @: 2 @:neq@:(a,b) a!=b}
34940 @r{ a b@: a < @: @: 2 @:lt@:(a,b) a<b}
34941 @r{ a b@: a > @: @: 2 @:gt@:(a,b) a>b}
34942 @r{ a b@: a [ @: @: 2 @:leq@:(a,b) a<=b}
34943 @r{ a b@: a ] @: @: 2 @:geq@:(a,b) a>=b}
34944 @r{ a b@: a @{ @: @: 2 @:in@:(a,b)}
34945 @r{ a b@: a & @: @: 2,45 @:land@:(a,b) a&&b}
34946 @r{ a b@: a | @: @: 2,45 @:lor@:(a,b) a||b}
34947 @r{ a@: a ! @: @: 1,45 @:lnot@:(a) !a}
34948 @r{ a b c@: a : @: @: 45 @:if@:(a,b,c) a?b:c}
34949 @r{ a@: a . @: @: 1 @:rmeq@:(a)}
34950 @r{ a@: a " @: @: 7,8 @:calc-expand-formula@:}
34951
34952 @c
34953 @r{ a@: a + @:i, l, h @: 6,38 @:sum@:(a,i,l,h)}
34954 @r{ a@: a - @:i, l, h @: 6,38 @:asum@:(a,i,l,h)}
34955 @r{ a@: a * @:i, l, h @: 6,38 @:prod@:(a,i,l,h)}
34956 @r{ a b@: a _ @: @: 2 @:subscr@:(a,b) a_b}
34957
34958 @c
34959 @r{ a b@: a \ @: @: 2 @:pdiv@:(a,b)}
34960 @r{ a b@: a % @: @: 2 @:prem@:(a,b)}
34961 @r{ a b@: a / @: @: 2 @:pdivrem@:(a,b) [q,r]}
34962 @r{ a b@: H a / @: @: 2 @:pdivide@:(a,b) q+r/b}
34963
34964 @c
34965 @r{ a@: a a @: @: 1 @:apart@:(a)}
34966 @r{ a@: a b @:old, new @: 38 @:subst@:(a,old,new)}
34967 @r{ a@: a c @:v @: 38 @:collect@:(a,v)}
34968 @r{ a@: a d @:v @: 4,38 @:deriv@:(a,v)}
34969 @r{ a@: H a d @:v @: 4,38 @:tderiv@:(a,v)}
34970 @r{ a@: a e @: @: @:esimplify@:(a)}
34971 @r{ a@: a f @: @: 1 @:factor@:(a)}
34972 @r{ a@: H a f @: @: 1 @:factors@:(a)}
34973 @r{ a b@: a g @: @: 2 @:pgcd@:(a,b)}
34974 @r{ a@: a i @:v @: 38 @:integ@:(a,v)}
34975 @r{ a@: a m @:pats @: 38 @:match@:(a,pats)}
34976 @r{ a@: I a m @:pats @: 38 @:matchnot@:(a,pats)}
34977 @r{ data x@: a p @: @: 28 @:polint@:(data,x)}
34978 @r{ data x@: H a p @: @: 28 @:ratint@:(data,x)}
34979 @r{ a@: a n @: @: 1 @:nrat@:(a)}
34980 @r{ a@: a r @:rules @:4,8,38 @:rewrite@:(a,rules,n)}
34981 @r{ a@: a s @: @: @:simplify@:(a)}
34982 @r{ a@: a t @:v, n @: 31,39 @:taylor@:(a,v,n)}
34983 @r{ a@: a v @: @: 7,8 @:calc-alg-evaluate@:}
34984 @r{ a@: a x @: @: 4,8 @:expand@:(a)}
34985
34986 @c
34987 @r{ data@: a F @:model, vars @: 48 @:fit@:(m,iv,pv,data)}
34988 @r{ data@: I a F @:model, vars @: 48 @:xfit@:(m,iv,pv,data)}
34989 @r{ data@: H a F @:model, vars @: 48 @:efit@:(m,iv,pv,data)}
34990 @r{ a@: a I @:v, l, h @: 38 @:ninteg@:(a,v,l,h)}
34991 @r{ a b@: a M @:op @: 22 @:mapeq@:(op,a,b)}
34992 @r{ a b@: I a M @:op @: 22 @:mapeqr@:(op,a,b)}
34993 @r{ a b@: H a M @:op @: 22 @:mapeqp@:(op,a,b)}
34994 @r{ a g@: a N @:v @: 38 @:minimize@:(a,v,g)}
34995 @r{ a g@: H a N @:v @: 38 @:wminimize@:(a,v,g)}
34996 @r{ a@: a P @:v @: 38 @:roots@:(a,v)}
34997 @r{ a g@: a R @:v @: 38 @:root@:(a,v,g)}
34998 @r{ a g@: H a R @:v @: 38 @:wroot@:(a,v,g)}
34999 @r{ a@: a S @:v @: 38 @:solve@:(a,v)}
35000 @r{ a@: I a S @:v @: 38 @:finv@:(a,v)}
35001 @r{ a@: H a S @:v @: 38 @:fsolve@:(a,v)}
35002 @r{ a@: I H a S @:v @: 38 @:ffinv@:(a,v)}
35003 @r{ a@: a T @:i, l, h @: 6,38 @:table@:(a,i,l,h)}
35004 @r{ a g@: a X @:v @: 38 @:maximize@:(a,v,g)}
35005 @r{ a g@: H a X @:v @: 38 @:wmaximize@:(a,v,g)}
35006
35007 @c
35008 @r{ a b@: b a @: @: 9 @:and@:(a,b,w)}
35009 @r{ a@: b c @: @: 9 @:clip@:(a,w)}
35010 @r{ a b@: b d @: @: 9 @:diff@:(a,b,w)}
35011 @r{ a@: b l @: @: 10 @:lsh@:(a,n,w)}
35012 @r{ a n@: H b l @: @: 9 @:lsh@:(a,n,w)}
35013 @r{ a@: b n @: @: 9 @:not@:(a,w)}
35014 @r{ a b@: b o @: @: 9 @:or@:(a,b,w)}
35015 @r{ v@: b p @: @: 1 @:vpack@:(v)}
35016 @r{ a@: b r @: @: 10 @:rsh@:(a,n,w)}
35017 @r{ a n@: H b r @: @: 9 @:rsh@:(a,n,w)}
35018 @r{ a@: b t @: @: 10 @:rot@:(a,n,w)}
35019 @r{ a n@: H b t @: @: 9 @:rot@:(a,n,w)}
35020 @r{ a@: b u @: @: 1 @:vunpack@:(a)}
35021 @r{ @: b w @:w @: 9,50 @:calc-word-size@:}
35022 @r{ a b@: b x @: @: 9 @:xor@:(a,b,w)}
35023
35024 @c
35025 @r{c s l p@: b D @: @: @:ddb@:(c,s,l,p)}
35026 @r{ r n p@: b F @: @: @:fv@:(r,n,p)}
35027 @r{ r n p@: I b F @: @: @:fvb@:(r,n,p)}
35028 @r{ r n p@: H b F @: @: @:fvl@:(r,n,p)}
35029 @r{ v@: b I @: @: 19 @:irr@:(v)}
35030 @r{ v@: I b I @: @: 19 @:irrb@:(v)}
35031 @r{ a@: b L @: @: 10 @:ash@:(a,n,w)}
35032 @r{ a n@: H b L @: @: 9 @:ash@:(a,n,w)}
35033 @r{ r n a@: b M @: @: @:pmt@:(r,n,a)}
35034 @r{ r n a@: I b M @: @: @:pmtb@:(r,n,a)}
35035 @r{ r n a@: H b M @: @: @:pmtl@:(r,n,a)}
35036 @r{ r v@: b N @: @: 19 @:npv@:(r,v)}
35037 @r{ r v@: I b N @: @: 19 @:npvb@:(r,v)}
35038 @r{ r n p@: b P @: @: @:pv@:(r,n,p)}
35039 @r{ r n p@: I b P @: @: @:pvb@:(r,n,p)}
35040 @r{ r n p@: H b P @: @: @:pvl@:(r,n,p)}
35041 @r{ a@: b R @: @: 10 @:rash@:(a,n,w)}
35042 @r{ a n@: H b R @: @: 9 @:rash@:(a,n,w)}
35043 @r{ c s l@: b S @: @: @:sln@:(c,s,l)}
35044 @r{ n p a@: b T @: @: @:rate@:(n,p,a)}
35045 @r{ n p a@: I b T @: @: @:rateb@:(n,p,a)}
35046 @r{ n p a@: H b T @: @: @:ratel@:(n,p,a)}
35047 @r{c s l p@: b Y @: @: @:syd@:(c,s,l,p)}
35048
35049 @r{ r p a@: b # @: @: @:nper@:(r,p,a)}
35050 @r{ r p a@: I b # @: @: @:nperb@:(r,p,a)}
35051 @r{ r p a@: H b # @: @: @:nperl@:(r,p,a)}
35052 @r{ a b@: b % @: @: @:relch@:(a,b)}
35053
35054 @c
35055 @r{ a@: c c @: @: 5 @:pclean@:(a,p)}
35056 @r{ a@: c 0-9 @: @: @:pclean@:(a,p)}
35057 @r{ a@: H c c @: @: 5 @:clean@:(a,p)}
35058 @r{ a@: H c 0-9 @: @: @:clean@:(a,p)}
35059 @r{ a@: c d @: @: 1 @:deg@:(a)}
35060 @r{ a@: c f @: @: 1 @:pfloat@:(a)}
35061 @r{ a@: H c f @: @: 1 @:float@:(a)}
35062 @r{ a@: c h @: @: 1 @:hms@:(a)}
35063 @r{ a@: c p @: @: @:polar@:(a)}
35064 @r{ a@: I c p @: @: @:rect@:(a)}
35065 @r{ a@: c r @: @: 1 @:rad@:(a)}
35066
35067 @c
35068 @r{ a@: c F @: @: 5 @:pfrac@:(a,p)}
35069 @r{ a@: H c F @: @: 5 @:frac@:(a,p)}
35070
35071 @c
35072 @r{ a@: c % @: @: @:percent@:(a*100)}
35073
35074 @c
35075 @r{ @: d . @:char @: 50 @:calc-point-char@:}
35076 @r{ @: d , @:char @: 50 @:calc-group-char@:}
35077 @r{ @: d < @: @: 13,50 @:calc-left-justify@:}
35078 @r{ @: d = @: @: 13,50 @:calc-center-justify@:}
35079 @r{ @: d > @: @: 13,50 @:calc-right-justify@:}
35080 @r{ @: d @{ @:label @: 50 @:calc-left-label@:}
35081 @r{ @: d @} @:label @: 50 @:calc-right-label@:}
35082 @r{ @: d [ @: @: 4 @:calc-truncate-up@:}
35083 @r{ @: d ] @: @: 4 @:calc-truncate-down@:}
35084 @r{ @: d " @: @: 12,50 @:calc-display-strings@:}
35085 @r{ @: d @key{SPC} @: @: @:calc-refresh@:}
35086 @r{ @: d @key{RET} @: @: 1 @:calc-refresh-top@:}
35087
35088 @c
35089 @r{ @: d 0 @: @: 50 @:calc-decimal-radix@:}
35090 @r{ @: d 2 @: @: 50 @:calc-binary-radix@:}
35091 @r{ @: d 6 @: @: 50 @:calc-hex-radix@:}
35092 @r{ @: d 8 @: @: 50 @:calc-octal-radix@:}
35093
35094 @c
35095 @r{ @: d b @: @:12,13,50 @:calc-line-breaking@:}
35096 @r{ @: d c @: @: 50 @:calc-complex-notation@:}
35097 @r{ @: d d @:format @: 50 @:calc-date-notation@:}
35098 @r{ @: d e @: @: 5,50 @:calc-eng-notation@:}
35099 @r{ @: d f @:num @: 31,50 @:calc-fix-notation@:}
35100 @r{ @: d g @: @:12,13,50 @:calc-group-digits@:}
35101 @r{ @: d h @:format @: 50 @:calc-hms-notation@:}
35102 @r{ @: d i @: @: 50 @:calc-i-notation@:}
35103 @r{ @: d j @: @: 50 @:calc-j-notation@:}
35104 @r{ @: d l @: @: 12,50 @:calc-line-numbering@:}
35105 @r{ @: d n @: @: 5,50 @:calc-normal-notation@:}
35106 @r{ @: d o @:format @: 50 @:calc-over-notation@:}
35107 @r{ @: d p @: @: 12,50 @:calc-show-plain@:}
35108 @r{ @: d r @:radix @: 31,50 @:calc-radix@:}
35109 @r{ @: d s @: @: 5,50 @:calc-sci-notation@:}
35110 @r{ @: d t @: @: 27 @:calc-truncate-stack@:}
35111 @r{ @: d w @: @: 12,13 @:calc-auto-why@:}
35112 @r{ @: d z @: @: 12,50 @:calc-leading-zeros@:}
35113
35114 @c
35115 @r{ @: d B @: @: 50 @:calc-big-language@:}
35116 @r{ @: d C @: @: 50 @:calc-c-language@:}
35117 @r{ @: d E @: @: 50 @:calc-eqn-language@:}
35118 @r{ @: d F @: @: 50 @:calc-fortran-language@:}
35119 @r{ @: d M @: @: 50 @:calc-mathematica-language@:}
35120 @r{ @: d N @: @: 50 @:calc-normal-language@:}
35121 @r{ @: d O @: @: 50 @:calc-flat-language@:}
35122 @r{ @: d P @: @: 50 @:calc-pascal-language@:}
35123 @r{ @: d T @: @: 50 @:calc-tex-language@:}
35124 @r{ @: d L @: @: 50 @:calc-latex-language@:}
35125 @r{ @: d U @: @: 50 @:calc-unformatted-language@:}
35126 @r{ @: d W @: @: 50 @:calc-maple-language@:}
35127
35128 @c
35129 @r{ a@: f [ @: @: 4 @:decr@:(a,n)}
35130 @r{ a@: f ] @: @: 4 @:incr@:(a,n)}
35131
35132 @c
35133 @r{ a b@: f b @: @: 2 @:beta@:(a,b)}
35134 @r{ a@: f e @: @: 1 @:erf@:(a)}
35135 @r{ a@: I f e @: @: 1 @:erfc@:(a)}
35136 @r{ a@: f g @: @: 1 @:gamma@:(a)}
35137 @r{ a b@: f h @: @: 2 @:hypot@:(a,b)}
35138 @r{ a@: f i @: @: 1 @:im@:(a)}
35139 @r{ n a@: f j @: @: 2 @:besJ@:(n,a)}
35140 @r{ a b@: f n @: @: 2 @:min@:(a,b)}
35141 @r{ a@: f r @: @: 1 @:re@:(a)}
35142 @r{ a@: f s @: @: 1 @:sign@:(a)}
35143 @r{ a b@: f x @: @: 2 @:max@:(a,b)}
35144 @r{ n a@: f y @: @: 2 @:besY@:(n,a)}
35145
35146 @c
35147 @r{ a@: f A @: @: 1 @:abssqr@:(a)}
35148 @r{ x a b@: f B @: @: @:betaI@:(x,a,b)}
35149 @r{ x a b@: H f B @: @: @:betaB@:(x,a,b)}
35150 @r{ a@: f E @: @: 1 @:expm1@:(a)}
35151 @r{ a x@: f G @: @: 2 @:gammaP@:(a,x)}
35152 @r{ a x@: I f G @: @: 2 @:gammaQ@:(a,x)}
35153 @r{ a x@: H f G @: @: 2 @:gammag@:(a,x)}
35154 @r{ a x@: I H f G @: @: 2 @:gammaG@:(a,x)}
35155 @r{ a b@: f I @: @: 2 @:ilog@:(a,b)}
35156 @r{ a b@: I f I @: @: 2 @:alog@:(a,b) b^a}
35157 @r{ a@: f L @: @: 1 @:lnp1@:(a)}
35158 @r{ a@: f M @: @: 1 @:mant@:(a)}
35159 @r{ a@: f Q @: @: 1 @:isqrt@:(a)}
35160 @r{ a@: I f Q @: @: 1 @:sqr@:(a) a^2}
35161 @r{ a n@: f S @: @: 2 @:scf@:(a,n)}
35162 @r{ y x@: f T @: @: @:arctan2@:(y,x)}
35163 @r{ a@: f X @: @: 1 @:xpon@:(a)}
35164
35165 @c
35166 @r{ x y@: g a @: @: 28,40 @:calc-graph-add@:}
35167 @r{ @: g b @: @: 12 @:calc-graph-border@:}
35168 @r{ @: g c @: @: @:calc-graph-clear@:}
35169 @r{ @: g d @: @: 41 @:calc-graph-delete@:}
35170 @r{ x y@: g f @: @: 28,40 @:calc-graph-fast@:}
35171 @r{ @: g g @: @: 12 @:calc-graph-grid@:}
35172 @r{ @: g h @:title @: @:calc-graph-header@:}
35173 @r{ @: g j @: @: 4 @:calc-graph-juggle@:}
35174 @r{ @: g k @: @: 12 @:calc-graph-key@:}
35175 @r{ @: g l @: @: 12 @:calc-graph-log-x@:}
35176 @r{ @: g n @:name @: @:calc-graph-name@:}
35177 @r{ @: g p @: @: 42 @:calc-graph-plot@:}
35178 @r{ @: g q @: @: @:calc-graph-quit@:}
35179 @r{ @: g r @:range @: @:calc-graph-range-x@:}
35180 @r{ @: g s @: @: 12,13 @:calc-graph-line-style@:}
35181 @r{ @: g t @:title @: @:calc-graph-title-x@:}
35182 @r{ @: g v @: @: @:calc-graph-view-commands@:}
35183 @r{ @: g x @:display @: @:calc-graph-display@:}
35184 @r{ @: g z @: @: 12 @:calc-graph-zero-x@:}
35185
35186 @c
35187 @r{ x y z@: g A @: @: 28,40 @:calc-graph-add-3d@:}
35188 @r{ @: g C @:command @: @:calc-graph-command@:}
35189 @r{ @: g D @:device @: 43,44 @:calc-graph-device@:}
35190 @r{ x y z@: g F @: @: 28,40 @:calc-graph-fast-3d@:}
35191 @r{ @: g H @: @: 12 @:calc-graph-hide@:}
35192 @r{ @: g K @: @: @:calc-graph-kill@:}
35193 @r{ @: g L @: @: 12 @:calc-graph-log-y@:}
35194 @r{ @: g N @:number @: 43,51 @:calc-graph-num-points@:}
35195 @r{ @: g O @:filename @: 43,44 @:calc-graph-output@:}
35196 @r{ @: g P @: @: 42 @:calc-graph-print@:}
35197 @r{ @: g R @:range @: @:calc-graph-range-y@:}
35198 @r{ @: g S @: @: 12,13 @:calc-graph-point-style@:}
35199 @r{ @: g T @:title @: @:calc-graph-title-y@:}
35200 @r{ @: g V @: @: @:calc-graph-view-trail@:}
35201 @r{ @: g X @:format @: @:calc-graph-geometry@:}
35202 @r{ @: g Z @: @: 12 @:calc-graph-zero-y@:}
35203
35204 @c
35205 @r{ @: g C-l @: @: 12 @:calc-graph-log-z@:}
35206 @r{ @: g C-r @:range @: @:calc-graph-range-z@:}
35207 @r{ @: g C-t @:title @: @:calc-graph-title-z@:}
35208
35209 @c
35210 @r{ @: h b @: @: @:calc-describe-bindings@:}
35211 @r{ @: h c @:key @: @:calc-describe-key-briefly@:}
35212 @r{ @: h f @:function @: @:calc-describe-function@:}
35213 @r{ @: h h @: @: @:calc-full-help@:}
35214 @r{ @: h i @: @: @:calc-info@:}
35215 @r{ @: h k @:key @: @:calc-describe-key@:}
35216 @r{ @: h n @: @: @:calc-view-news@:}
35217 @r{ @: h s @: @: @:calc-info-summary@:}
35218 @r{ @: h t @: @: @:calc-tutorial@:}
35219 @r{ @: h v @:var @: @:calc-describe-variable@:}
35220
35221 @c
35222 @r{ @: j 1-9 @: @: @:calc-select-part@:}
35223 @r{ @: j @key{RET} @: @: 27 @:calc-copy-selection@:}
35224 @r{ @: j @key{DEL} @: @: 27 @:calc-del-selection@:}
35225 @r{ @: j ' @:formula @: 27 @:calc-enter-selection@:}
35226 @r{ @: j ` @:editing @: 27,30 @:calc-edit-selection@:}
35227 @r{ @: j " @: @: 7,27 @:calc-sel-expand-formula@:}
35228
35229 @c
35230 @r{ @: j + @:formula @: 27 @:calc-sel-add-both-sides@:}
35231 @r{ @: j - @:formula @: 27 @:calc-sel-sub-both-sides@:}
35232 @r{ @: j * @:formula @: 27 @:calc-sel-mul-both-sides@:}
35233 @r{ @: j / @:formula @: 27 @:calc-sel-div-both-sides@:}
35234 @r{ @: j & @: @: 27 @:calc-sel-invert@:}
35235
35236 @c
35237 @r{ @: j a @: @: 27 @:calc-select-additional@:}
35238 @r{ @: j b @: @: 12 @:calc-break-selections@:}
35239 @r{ @: j c @: @: @:calc-clear-selections@:}
35240 @r{ @: j d @: @: 12,50 @:calc-show-selections@:}
35241 @r{ @: j e @: @: 12 @:calc-enable-selections@:}
35242 @r{ @: j l @: @: 4,27 @:calc-select-less@:}
35243 @r{ @: j m @: @: 4,27 @:calc-select-more@:}
35244 @r{ @: j n @: @: 4 @:calc-select-next@:}
35245 @r{ @: j o @: @: 4,27 @:calc-select-once@:}
35246 @r{ @: j p @: @: 4 @:calc-select-previous@:}
35247 @r{ @: j r @:rules @:4,8,27 @:calc-rewrite-selection@:}
35248 @r{ @: j s @: @: 4,27 @:calc-select-here@:}
35249 @r{ @: j u @: @: 27 @:calc-unselect@:}
35250 @r{ @: j v @: @: 7,27 @:calc-sel-evaluate@:}
35251
35252 @c
35253 @r{ @: j C @: @: 27 @:calc-sel-commute@:}
35254 @r{ @: j D @: @: 4,27 @:calc-sel-distribute@:}
35255 @r{ @: j E @: @: 27 @:calc-sel-jump-equals@:}
35256 @r{ @: j I @: @: 27 @:calc-sel-isolate@:}
35257 @r{ @: H j I @: @: 27 @:calc-sel-isolate@: (full)}
35258 @r{ @: j L @: @: 4,27 @:calc-commute-left@:}
35259 @r{ @: j M @: @: 27 @:calc-sel-merge@:}
35260 @r{ @: j N @: @: 27 @:calc-sel-negate@:}
35261 @r{ @: j O @: @: 4,27 @:calc-select-once-maybe@:}
35262 @r{ @: j R @: @: 4,27 @:calc-commute-right@:}
35263 @r{ @: j S @: @: 4,27 @:calc-select-here-maybe@:}
35264 @r{ @: j U @: @: 27 @:calc-sel-unpack@:}
35265
35266 @c
35267 @r{ @: k a @: @: @:calc-random-again@:}
35268 @r{ n@: k b @: @: 1 @:bern@:(n)}
35269 @r{ n x@: H k b @: @: 2 @:bern@:(n,x)}
35270 @r{ n m@: k c @: @: 2 @:choose@:(n,m)}
35271 @r{ n m@: H k c @: @: 2 @:perm@:(n,m)}
35272 @r{ n@: k d @: @: 1 @:dfact@:(n) n!!}
35273 @r{ n@: k e @: @: 1 @:euler@:(n)}
35274 @r{ n x@: H k e @: @: 2 @:euler@:(n,x)}
35275 @r{ n@: k f @: @: 4 @:prfac@:(n)}
35276 @r{ n m@: k g @: @: 2 @:gcd@:(n,m)}
35277 @r{ m n@: k h @: @: 14 @:shuffle@:(n,m)}
35278 @r{ n m@: k l @: @: 2 @:lcm@:(n,m)}
35279 @r{ n@: k m @: @: 1 @:moebius@:(n)}
35280 @r{ n@: k n @: @: 4 @:nextprime@:(n)}
35281 @r{ n@: I k n @: @: 4 @:prevprime@:(n)}
35282 @r{ n@: k p @: @: 4,28 @:calc-prime-test@:}
35283 @r{ m@: k r @: @: 14 @:random@:(m)}
35284 @r{ n m@: k s @: @: 2 @:stir1@:(n,m)}
35285 @r{ n m@: H k s @: @: 2 @:stir2@:(n,m)}
35286 @r{ n@: k t @: @: 1 @:totient@:(n)}
35287
35288 @c
35289 @r{ n p x@: k B @: @: @:utpb@:(x,n,p)}
35290 @r{ n p x@: I k B @: @: @:ltpb@:(x,n,p)}
35291 @r{ v x@: k C @: @: @:utpc@:(x,v)}
35292 @r{ v x@: I k C @: @: @:ltpc@:(x,v)}
35293 @r{ n m@: k E @: @: @:egcd@:(n,m)}
35294 @r{v1 v2 x@: k F @: @: @:utpf@:(x,v1,v2)}
35295 @r{v1 v2 x@: I k F @: @: @:ltpf@:(x,v1,v2)}
35296 @r{ m s x@: k N @: @: @:utpn@:(x,m,s)}
35297 @r{ m s x@: I k N @: @: @:ltpn@:(x,m,s)}
35298 @r{ m x@: k P @: @: @:utpp@:(x,m)}
35299 @r{ m x@: I k P @: @: @:ltpp@:(x,m)}
35300 @r{ v x@: k T @: @: @:utpt@:(x,v)}
35301 @r{ v x@: I k T @: @: @:ltpt@:(x,v)}
35302
35303 @c
35304 @r{ @: m a @: @: 12,13 @:calc-algebraic-mode@:}
35305 @r{ @: m d @: @: @:calc-degrees-mode@:}
35306 @r{ @: m f @: @: 12 @:calc-frac-mode@:}
35307 @r{ @: m g @: @: 52 @:calc-get-modes@:}
35308 @r{ @: m h @: @: @:calc-hms-mode@:}
35309 @r{ @: m i @: @: 12,13 @:calc-infinite-mode@:}
35310 @r{ @: m m @: @: @:calc-save-modes@:}
35311 @r{ @: m p @: @: 12 @:calc-polar-mode@:}
35312 @r{ @: m r @: @: @:calc-radians-mode@:}
35313 @r{ @: m s @: @: 12 @:calc-symbolic-mode@:}
35314 @r{ @: m t @: @: 12 @:calc-total-algebraic-mode@:}
35315 @r{ @: m v @: @: 12,13 @:calc-matrix-mode@:}
35316 @r{ @: m w @: @: 13 @:calc-working@:}
35317 @r{ @: m x @: @: @:calc-always-load-extensions@:}
35318
35319 @c
35320 @r{ @: m A @: @: 12 @:calc-alg-simplify-mode@:}
35321 @r{ @: m B @: @: 12 @:calc-bin-simplify-mode@:}
35322 @r{ @: m C @: @: 12 @:calc-auto-recompute@:}
35323 @r{ @: m D @: @: @:calc-default-simplify-mode@:}
35324 @r{ @: m E @: @: 12 @:calc-ext-simplify-mode@:}
35325 @r{ @: m F @:filename @: 13 @:calc-settings-file-name@:}
35326 @r{ @: m N @: @: 12 @:calc-num-simplify-mode@:}
35327 @r{ @: m O @: @: 12 @:calc-no-simplify-mode@:}
35328 @r{ @: m R @: @: 12,13 @:calc-mode-record-mode@:}
35329 @r{ @: m S @: @: 12 @:calc-shift-prefix@:}
35330 @r{ @: m U @: @: 12 @:calc-units-simplify-mode@:}
35331
35332 @c
35333 @r{ @: s c @:var1, var2 @: 29 @:calc-copy-variable@:}
35334 @r{ @: s d @:var, decl @: @:calc-declare-variable@:}
35335 @r{ @: s e @:var, editing @: 29,30 @:calc-edit-variable@:}
35336 @r{ @: s i @:buffer @: @:calc-insert-variables@:}
35337 @r{ a b@: s l @:var @: 29 @:@:a (letting var=b)}
35338 @r{ a ...@: s m @:op, var @: 22,29 @:calc-store-map@:}
35339 @r{ @: s n @:var @: 29,47 @:calc-store-neg@: (v/-1)}
35340 @r{ @: s p @:var @: 29 @:calc-permanent-variable@:}
35341 @r{ @: s r @:var @: 29 @:@:v (recalled value)}
35342 @r{ @: r 0-9 @: @: @:calc-recall-quick@:}
35343 @r{ a@: s s @:var @: 28,29 @:calc-store@:}
35344 @r{ a@: s 0-9 @: @: @:calc-store-quick@:}
35345 @r{ a@: s t @:var @: 29 @:calc-store-into@:}
35346 @r{ a@: t 0-9 @: @: @:calc-store-into-quick@:}
35347 @r{ @: s u @:var @: 29 @:calc-unstore@:}
35348 @r{ a@: s x @:var @: 29 @:calc-store-exchange@:}
35349
35350 @c
35351 @r{ @: s A @:editing @: 30 @:calc-edit-AlgSimpRules@:}
35352 @r{ @: s D @:editing @: 30 @:calc-edit-Decls@:}
35353 @r{ @: s E @:editing @: 30 @:calc-edit-EvalRules@:}
35354 @r{ @: s F @:editing @: 30 @:calc-edit-FitRules@:}
35355 @r{ @: s G @:editing @: 30 @:calc-edit-GenCount@:}
35356 @r{ @: s H @:editing @: 30 @:calc-edit-Holidays@:}
35357 @r{ @: s I @:editing @: 30 @:calc-edit-IntegLimit@:}
35358 @r{ @: s L @:editing @: 30 @:calc-edit-LineStyles@:}
35359 @r{ @: s P @:editing @: 30 @:calc-edit-PointStyles@:}
35360 @r{ @: s R @:editing @: 30 @:calc-edit-PlotRejects@:}
35361 @r{ @: s T @:editing @: 30 @:calc-edit-TimeZone@:}
35362 @r{ @: s U @:editing @: 30 @:calc-edit-Units@:}
35363 @r{ @: s X @:editing @: 30 @:calc-edit-ExtSimpRules@:}
35364
35365 @c
35366 @r{ a@: s + @:var @: 29,47 @:calc-store-plus@: (v+a)}
35367 @r{ a@: s - @:var @: 29,47 @:calc-store-minus@: (v-a)}
35368 @r{ a@: s * @:var @: 29,47 @:calc-store-times@: (v*a)}
35369 @r{ a@: s / @:var @: 29,47 @:calc-store-div@: (v/a)}
35370 @r{ a@: s ^ @:var @: 29,47 @:calc-store-power@: (v^a)}
35371 @r{ a@: s | @:var @: 29,47 @:calc-store-concat@: (v|a)}
35372 @r{ @: s & @:var @: 29,47 @:calc-store-inv@: (v^-1)}
35373 @r{ @: s [ @:var @: 29,47 @:calc-store-decr@: (v-1)}
35374 @r{ @: s ] @:var @: 29,47 @:calc-store-incr@: (v-(-1))}
35375 @r{ a b@: s : @: @: 2 @:assign@:(a,b) a @tfn{:=} b}
35376 @r{ a@: s = @: @: 1 @:evalto@:(a,b) a @tfn{=>}}
35377
35378 @c
35379 @r{ @: t [ @: @: 4 @:calc-trail-first@:}
35380 @r{ @: t ] @: @: 4 @:calc-trail-last@:}
35381 @r{ @: t < @: @: 4 @:calc-trail-scroll-left@:}
35382 @r{ @: t > @: @: 4 @:calc-trail-scroll-right@:}
35383 @r{ @: t . @: @: 12 @:calc-full-trail-vectors@:}
35384
35385 @c
35386 @r{ @: t b @: @: 4 @:calc-trail-backward@:}
35387 @r{ @: t d @: @: 12,50 @:calc-trail-display@:}
35388 @r{ @: t f @: @: 4 @:calc-trail-forward@:}
35389 @r{ @: t h @: @: @:calc-trail-here@:}
35390 @r{ @: t i @: @: @:calc-trail-in@:}
35391 @r{ @: t k @: @: 4 @:calc-trail-kill@:}
35392 @r{ @: t m @:string @: @:calc-trail-marker@:}
35393 @r{ @: t n @: @: 4 @:calc-trail-next@:}
35394 @r{ @: t o @: @: @:calc-trail-out@:}
35395 @r{ @: t p @: @: 4 @:calc-trail-previous@:}
35396 @r{ @: t r @:string @: @:calc-trail-isearch-backward@:}
35397 @r{ @: t s @:string @: @:calc-trail-isearch-forward@:}
35398 @r{ @: t y @: @: 4 @:calc-trail-yank@:}
35399
35400 @c
35401 @r{ d@: t C @:oz, nz @: @:tzconv@:(d,oz,nz)}
35402 @r{d oz nz@: t C @:$ @: @:tzconv@:(d,oz,nz)}
35403 @r{ d@: t D @: @: 15 @:date@:(d)}
35404 @r{ d@: t I @: @: 4 @:incmonth@:(d,n)}
35405 @r{ d@: t J @: @: 16 @:julian@:(d,z)}
35406 @r{ d@: t M @: @: 17 @:newmonth@:(d,n)}
35407 @r{ @: t N @: @: 16 @:now@:(z)}
35408 @r{ d@: t P @:1 @: 31 @:year@:(d)}
35409 @r{ d@: t P @:2 @: 31 @:month@:(d)}
35410 @r{ d@: t P @:3 @: 31 @:day@:(d)}
35411 @r{ d@: t P @:4 @: 31 @:hour@:(d)}
35412 @r{ d@: t P @:5 @: 31 @:minute@:(d)}
35413 @r{ d@: t P @:6 @: 31 @:second@:(d)}
35414 @r{ d@: t P @:7 @: 31 @:weekday@:(d)}
35415 @r{ d@: t P @:8 @: 31 @:yearday@:(d)}
35416 @r{ d@: t P @:9 @: 31 @:time@:(d)}
35417 @r{ d@: t U @: @: 16 @:unixtime@:(d,z)}
35418 @r{ d@: t W @: @: 17 @:newweek@:(d,w)}
35419 @r{ d@: t Y @: @: 17 @:newyear@:(d,n)}
35420
35421 @c
35422 @r{ a b@: t + @: @: 2 @:badd@:(a,b)}
35423 @r{ a b@: t - @: @: 2 @:bsub@:(a,b)}
35424
35425 @c
35426 @r{ @: u a @: @: 12 @:calc-autorange-units@:}
35427 @r{ a@: u b @: @: @:calc-base-units@:}
35428 @r{ a@: u c @:units @: 18 @:calc-convert-units@:}
35429 @r{ defn@: u d @:unit, descr @: @:calc-define-unit@:}
35430 @r{ @: u e @: @: @:calc-explain-units@:}
35431 @r{ @: u g @:unit @: @:calc-get-unit-definition@:}
35432 @r{ @: u p @: @: @:calc-permanent-units@:}
35433 @r{ a@: u r @: @: @:calc-remove-units@:}
35434 @r{ a@: u s @: @: @:usimplify@:(a)}
35435 @r{ a@: u t @:units @: 18 @:calc-convert-temperature@:}
35436 @r{ @: u u @:unit @: @:calc-undefine-unit@:}
35437 @r{ @: u v @: @: @:calc-enter-units-table@:}
35438 @r{ a@: u x @: @: @:calc-extract-units@:}
35439 @r{ a@: u 0-9 @: @: @:calc-quick-units@:}
35440
35441 @c
35442 @r{ v1 v2@: u C @: @: 20 @:vcov@:(v1,v2)}
35443 @r{ v1 v2@: I u C @: @: 20 @:vpcov@:(v1,v2)}
35444 @r{ v1 v2@: H u C @: @: 20 @:vcorr@:(v1,v2)}
35445 @r{ v@: u G @: @: 19 @:vgmean@:(v)}
35446 @r{ a b@: H u G @: @: 2 @:agmean@:(a,b)}
35447 @r{ v@: u M @: @: 19 @:vmean@:(v)}
35448 @r{ v@: I u M @: @: 19 @:vmeane@:(v)}
35449 @r{ v@: H u M @: @: 19 @:vmedian@:(v)}
35450 @r{ v@: I H u M @: @: 19 @:vhmean@:(v)}
35451 @r{ v@: u N @: @: 19 @:vmin@:(v)}
35452 @r{ v@: u S @: @: 19 @:vsdev@:(v)}
35453 @r{ v@: I u S @: @: 19 @:vpsdev@:(v)}
35454 @r{ v@: H u S @: @: 19 @:vvar@:(v)}
35455 @r{ v@: I H u S @: @: 19 @:vpvar@:(v)}
35456 @r{ @: u V @: @: @:calc-view-units-table@:}
35457 @r{ v@: u X @: @: 19 @:vmax@:(v)}
35458
35459 @c
35460 @r{ v@: u + @: @: 19 @:vsum@:(v)}
35461 @r{ v@: u * @: @: 19 @:vprod@:(v)}
35462 @r{ v@: u # @: @: 19 @:vcount@:(v)}
35463
35464 @c
35465 @r{ @: V ( @: @: 50 @:calc-vector-parens@:}
35466 @r{ @: V @{ @: @: 50 @:calc-vector-braces@:}
35467 @r{ @: V [ @: @: 50 @:calc-vector-brackets@:}
35468 @r{ @: V ] @:ROCP @: 50 @:calc-matrix-brackets@:}
35469 @r{ @: V , @: @: 50 @:calc-vector-commas@:}
35470 @r{ @: V < @: @: 50 @:calc-matrix-left-justify@:}
35471 @r{ @: V = @: @: 50 @:calc-matrix-center-justify@:}
35472 @r{ @: V > @: @: 50 @:calc-matrix-right-justify@:}
35473 @r{ @: V / @: @: 12,50 @:calc-break-vectors@:}
35474 @r{ @: V . @: @: 12,50 @:calc-full-vectors@:}
35475
35476 @c
35477 @r{ s t@: V ^ @: @: 2 @:vint@:(s,t)}
35478 @r{ s t@: V - @: @: 2 @:vdiff@:(s,t)}
35479 @r{ s@: V ~ @: @: 1 @:vcompl@:(s)}
35480 @r{ s@: V # @: @: 1 @:vcard@:(s)}
35481 @r{ s@: V : @: @: 1 @:vspan@:(s)}
35482 @r{ s@: V + @: @: 1 @:rdup@:(s)}
35483
35484 @c
35485 @r{ m@: V & @: @: 1 @:inv@:(m) 1/m}
35486
35487 @c
35488 @r{ v@: v a @:n @: @:arrange@:(v,n)}
35489 @r{ a@: v b @:n @: @:cvec@:(a,n)}
35490 @r{ v@: v c @:n >0 @: 21,31 @:mcol@:(v,n)}
35491 @r{ v@: v c @:n <0 @: 31 @:mrcol@:(v,-n)}
35492 @r{ m@: v c @:0 @: 31 @:getdiag@:(m)}
35493 @r{ v@: v d @: @: 25 @:diag@:(v,n)}
35494 @r{ v m@: v e @: @: 2 @:vexp@:(v,m)}
35495 @r{ v m f@: H v e @: @: 2 @:vexp@:(v,m,f)}
35496 @r{ v a@: v f @: @: 26 @:find@:(v,a,n)}
35497 @r{ v@: v h @: @: 1 @:head@:(v)}
35498 @r{ v@: I v h @: @: 1 @:tail@:(v)}
35499 @r{ v@: H v h @: @: 1 @:rhead@:(v)}
35500 @r{ v@: I H v h @: @: 1 @:rtail@:(v)}
35501 @r{ @: v i @:n @: 31 @:idn@:(1,n)}
35502 @r{ @: v i @:0 @: 31 @:idn@:(1)}
35503 @r{ h t@: v k @: @: 2 @:cons@:(h,t)}
35504 @r{ h t@: H v k @: @: 2 @:rcons@:(h,t)}
35505 @r{ v@: v l @: @: 1 @:vlen@:(v)}
35506 @r{ v@: H v l @: @: 1 @:mdims@:(v)}
35507 @r{ v m@: v m @: @: 2 @:vmask@:(v,m)}
35508 @r{ v@: v n @: @: 1 @:rnorm@:(v)}
35509 @r{ a b c@: v p @: @: 24 @:calc-pack@:}
35510 @r{ v@: v r @:n >0 @: 21,31 @:mrow@:(v,n)}
35511 @r{ v@: v r @:n <0 @: 31 @:mrrow@:(v,-n)}
35512 @r{ m@: v r @:0 @: 31 @:getdiag@:(m)}
35513 @r{ v i j@: v s @: @: @:subvec@:(v,i,j)}
35514 @r{ v i j@: I v s @: @: @:rsubvec@:(v,i,j)}
35515 @r{ m@: v t @: @: 1 @:trn@:(m)}
35516 @r{ v@: v u @: @: 24 @:calc-unpack@:}
35517 @r{ v@: v v @: @: 1 @:rev@:(v)}
35518 @r{ @: v x @:n @: 31 @:index@:(n)}
35519 @r{ n s i@: C-u v x @: @: @:index@:(n,s,i)}
35520
35521 @c
35522 @r{ v@: V A @:op @: 22 @:apply@:(op,v)}
35523 @r{ v1 v2@: V C @: @: 2 @:cross@:(v1,v2)}
35524 @r{ m@: V D @: @: 1 @:det@:(m)}
35525 @r{ s@: V E @: @: 1 @:venum@:(s)}
35526 @r{ s@: V F @: @: 1 @:vfloor@:(s)}
35527 @r{ v@: V G @: @: @:grade@:(v)}
35528 @r{ v@: I V G @: @: @:rgrade@:(v)}
35529 @r{ v@: V H @:n @: 31 @:histogram@:(v,n)}
35530 @r{ v w@: H V H @:n @: 31 @:histogram@:(v,w,n)}
35531 @r{ v1 v2@: V I @:mop aop @: 22 @:inner@:(mop,aop,v1,v2)}
35532 @r{ m@: V J @: @: 1 @:ctrn@:(m)}
35533 @r{ m@: V L @: @: 1 @:lud@:(m)}
35534 @r{ v@: V M @:op @: 22,23 @:map@:(op,v)}
35535 @r{ v@: V N @: @: 1 @:cnorm@:(v)}
35536 @r{ v1 v2@: V O @:op @: 22 @:outer@:(op,v1,v2)}
35537 @r{ v@: V R @:op @: 22,23 @:reduce@:(op,v)}
35538 @r{ v@: I V R @:op @: 22,23 @:rreduce@:(op,v)}
35539 @r{ a n@: H V R @:op @: 22 @:nest@:(op,a,n)}
35540 @r{ a@: I H V R @:op @: 22 @:fixp@:(op,a)}
35541 @r{ v@: V S @: @: @:sort@:(v)}
35542 @r{ v@: I V S @: @: @:rsort@:(v)}
35543 @r{ m@: V T @: @: 1 @:tr@:(m)}
35544 @r{ v@: V U @:op @: 22 @:accum@:(op,v)}
35545 @r{ v@: I V U @:op @: 22 @:raccum@:(op,v)}
35546 @r{ a n@: H V U @:op @: 22 @:anest@:(op,a,n)}
35547 @r{ a@: I H V U @:op @: 22 @:afixp@:(op,a)}
35548 @r{ s t@: V V @: @: 2 @:vunion@:(s,t)}
35549 @r{ s t@: V X @: @: 2 @:vxor@:(s,t)}
35550
35551 @c
35552 @r{ @: Y @: @: @:@:user commands}
35553
35554 @c
35555 @r{ @: z @: @: @:@:user commands}
35556
35557 @c
35558 @r{ c@: Z [ @: @: 45 @:calc-kbd-if@:}
35559 @r{ c@: Z | @: @: 45 @:calc-kbd-else-if@:}
35560 @r{ @: Z : @: @: @:calc-kbd-else@:}
35561 @r{ @: Z ] @: @: @:calc-kbd-end-if@:}
35562
35563 @c
35564 @r{ @: Z @{ @: @: 4 @:calc-kbd-loop@:}
35565 @r{ c@: Z / @: @: 45 @:calc-kbd-break@:}
35566 @r{ @: Z @} @: @: @:calc-kbd-end-loop@:}
35567 @r{ n@: Z < @: @: @:calc-kbd-repeat@:}
35568 @r{ @: Z > @: @: @:calc-kbd-end-repeat@:}
35569 @r{ n m@: Z ( @: @: @:calc-kbd-for@:}
35570 @r{ s@: Z ) @: @: @:calc-kbd-end-for@:}
35571
35572 @c
35573 @r{ @: Z C-g @: @: @:@:cancel if/loop command}
35574
35575 @c
35576 @r{ @: Z ` @: @: @:calc-kbd-push@:}
35577 @r{ @: Z ' @: @: @:calc-kbd-pop@:}
35578 @r{ a@: Z = @:message @: 28 @:calc-kbd-report@:}
35579 @r{ @: Z # @:prompt @: @:calc-kbd-query@:}
35580
35581 @c
35582 @r{ comp@: Z C @:func, args @: 50 @:calc-user-define-composition@:}
35583 @r{ @: Z D @:key, command @: @:calc-user-define@:}
35584 @r{ @: Z E @:key, editing @: 30 @:calc-user-define-edit@:}
35585 @r{ defn@: Z F @:k, c, f, a, n@: 28 @:calc-user-define-formula@:}
35586 @r{ @: Z G @:key @: @:calc-get-user-defn@:}
35587 @r{ @: Z I @: @: @:calc-user-define-invocation@:}
35588 @r{ @: Z K @:key, command @: @:calc-user-define-kbd-macro@:}
35589 @r{ @: Z P @:key @: @:calc-user-define-permanent@:}
35590 @r{ @: Z S @: @: 30 @:calc-edit-user-syntax@:}
35591 @r{ @: Z T @: @: 12 @:calc-timing@:}
35592 @r{ @: Z U @:key @: @:calc-user-undefine@:}
35593
35594 @end format
35595
35596 @noindent
35597 NOTES
35598
35599 @enumerate
35600 @c 1
35601 @item
35602 Positive prefix arguments apply to @expr{n} stack entries.
35603 Negative prefix arguments apply to the @expr{-n}th stack entry.
35604 A prefix of zero applies to the entire stack. (For @key{LFD} and
35605 @kbd{M-@key{DEL}}, the meaning of the sign is reversed.)
35606
35607 @c 2
35608 @item
35609 Positive prefix arguments apply to @expr{n} stack entries.
35610 Negative prefix arguments apply to the top stack entry
35611 and the next @expr{-n} stack entries.
35612
35613 @c 3
35614 @item
35615 Positive prefix arguments rotate top @expr{n} stack entries by one.
35616 Negative prefix arguments rotate the entire stack by @expr{-n}.
35617 A prefix of zero reverses the entire stack.
35618
35619 @c 4
35620 @item
35621 Prefix argument specifies a repeat count or distance.
35622
35623 @c 5
35624 @item
35625 Positive prefix arguments specify a precision @expr{p}.
35626 Negative prefix arguments reduce the current precision by @expr{-p}.
35627
35628 @c 6
35629 @item
35630 A prefix argument is interpreted as an additional step-size parameter.
35631 A plain @kbd{C-u} prefix means to prompt for the step size.
35632
35633 @c 7
35634 @item
35635 A prefix argument specifies simplification level and depth.
35636 1=Default, 2=like @kbd{a s}, 3=like @kbd{a e}.
35637
35638 @c 8
35639 @item
35640 A negative prefix operates only on the top level of the input formula.
35641
35642 @c 9
35643 @item
35644 Positive prefix arguments specify a word size of @expr{w} bits, unsigned.
35645 Negative prefix arguments specify a word size of @expr{w} bits, signed.
35646
35647 @c 10
35648 @item
35649 Prefix arguments specify the shift amount @expr{n}. The @expr{w} argument
35650 cannot be specified in the keyboard version of this command.
35651
35652 @c 11
35653 @item
35654 From the keyboard, @expr{d} is omitted and defaults to zero.
35655
35656 @c 12
35657 @item
35658 Mode is toggled; a positive prefix always sets the mode, and a negative
35659 prefix always clears the mode.
35660
35661 @c 13
35662 @item
35663 Some prefix argument values provide special variations of the mode.
35664
35665 @c 14
35666 @item
35667 A prefix argument, if any, is used for @expr{m} instead of taking
35668 @expr{m} from the stack. @expr{M} may take any of these values:
35669 @iftex
35670 {@advance@tableindent10pt
35671 @end iftex
35672 @table @asis
35673 @item Integer
35674 Random integer in the interval @expr{[0 .. m)}.
35675 @item Float
35676 Random floating-point number in the interval @expr{[0 .. m)}.
35677 @item 0.0
35678 Gaussian with mean 1 and standard deviation 0.
35679 @item Error form
35680 Gaussian with specified mean and standard deviation.
35681 @item Interval
35682 Random integer or floating-point number in that interval.
35683 @item Vector
35684 Random element from the vector.
35685 @end table
35686 @iftex
35687 }
35688 @end iftex
35689
35690 @c 15
35691 @item
35692 A prefix argument from 1 to 6 specifies number of date components
35693 to remove from the stack. @xref{Date Conversions}.
35694
35695 @c 16
35696 @item
35697 A prefix argument specifies a time zone; @kbd{C-u} says to take the
35698 time zone number or name from the top of the stack. @xref{Time Zones}.
35699
35700 @c 17
35701 @item
35702 A prefix argument specifies a day number (0-6, 0-31, or 0-366).
35703
35704 @c 18
35705 @item
35706 If the input has no units, you will be prompted for both the old and
35707 the new units.
35708
35709 @c 19
35710 @item
35711 With a prefix argument, collect that many stack entries to form the
35712 input data set. Each entry may be a single value or a vector of values.
35713
35714 @c 20
35715 @item
35716 With a prefix argument of 1, take a single
35717 @texline @var{n}@math{\times2}
35718 @infoline @mathit{@var{N}x2}
35719 matrix from the stack instead of two separate data vectors.
35720
35721 @c 21
35722 @item
35723 The row or column number @expr{n} may be given as a numeric prefix
35724 argument instead. A plain @kbd{C-u} prefix says to take @expr{n}
35725 from the top of the stack. If @expr{n} is a vector or interval,
35726 a subvector/submatrix of the input is created.
35727
35728 @c 22
35729 @item
35730 The @expr{op} prompt can be answered with the key sequence for the
35731 desired function, or with @kbd{x} or @kbd{z} followed by a function name,
35732 or with @kbd{$} to take a formula from the top of the stack, or with
35733 @kbd{'} and a typed formula. In the last two cases, the formula may
35734 be a nameless function like @samp{<#1+#2>} or @samp{<x, y : x+y>}, or it
35735 may include @kbd{$}, @kbd{$$}, etc. (where @kbd{$} will correspond to the
35736 last argument of the created function), or otherwise you will be
35737 prompted for an argument list. The number of vectors popped from the
35738 stack by @kbd{V M} depends on the number of arguments of the function.
35739
35740 @c 23
35741 @item
35742 One of the mapping direction keys @kbd{_} (horizontal, i.e., map
35743 by rows or reduce across), @kbd{:} (vertical, i.e., map by columns or
35744 reduce down), or @kbd{=} (map or reduce by rows) may be used before
35745 entering @expr{op}; these modify the function name by adding the letter
35746 @code{r} for ``rows,'' @code{c} for ``columns,'' @code{a} for ``across,''
35747 or @code{d} for ``down.''
35748
35749 @c 24
35750 @item
35751 The prefix argument specifies a packing mode. A nonnegative mode
35752 is the number of items (for @kbd{v p}) or the number of levels
35753 (for @kbd{v u}). A negative mode is as described below. With no
35754 prefix argument, the mode is taken from the top of the stack and
35755 may be an integer or a vector of integers.
35756 @iftex
35757 {@advance@tableindent-20pt
35758 @end iftex
35759 @table @cite
35760 @item -1
35761 (@var{2}) Rectangular complex number.
35762 @item -2
35763 (@var{2}) Polar complex number.
35764 @item -3
35765 (@var{3}) HMS form.
35766 @item -4
35767 (@var{2}) Error form.
35768 @item -5
35769 (@var{2}) Modulo form.
35770 @item -6
35771 (@var{2}) Closed interval.
35772 @item -7
35773 (@var{2}) Closed .. open interval.
35774 @item -8
35775 (@var{2}) Open .. closed interval.
35776 @item -9
35777 (@var{2}) Open interval.
35778 @item -10
35779 (@var{2}) Fraction.
35780 @item -11
35781 (@var{2}) Float with integer mantissa.
35782 @item -12
35783 (@var{2}) Float with mantissa in @expr{[1 .. 10)}.
35784 @item -13
35785 (@var{1}) Date form (using date numbers).
35786 @item -14
35787 (@var{3}) Date form (using year, month, day).
35788 @item -15
35789 (@var{6}) Date form (using year, month, day, hour, minute, second).
35790 @end table
35791 @iftex
35792 }
35793 @end iftex
35794
35795 @c 25
35796 @item
35797 A prefix argument specifies the size @expr{n} of the matrix. With no
35798 prefix argument, @expr{n} is omitted and the size is inferred from
35799 the input vector.
35800
35801 @c 26
35802 @item
35803 The prefix argument specifies the starting position @expr{n} (default 1).
35804
35805 @c 27
35806 @item
35807 Cursor position within stack buffer affects this command.
35808
35809 @c 28
35810 @item
35811 Arguments are not actually removed from the stack by this command.
35812
35813 @c 29
35814 @item
35815 Variable name may be a single digit or a full name.
35816
35817 @c 30
35818 @item
35819 Editing occurs in a separate buffer. Press @kbd{C-c C-c} (or
35820 @key{LFD}, or in some cases @key{RET}) to finish the edit, or kill the
35821 buffer with @kbd{C-x k} to cancel the edit. The @key{LFD} key prevents evaluation
35822 of the result of the edit.
35823
35824 @c 31
35825 @item
35826 The number prompted for can also be provided as a prefix argument.
35827
35828 @c 32
35829 @item
35830 Press this key a second time to cancel the prefix.
35831
35832 @c 33
35833 @item
35834 With a negative prefix, deactivate all formulas. With a positive
35835 prefix, deactivate and then reactivate from scratch.
35836
35837 @c 34
35838 @item
35839 Default is to scan for nearest formula delimiter symbols. With a
35840 prefix of zero, formula is delimited by mark and point. With a
35841 non-zero prefix, formula is delimited by scanning forward or
35842 backward by that many lines.
35843
35844 @c 35
35845 @item
35846 Parse the region between point and mark as a vector. A nonzero prefix
35847 parses @var{n} lines before or after point as a vector. A zero prefix
35848 parses the current line as a vector. A @kbd{C-u} prefix parses the
35849 region between point and mark as a single formula.
35850
35851 @c 36
35852 @item
35853 Parse the rectangle defined by point and mark as a matrix. A positive
35854 prefix @var{n} divides the rectangle into columns of width @var{n}.
35855 A zero or @kbd{C-u} prefix parses each line as one formula. A negative
35856 prefix suppresses special treatment of bracketed portions of a line.
35857
35858 @c 37
35859 @item
35860 A numeric prefix causes the current language mode to be ignored.
35861
35862 @c 38
35863 @item
35864 Responding to a prompt with a blank line answers that and all
35865 later prompts by popping additional stack entries.
35866
35867 @c 39
35868 @item
35869 Answer for @expr{v} may also be of the form @expr{v = v_0} or
35870 @expr{v - v_0}.
35871
35872 @c 40
35873 @item
35874 With a positive prefix argument, stack contains many @expr{y}'s and one
35875 common @expr{x}. With a zero prefix, stack contains a vector of
35876 @expr{y}s and a common @expr{x}. With a negative prefix, stack
35877 contains many @expr{[x,y]} vectors. (For 3D plots, substitute
35878 @expr{z} for @expr{y} and @expr{x,y} for @expr{x}.)
35879
35880 @c 41
35881 @item
35882 With any prefix argument, all curves in the graph are deleted.
35883
35884 @c 42
35885 @item
35886 With a positive prefix, refines an existing plot with more data points.
35887 With a negative prefix, forces recomputation of the plot data.
35888
35889 @c 43
35890 @item
35891 With any prefix argument, set the default value instead of the
35892 value for this graph.
35893
35894 @c 44
35895 @item
35896 With a negative prefix argument, set the value for the printer.
35897
35898 @c 45
35899 @item
35900 Condition is considered ``true'' if it is a nonzero real or complex
35901 number, or a formula whose value is known to be nonzero; it is ``false''
35902 otherwise.
35903
35904 @c 46
35905 @item
35906 Several formulas separated by commas are pushed as multiple stack
35907 entries. Trailing @kbd{)}, @kbd{]}, @kbd{@}}, @kbd{>}, and @kbd{"}
35908 delimiters may be omitted. The notation @kbd{$$$} refers to the value
35909 in stack level three, and causes the formula to replace the top three
35910 stack levels. The notation @kbd{$3} refers to stack level three without
35911 causing that value to be removed from the stack. Use @key{LFD} in place
35912 of @key{RET} to prevent evaluation; use @kbd{M-=} in place of @key{RET}
35913 to evaluate variables.
35914
35915 @c 47
35916 @item
35917 The variable is replaced by the formula shown on the right. The
35918 Inverse flag reverses the order of the operands, e.g., @kbd{I s - x}
35919 assigns
35920 @texline @math{x \coloneq a-x}.
35921 @infoline @expr{x := a-x}.
35922
35923 @c 48
35924 @item
35925 Press @kbd{?} repeatedly to see how to choose a model. Answer the
35926 variables prompt with @expr{iv} or @expr{iv;pv} to specify
35927 independent and parameter variables. A positive prefix argument
35928 takes @mathit{@var{n}+1} vectors from the stack; a zero prefix takes a matrix
35929 and a vector from the stack.
35930
35931 @c 49
35932 @item
35933 With a plain @kbd{C-u} prefix, replace the current region of the
35934 destination buffer with the yanked text instead of inserting.
35935
35936 @c 50
35937 @item
35938 All stack entries are reformatted; the @kbd{H} prefix inhibits this.
35939 The @kbd{I} prefix sets the mode temporarily, redraws the top stack
35940 entry, then restores the original setting of the mode.
35941
35942 @c 51
35943 @item
35944 A negative prefix sets the default 3D resolution instead of the
35945 default 2D resolution.
35946
35947 @c 52
35948 @item
35949 This grabs a vector of the form [@var{prec}, @var{wsize}, @var{ssize},
35950 @var{radix}, @var{flfmt}, @var{ang}, @var{frac}, @var{symb}, @var{polar},
35951 @var{matrix}, @var{simp}, @var{inf}]. A prefix argument from 1 to 12
35952 grabs the @var{n}th mode value only.
35953 @end enumerate
35954
35955 @iftex
35956 (Space is provided below for you to keep your own written notes.)
35957 @page
35958 @endgroup
35959 @end iftex
35960
35961
35962 @c [end-summary]
35963
35964 @node Key Index, Command Index, Summary, Top
35965 @unnumbered Index of Key Sequences
35966
35967 @printindex ky
35968
35969 @node Command Index, Function Index, Key Index, Top
35970 @unnumbered Index of Calculator Commands
35971
35972 Since all Calculator commands begin with the prefix @samp{calc-}, the
35973 @kbd{x} key has been provided as a variant of @kbd{M-x} which automatically
35974 types @samp{calc-} for you. Thus, @kbd{x last-args} is short for
35975 @kbd{M-x calc-last-args}.
35976
35977 @printindex pg
35978
35979 @node Function Index, Concept Index, Command Index, Top
35980 @unnumbered Index of Algebraic Functions
35981
35982 This is a list of built-in functions and operators usable in algebraic
35983 expressions. Their full Lisp names are derived by adding the prefix
35984 @samp{calcFunc-}, as in @code{calcFunc-sqrt}.
35985 @iftex
35986 All functions except those noted with ``*'' have corresponding
35987 Calc keystrokes and can also be found in the Calc Summary.
35988 @end iftex
35989
35990 @printindex tp
35991
35992 @node Concept Index, Variable Index, Function Index, Top
35993 @unnumbered Concept Index
35994
35995 @printindex cp
35996
35997 @node Variable Index, Lisp Function Index, Concept Index, Top
35998 @unnumbered Index of Variables
35999
36000 The variables in this list that do not contain dashes are accessible
36001 as Calc variables. Add a @samp{var-} prefix to get the name of the
36002 corresponding Lisp variable.
36003
36004 The remaining variables are Lisp variables suitable for @code{setq}ing
36005 in your Calc init file or @file{.emacs} file.
36006
36007 @printindex vr
36008
36009 @node Lisp Function Index, , Variable Index, Top
36010 @unnumbered Index of Lisp Math Functions
36011
36012 The following functions are meant to be used with @code{defmath}, not
36013 @code{defun} definitions. For names that do not start with @samp{calc-},
36014 the corresponding full Lisp name is derived by adding a prefix of
36015 @samp{math-}.
36016
36017 @printindex fn
36018
36019 @summarycontents
36020
36021 @c [end]
36022
36023 @contents
36024 @bye
36025
36026
36027 @ignore
36028 arch-tag: 77a71809-fa4d-40be-b2cc-da3e8fb137c0
36029 @end ignore