1 \input texinfo @c -*-texinfo-*-
2 @comment %**start of header (This is for running Texinfo on a region.)
4 @setfilename ../info/calc
6 @settitle GNU Emacs Calc 2.1 Manual
8 @comment %**end of header (This is for running Texinfo on a region.)
10 @c The following macros are used for conditional output for single lines.
12 @c `foo' will appear only in TeX output
14 @c `foo' will appear only in non-TeX output
16 @c @expr{expr} will typeset an expression;
17 @c $x$ in TeX, @samp{x} otherwise.
22 @alias infoline=comment
35 @alias texline=comment
36 @macro infoline{stuff}
52 % Suggested by Karl Berry <karl@@freefriends.org>
53 \gdef\!{\mskip-\thinmuskip}
56 @c Fix some other things specifically for this manual.
59 @mathcode`@:=`@: @c Make Calc fractions come out right in math mode
61 \gdef\coloneq{\mathrel{\mathord:\mathord=}}
63 \gdef\beforedisplay{\vskip-10pt}
64 \gdef\afterdisplay{\vskip-5pt}
65 \gdef\beforedisplayh{\vskip-25pt}
66 \gdef\afterdisplayh{\vskip-10pt}
68 @newdimen@kyvpos @kyvpos=0pt
69 @newdimen@kyhpos @kyhpos=0pt
70 @newcount@calcclubpenalty @calcclubpenalty=1000
73 @newtoks@calcoldeverypar @calcoldeverypar=@everypar
74 @everypar={@calceverypar@the@calcoldeverypar}
75 @ifx@turnoffactive@undefinedzzz@def@turnoffactive{}@fi
76 @ifx@ninett@undefinedzzz@font@ninett=cmtt9@fi
77 @catcode`@\=0 \catcode`\@=11
79 \catcode`\@=0 @catcode`@\=@active
84 This file documents Calc, the GNU Emacs calculator.
86 Copyright (C) 1990, 1991, 2001, 2002, 2003, 2004,
87 2005 Free Software Foundation, Inc.
90 Permission is granted to copy, distribute and/or modify this document
91 under the terms of the GNU Free Documentation License, Version 1.2 or
92 any later version published by the Free Software Foundation; with the
93 Invariant Sections being just ``GNU GENERAL PUBLIC LICENSE'', with the
94 Front-Cover texts being ``A GNU Manual,'' and with the Back-Cover
95 Texts as in (a) below.
97 (a) The FSF's Back-Cover Text is: ``You have freedom to copy and modify
98 this GNU Manual, like GNU software. Copies published by the Free
99 Software Foundation raise funds for GNU development.''
105 * Calc: (calc). Advanced desk calculator and mathematical tool.
110 @center @titlefont{Calc Manual}
112 @center GNU Emacs Calc Version 2.1
117 @center Dave Gillespie
118 @center daveg@@synaptics.com
121 @vskip 0pt plus 1filll
122 Copyright @copyright{} 1990, 1991, 2001, 2002, 2003, 2004,
123 2005 Free Software Foundation, Inc.
129 @node Top, , (dir), (dir)
130 @chapter The GNU Emacs Calculator
133 @dfn{Calc} is an advanced desk calculator and mathematical tool
134 that runs as part of the GNU Emacs environment.
136 This manual is divided into three major parts: ``Getting Started,''
137 the ``Calc Tutorial,'' and the ``Calc Reference.'' The Tutorial
138 introduces all the major aspects of Calculator use in an easy,
139 hands-on way. The remainder of the manual is a complete reference to
140 the features of the Calculator.
142 For help in the Emacs Info system (which you are using to read this
143 file), type @kbd{?}. (You can also type @kbd{h} to run through a
144 longer Info tutorial.)
148 * Copying:: How you can copy and share Calc.
150 * Getting Started:: General description and overview.
151 * Interactive Tutorial::
152 * Tutorial:: A step-by-step introduction for beginners.
154 * Introduction:: Introduction to the Calc reference manual.
155 * Data Types:: Types of objects manipulated by Calc.
156 * Stack and Trail:: Manipulating the stack and trail buffers.
157 * Mode Settings:: Adjusting display format and other modes.
158 * Arithmetic:: Basic arithmetic functions.
159 * Scientific Functions:: Transcendentals and other scientific functions.
160 * Matrix Functions:: Operations on vectors and matrices.
161 * Algebra:: Manipulating expressions algebraically.
162 * Units:: Operations on numbers with units.
163 * Store and Recall:: Storing and recalling variables.
164 * Graphics:: Commands for making graphs of data.
165 * Kill and Yank:: Moving data into and out of Calc.
166 * Keypad Mode:: Operating Calc from a keypad.
167 * Embedded Mode:: Working with formulas embedded in a file.
168 * Programming:: Calc as a programmable calculator.
170 * Customizable Variables:: Customizable Variables.
171 * Reporting Bugs:: How to report bugs and make suggestions.
173 * Summary:: Summary of Calc commands and functions.
175 * Key Index:: The standard Calc key sequences.
176 * Command Index:: The interactive Calc commands.
177 * Function Index:: Functions (in algebraic formulas).
178 * Concept Index:: General concepts.
179 * Variable Index:: Variables used by Calc (both user and internal).
180 * Lisp Function Index:: Internal Lisp math functions.
183 @node Copying, Getting Started, Top, Top
184 @unnumbered GNU GENERAL PUBLIC LICENSE
185 @center Version 2, June 1991
187 @c This file is intended to be included in another file.
190 Copyright @copyright{} 1989, 1991 Free Software Foundation, Inc.
191 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
193 Everyone is permitted to copy and distribute verbatim copies
194 of this license document, but changing it is not allowed.
197 @unnumberedsec Preamble
199 The licenses for most software are designed to take away your
200 freedom to share and change it. By contrast, the GNU General Public
201 License is intended to guarantee your freedom to share and change free
202 software---to make sure the software is free for all its users. This
203 General Public License applies to most of the Free Software
204 Foundation's software and to any other program whose authors commit to
205 using it. (Some other Free Software Foundation software is covered by
206 the GNU Library General Public License instead.) You can apply it to
209 When we speak of free software, we are referring to freedom, not
210 price. Our General Public Licenses are designed to make sure that you
211 have the freedom to distribute copies of free software (and charge for
212 this service if you wish), that you receive source code or can get it
213 if you want it, that you can change the software or use pieces of it
214 in new free programs; and that you know you can do these things.
216 To protect your rights, we need to make restrictions that forbid
217 anyone to deny you these rights or to ask you to surrender the rights.
218 These restrictions translate to certain responsibilities for you if you
219 distribute copies of the software, or if you modify it.
221 For example, if you distribute copies of such a program, whether
222 gratis or for a fee, you must give the recipients all the rights that
223 you have. You must make sure that they, too, receive or can get the
224 source code. And you must show them these terms so they know their
227 We protect your rights with two steps: (1) copyright the software, and
228 (2) offer you this license which gives you legal permission to copy,
229 distribute and/or modify the software.
231 Also, for each author's protection and ours, we want to make certain
232 that everyone understands that there is no warranty for this free
233 software. If the software is modified by someone else and passed on, we
234 want its recipients to know that what they have is not the original, so
235 that any problems introduced by others will not reflect on the original
236 authors' reputations.
238 Finally, any free program is threatened constantly by software
239 patents. We wish to avoid the danger that redistributors of a free
240 program will individually obtain patent licenses, in effect making the
241 program proprietary. To prevent this, we have made it clear that any
242 patent must be licensed for everyone's free use or not licensed at all.
244 The precise terms and conditions for copying, distribution and
248 @unnumberedsec TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
251 @center TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
256 This License applies to any program or other work which contains
257 a notice placed by the copyright holder saying it may be distributed
258 under the terms of this General Public License. The ``Program'', below,
259 refers to any such program or work, and a ``work based on the Program''
260 means either the Program or any derivative work under copyright law:
261 that is to say, a work containing the Program or a portion of it,
262 either verbatim or with modifications and/or translated into another
263 language. (Hereinafter, translation is included without limitation in
264 the term ``modification''.) Each licensee is addressed as ``you''.
266 Activities other than copying, distribution and modification are not
267 covered by this License; they are outside its scope. The act of
268 running the Program is not restricted, and the output from the Program
269 is covered only if its contents constitute a work based on the
270 Program (independent of having been made by running the Program).
271 Whether that is true depends on what the Program does.
274 You may copy and distribute verbatim copies of the Program's
275 source code as you receive it, in any medium, provided that you
276 conspicuously and appropriately publish on each copy an appropriate
277 copyright notice and disclaimer of warranty; keep intact all the
278 notices that refer to this License and to the absence of any warranty;
279 and give any other recipients of the Program a copy of this License
280 along with the Program.
282 You may charge a fee for the physical act of transferring a copy, and
283 you may at your option offer warranty protection in exchange for a fee.
286 You may modify your copy or copies of the Program or any portion
287 of it, thus forming a work based on the Program, and copy and
288 distribute such modifications or work under the terms of Section 1
289 above, provided that you also meet all of these conditions:
293 You must cause the modified files to carry prominent notices
294 stating that you changed the files and the date of any change.
297 You must cause any work that you distribute or publish, that in
298 whole or in part contains or is derived from the Program or any
299 part thereof, to be licensed as a whole at no charge to all third
300 parties under the terms of this License.
303 If the modified program normally reads commands interactively
304 when run, you must cause it, when started running for such
305 interactive use in the most ordinary way, to print or display an
306 announcement including an appropriate copyright notice and a
307 notice that there is no warranty (or else, saying that you provide
308 a warranty) and that users may redistribute the program under
309 these conditions, and telling the user how to view a copy of this
310 License. (Exception: if the Program itself is interactive but
311 does not normally print such an announcement, your work based on
312 the Program is not required to print an announcement.)
315 These requirements apply to the modified work as a whole. If
316 identifiable sections of that work are not derived from the Program,
317 and can be reasonably considered independent and separate works in
318 themselves, then this License, and its terms, do not apply to those
319 sections when you distribute them as separate works. But when you
320 distribute the same sections as part of a whole which is a work based
321 on the Program, the distribution of the whole must be on the terms of
322 this License, whose permissions for other licensees extend to the
323 entire whole, and thus to each and every part regardless of who wrote it.
325 Thus, it is not the intent of this section to claim rights or contest
326 your rights to work written entirely by you; rather, the intent is to
327 exercise the right to control the distribution of derivative or
328 collective works based on the Program.
330 In addition, mere aggregation of another work not based on the Program
331 with the Program (or with a work based on the Program) on a volume of
332 a storage or distribution medium does not bring the other work under
333 the scope of this License.
336 You may copy and distribute the Program (or a work based on it,
337 under Section 2) in object code or executable form under the terms of
338 Sections 1 and 2 above provided that you also do one of the following:
342 Accompany it with the complete corresponding machine-readable
343 source code, which must be distributed under the terms of Sections
344 1 and 2 above on a medium customarily used for software interchange; or,
347 Accompany it with a written offer, valid for at least three
348 years, to give any third party, for a charge no more than your
349 cost of physically performing source distribution, a complete
350 machine-readable copy of the corresponding source code, to be
351 distributed under the terms of Sections 1 and 2 above on a medium
352 customarily used for software interchange; or,
355 Accompany it with the information you received as to the offer
356 to distribute corresponding source code. (This alternative is
357 allowed only for noncommercial distribution and only if you
358 received the program in object code or executable form with such
359 an offer, in accord with Subsection b above.)
362 The source code for a work means the preferred form of the work for
363 making modifications to it. For an executable work, complete source
364 code means all the source code for all modules it contains, plus any
365 associated interface definition files, plus the scripts used to
366 control compilation and installation of the executable. However, as a
367 special exception, the source code distributed need not include
368 anything that is normally distributed (in either source or binary
369 form) with the major components (compiler, kernel, and so on) of the
370 operating system on which the executable runs, unless that component
371 itself accompanies the executable.
373 If distribution of executable or object code is made by offering
374 access to copy from a designated place, then offering equivalent
375 access to copy the source code from the same place counts as
376 distribution of the source code, even though third parties are not
377 compelled to copy the source along with the object code.
380 You may not copy, modify, sublicense, or distribute the Program
381 except as expressly provided under this License. Any attempt
382 otherwise to copy, modify, sublicense or distribute the Program is
383 void, and will automatically terminate your rights under this License.
384 However, parties who have received copies, or rights, from you under
385 this License will not have their licenses terminated so long as such
386 parties remain in full compliance.
389 You are not required to accept this License, since you have not
390 signed it. However, nothing else grants you permission to modify or
391 distribute the Program or its derivative works. These actions are
392 prohibited by law if you do not accept this License. Therefore, by
393 modifying or distributing the Program (or any work based on the
394 Program), you indicate your acceptance of this License to do so, and
395 all its terms and conditions for copying, distributing or modifying
396 the Program or works based on it.
399 Each time you redistribute the Program (or any work based on the
400 Program), the recipient automatically receives a license from the
401 original licensor to copy, distribute or modify the Program subject to
402 these terms and conditions. You may not impose any further
403 restrictions on the recipients' exercise of the rights granted herein.
404 You are not responsible for enforcing compliance by third parties to
408 If, as a consequence of a court judgment or allegation of patent
409 infringement or for any other reason (not limited to patent issues),
410 conditions are imposed on you (whether by court order, agreement or
411 otherwise) that contradict the conditions of this License, they do not
412 excuse you from the conditions of this License. If you cannot
413 distribute so as to satisfy simultaneously your obligations under this
414 License and any other pertinent obligations, then as a consequence you
415 may not distribute the Program at all. For example, if a patent
416 license would not permit royalty-free redistribution of the Program by
417 all those who receive copies directly or indirectly through you, then
418 the only way you could satisfy both it and this License would be to
419 refrain entirely from distribution of the Program.
421 If any portion of this section is held invalid or unenforceable under
422 any particular circumstance, the balance of the section is intended to
423 apply and the section as a whole is intended to apply in other
426 It is not the purpose of this section to induce you to infringe any
427 patents or other property right claims or to contest validity of any
428 such claims; this section has the sole purpose of protecting the
429 integrity of the free software distribution system, which is
430 implemented by public license practices. Many people have made
431 generous contributions to the wide range of software distributed
432 through that system in reliance on consistent application of that
433 system; it is up to the author/donor to decide if he or she is willing
434 to distribute software through any other system and a licensee cannot
437 This section is intended to make thoroughly clear what is believed to
438 be a consequence of the rest of this License.
441 If the distribution and/or use of the Program is restricted in
442 certain countries either by patents or by copyrighted interfaces, the
443 original copyright holder who places the Program under this License
444 may add an explicit geographical distribution limitation excluding
445 those countries, so that distribution is permitted only in or among
446 countries not thus excluded. In such case, this License incorporates
447 the limitation as if written in the body of this License.
450 The Free Software Foundation may publish revised and/or new versions
451 of the General Public License from time to time. Such new versions will
452 be similar in spirit to the present version, but may differ in detail to
453 address new problems or concerns.
455 Each version is given a distinguishing version number. If the Program
456 specifies a version number of this License which applies to it and ``any
457 later version'', you have the option of following the terms and conditions
458 either of that version or of any later version published by the Free
459 Software Foundation. If the Program does not specify a version number of
460 this License, you may choose any version ever published by the Free Software
464 If you wish to incorporate parts of the Program into other free
465 programs whose distribution conditions are different, write to the author
466 to ask for permission. For software which is copyrighted by the Free
467 Software Foundation, write to the Free Software Foundation; we sometimes
468 make exceptions for this. Our decision will be guided by the two goals
469 of preserving the free status of all derivatives of our free software and
470 of promoting the sharing and reuse of software generally.
480 BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
481 FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
482 OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
483 PROVIDE THE PROGRAM ``AS IS'' WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
484 OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
485 MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
486 TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
487 PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
488 REPAIR OR CORRECTION.
491 IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
492 WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
493 REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
494 INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
495 OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
496 TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
497 YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
498 PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
499 POSSIBILITY OF SUCH DAMAGES.
503 @heading END OF TERMS AND CONDITIONS
506 @center END OF TERMS AND CONDITIONS
510 @unnumberedsec Appendix: How to Apply These Terms to Your New Programs
512 If you develop a new program, and you want it to be of the greatest
513 possible use to the public, the best way to achieve this is to make it
514 free software which everyone can redistribute and change under these terms.
516 To do so, attach the following notices to the program. It is safest
517 to attach them to the start of each source file to most effectively
518 convey the exclusion of warranty; and each file should have at least
519 the ``copyright'' line and a pointer to where the full notice is found.
522 @var{one line to give the program's name and a brief idea of what it does.}
523 Copyright (C) @var{yyyy} @var{name of author}
525 This program is free software; you can redistribute it and/or modify
526 it under the terms of the GNU General Public License as published by
527 the Free Software Foundation; either version 2 of the License, or
528 (at your option) any later version.
530 This program is distributed in the hope that it will be useful,
531 but WITHOUT ANY WARRANTY; without even the implied warranty of
532 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
533 GNU General Public License for more details.
535 You should have received a copy of the GNU General Public License
536 along with this program; if not, write to the Free Software
537 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
540 Also add information on how to contact you by electronic and paper mail.
542 If the program is interactive, make it output a short notice like this
543 when it starts in an interactive mode:
546 Gnomovision version 69, Copyright (C) 19@var{yy} @var{name of author}
547 Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
548 This is free software, and you are welcome to redistribute it
549 under certain conditions; type `show c' for details.
552 The hypothetical commands @samp{show w} and @samp{show c} should show
553 the appropriate parts of the General Public License. Of course, the
554 commands you use may be called something other than @samp{show w} and
555 @samp{show c}; they could even be mouse-clicks or menu items---whatever
558 You should also get your employer (if you work as a programmer) or your
559 school, if any, to sign a ``copyright disclaimer'' for the program, if
560 necessary. Here is a sample; alter the names:
563 Yoyodyne, Inc., hereby disclaims all copyright interest in the program
564 `Gnomovision' (which makes passes at compilers) written by James Hacker.
566 @var{signature of Ty Coon}, 1 April 1989
567 Ty Coon, President of Vice
570 This General Public License does not permit incorporating your program into
571 proprietary programs. If your program is a subroutine library, you may
572 consider it more useful to permit linking proprietary applications with the
573 library. If this is what you want to do, use the GNU Library General
574 Public License instead of this License.
576 @node Getting Started, Tutorial, Copying, Top
577 @chapter Getting Started
579 This chapter provides a general overview of Calc, the GNU Emacs
580 Calculator: What it is, how to start it and how to exit from it,
581 and what are the various ways that it can be used.
585 * About This Manual::
586 * Notations Used in This Manual::
587 * Demonstration of Calc::
589 * History and Acknowledgements::
592 @node What is Calc, About This Manual, Getting Started, Getting Started
593 @section What is Calc?
596 @dfn{Calc} is an advanced calculator and mathematical tool that runs as
597 part of the GNU Emacs environment. Very roughly based on the HP-28/48
598 series of calculators, its many features include:
602 Choice of algebraic or RPN (stack-based) entry of calculations.
605 Arbitrary precision integers and floating-point numbers.
608 Arithmetic on rational numbers, complex numbers (rectangular and polar),
609 error forms with standard deviations, open and closed intervals, vectors
610 and matrices, dates and times, infinities, sets, quantities with units,
611 and algebraic formulas.
614 Mathematical operations such as logarithms and trigonometric functions.
617 Programmer's features (bitwise operations, non-decimal numbers).
620 Financial functions such as future value and internal rate of return.
623 Number theoretical features such as prime factorization and arithmetic
624 modulo @var{m} for any @var{m}.
627 Algebraic manipulation features, including symbolic calculus.
630 Moving data to and from regular editing buffers.
633 Embedded mode for manipulating Calc formulas and data directly
634 inside any editing buffer.
637 Graphics using GNUPLOT, a versatile (and free) plotting program.
640 Easy programming using keyboard macros, algebraic formulas,
641 algebraic rewrite rules, or extended Emacs Lisp.
644 Calc tries to include a little something for everyone; as a result it is
645 large and might be intimidating to the first-time user. If you plan to
646 use Calc only as a traditional desk calculator, all you really need to
647 read is the ``Getting Started'' chapter of this manual and possibly the
648 first few sections of the tutorial. As you become more comfortable with
649 the program you can learn its additional features. Calc does not
650 have the scope and depth of a fully-functional symbolic math package,
651 but Calc has the advantages of convenience, portability, and freedom.
653 @node About This Manual, Notations Used in This Manual, What is Calc, Getting Started
654 @section About This Manual
657 This document serves as a complete description of the GNU Emacs
658 Calculator. It works both as an introduction for novices, and as
659 a reference for experienced users. While it helps to have some
660 experience with GNU Emacs in order to get the most out of Calc,
661 this manual ought to be readable even if you don't know or use Emacs
665 The manual is divided into three major parts:@: the ``Getting
666 Started'' chapter you are reading now, the Calc tutorial (chapter 2),
667 and the Calc reference manual (the remaining chapters and appendices).
670 The manual is divided into three major parts:@: the ``Getting
671 Started'' chapter you are reading now, the Calc tutorial (chapter 2),
672 and the Calc reference manual (the remaining chapters and appendices).
674 @c This manual has been printed in two volumes, the @dfn{Tutorial} and the
675 @c @dfn{Reference}. Both volumes include a copy of the ``Getting Started''
679 If you are in a hurry to use Calc, there is a brief ``demonstration''
680 below which illustrates the major features of Calc in just a couple of
681 pages. If you don't have time to go through the full tutorial, this
682 will show you everything you need to know to begin.
683 @xref{Demonstration of Calc}.
685 The tutorial chapter walks you through the various parts of Calc
686 with lots of hands-on examples and explanations. If you are new
687 to Calc and you have some time, try going through at least the
688 beginning of the tutorial. The tutorial includes about 70 exercises
689 with answers. These exercises give you some guided practice with
690 Calc, as well as pointing out some interesting and unusual ways
693 The reference section discusses Calc in complete depth. You can read
694 the reference from start to finish if you want to learn every aspect
695 of Calc. Or, you can look in the table of contents or the Concept
696 Index to find the parts of the manual that discuss the things you
699 @cindex Marginal notes
700 Every Calc keyboard command is listed in the Calc Summary, and also
701 in the Key Index. Algebraic functions, @kbd{M-x} commands, and
702 variables also have their own indices.
704 @infoline In the printed manual, each
705 paragraph that is referenced in the Key or Function Index is marked
706 in the margin with its index entry.
708 @c [fix-ref Help Commands]
709 You can access this manual on-line at any time within Calc by
710 pressing the @kbd{h i} key sequence. Outside of the Calc window,
711 you can press @kbd{M-# i} to read the manual on-line. Also, you
712 can jump directly to the Tutorial by pressing @kbd{h t} or @kbd{M-# t},
713 or to the Summary by pressing @kbd{h s} or @kbd{M-# s}. Within Calc,
714 you can also go to the part of the manual describing any Calc key,
715 function, or variable using @w{@kbd{h k}}, @kbd{h f}, or @kbd{h v},
716 respectively. @xref{Help Commands}.
718 The Calc manual can be printed, but because the manual is so large, you
719 should only make a printed copy if you really need it. To print the
720 manual, you will need the @TeX{} typesetting program (this is a free
721 program by Donald Knuth at Stanford University) as well as the
722 @file{texindex} program and @file{texinfo.tex} file, both of which can
723 be obtained from the FSF as part of the @code{texinfo} package.
724 To print the Calc manual in one huge tome, you will need the
725 source code to this manual, @file{calc.texi}, available as part of the
726 Emacs source. Once you have this file, type @kbd{texi2dvi calc.texi}.
727 Alternatively, change to the @file{man} subdirectory of the Emacs
728 source distribution, and type @kbd{make calc.dvi}. (Don't worry if you
729 get some ``overfull box'' warnings while @TeX{} runs.)
730 The result will be a device-independent output file called
731 @file{calc.dvi}, which you must print in whatever way is right
732 for your system. On many systems, the command is
745 @c Printed copies of this manual are also available from the Free Software
748 @node Notations Used in This Manual, Demonstration of Calc, About This Manual, Getting Started
749 @section Notations Used in This Manual
752 This section describes the various notations that are used
753 throughout the Calc manual.
755 In keystroke sequences, uppercase letters mean you must hold down
756 the shift key while typing the letter. Keys pressed with Control
757 held down are shown as @kbd{C-x}. Keys pressed with Meta held down
758 are shown as @kbd{M-x}. Other notations are @key{RET} for the
759 Return key, @key{SPC} for the space bar, @key{TAB} for the Tab key,
760 @key{DEL} for the Delete key, and @key{LFD} for the Line-Feed key.
761 The @key{DEL} key is called Backspace on some keyboards, it is
762 whatever key you would use to correct a simple typing error when
763 regularly using Emacs.
765 (If you don't have the @key{LFD} or @key{TAB} keys on your keyboard,
766 the @kbd{C-j} and @kbd{C-i} keys are equivalent to them, respectively.
767 If you don't have a Meta key, look for Alt or Extend Char. You can
768 also press @key{ESC} or @kbd{C-[} first to get the same effect, so
769 that @kbd{M-x}, @kbd{@key{ESC} x}, and @kbd{C-[ x} are all equivalent.)
771 Sometimes the @key{RET} key is not shown when it is ``obvious''
772 that you must press @key{RET} to proceed. For example, the @key{RET}
773 is usually omitted in key sequences like @kbd{M-x calc-keypad @key{RET}}.
775 Commands are generally shown like this: @kbd{p} (@code{calc-precision})
776 or @kbd{M-# k} (@code{calc-keypad}). This means that the command is
777 normally used by pressing the @kbd{p} key or @kbd{M-# k} key sequence,
778 but it also has the full-name equivalent shown, e.g., @kbd{M-x calc-precision}.
780 Commands that correspond to functions in algebraic notation
781 are written: @kbd{C} (@code{calc-cos}) [@code{cos}]. This means
782 the @kbd{C} key is equivalent to @kbd{M-x calc-cos}, and that
783 the corresponding function in an algebraic-style formula would
784 be @samp{cos(@var{x})}.
786 A few commands don't have key equivalents: @code{calc-sincos}
789 @node Demonstration of Calc, Using Calc, Notations Used in This Manual, Getting Started
790 @section A Demonstration of Calc
793 @cindex Demonstration of Calc
794 This section will show some typical small problems being solved with
795 Calc. The focus is more on demonstration than explanation, but
796 everything you see here will be covered more thoroughly in the
799 To begin, start Emacs if necessary (usually the command @code{emacs}
800 does this), and type @kbd{M-# c} (or @kbd{@key{ESC} # c}) to start the
801 Calculator. (You can also use @kbd{M-x calc} if this doesn't work.
802 @xref{Starting Calc}, for various ways of starting the Calculator.)
804 Be sure to type all the sample input exactly, especially noting the
805 difference between lower-case and upper-case letters. Remember,
806 @key{RET}, @key{TAB}, @key{DEL}, and @key{SPC} are the Return, Tab,
807 Delete, and Space keys.
809 @strong{RPN calculation.} In RPN, you type the input number(s) first,
810 then the command to operate on the numbers.
813 Type @kbd{2 @key{RET} 3 + Q} to compute
814 @texline @math{\sqrt{2+3} = 2.2360679775}.
815 @infoline the square root of 2+3, which is 2.2360679775.
818 Type @kbd{P 2 ^} to compute
819 @texline @math{\pi^2 = 9.86960440109}.
820 @infoline the value of `pi' squared, 9.86960440109.
823 Type @key{TAB} to exchange the order of these two results.
826 Type @kbd{- I H S} to subtract these results and compute the Inverse
827 Hyperbolic sine of the difference, 2.72996136574.
830 Type @key{DEL} to erase this result.
832 @strong{Algebraic calculation.} You can also enter calculations using
833 conventional ``algebraic'' notation. To enter an algebraic formula,
834 use the apostrophe key.
837 Type @kbd{' sqrt(2+3) @key{RET}} to compute
838 @texline @math{\sqrt{2+3}}.
839 @infoline the square root of 2+3.
842 Type @kbd{' pi^2 @key{RET}} to enter
843 @texline @math{\pi^2}.
844 @infoline `pi' squared.
845 To evaluate this symbolic formula as a number, type @kbd{=}.
848 Type @kbd{' arcsinh($ - $$) @key{RET}} to subtract the second-most-recent
849 result from the most-recent and compute the Inverse Hyperbolic sine.
851 @strong{Keypad mode.} If you are using the X window system, press
852 @w{@kbd{M-# k}} to get Keypad mode. (If you don't use X, skip to
856 Click on the @key{2}, @key{ENTER}, @key{3}, @key{+}, and @key{SQRT}
857 ``buttons'' using your left mouse button.
860 Click on @key{PI}, @key{2}, and @tfn{y^x}.
863 Click on @key{INV}, then @key{ENTER} to swap the two results.
866 Click on @key{-}, @key{INV}, @key{HYP}, and @key{SIN}.
869 Click on @key{<-} to erase the result, then click @key{OFF} to turn
870 the Keypad Calculator off.
872 @strong{Grabbing data.} Type @kbd{M-# x} if necessary to exit Calc.
873 Now select the following numbers as an Emacs region: ``Mark'' the
874 front of the list by typing @kbd{C-@key{SPC}} or @kbd{C-@@} there,
875 then move to the other end of the list. (Either get this list from
876 the on-line copy of this manual, accessed by @w{@kbd{M-# i}}, or just
877 type these numbers into a scratch file.) Now type @kbd{M-# g} to
878 ``grab'' these numbers into Calc.
889 The result @samp{[1.23, 1.97, 1.6, 2, 1.19, 1.08]} is a Calc ``vector.''
890 Type @w{@kbd{V R +}} to compute the sum of these numbers.
893 Type @kbd{U} to Undo this command, then type @kbd{V R *} to compute
894 the product of the numbers.
897 You can also grab data as a rectangular matrix. Place the cursor on
898 the upper-leftmost @samp{1} and set the mark, then move to just after
899 the lower-right @samp{8} and press @kbd{M-# r}.
902 Type @kbd{v t} to transpose this
903 @texline @math{3\times2}
906 @texline @math{2\times3}
908 matrix. Type @w{@kbd{v u}} to unpack the rows into two separate
909 vectors. Now type @w{@kbd{V R + @key{TAB} V R +}} to compute the sums
910 of the two original columns. (There is also a special
911 grab-and-sum-columns command, @kbd{M-# :}.)
913 @strong{Units conversion.} Units are entered algebraically.
914 Type @w{@kbd{' 43 mi/hr @key{RET}}} to enter the quantity 43 miles-per-hour.
915 Type @w{@kbd{u c km/hr @key{RET}}}. Type @w{@kbd{u c m/s @key{RET}}}.
917 @strong{Date arithmetic.} Type @kbd{t N} to get the current date and
918 time. Type @kbd{90 +} to find the date 90 days from now. Type
919 @kbd{' <25 dec 87> @key{RET}} to enter a date, then @kbd{- 7 /} to see how
920 many weeks have passed since then.
922 @strong{Algebra.} Algebraic entries can also include formulas
923 or equations involving variables. Type @kbd{@w{' [x + y} = a, x y = 1] @key{RET}}
924 to enter a pair of equations involving three variables.
925 (Note the leading apostrophe in this example; also, note that the space
926 between @samp{x y} is required.) Type @w{@kbd{a S x,y @key{RET}}} to solve
927 these equations for the variables @expr{x} and @expr{y}.
930 Type @kbd{d B} to view the solutions in more readable notation.
931 Type @w{@kbd{d C}} to view them in C language notation, @kbd{d T}
932 to view them in the notation for the @TeX{} typesetting system,
933 and @kbd{d L} to view them in the notation for the La@TeX{} typesetting
934 system. Type @kbd{d N} to return to normal notation.
937 Type @kbd{7.5}, then @kbd{s l a @key{RET}} to let @expr{a = 7.5} in these formulas.
938 (That's a letter @kbd{l}, not a numeral @kbd{1}.)
941 @strong{Help functions.} You can read about any command in the on-line
942 manual. Type @kbd{M-# c} to return to Calc after each of these
943 commands: @kbd{h k t N} to read about the @kbd{t N} command,
944 @kbd{h f sqrt @key{RET}} to read about the @code{sqrt} function, and
945 @kbd{h s} to read the Calc summary.
948 @strong{Help functions.} You can read about any command in the on-line
949 manual. Remember to type the letter @kbd{l}, then @kbd{M-# c}, to
950 return here after each of these commands: @w{@kbd{h k t N}} to read
951 about the @w{@kbd{t N}} command, @kbd{h f sqrt @key{RET}} to read about the
952 @code{sqrt} function, and @kbd{h s} to read the Calc summary.
955 Press @key{DEL} repeatedly to remove any leftover results from the stack.
956 To exit from Calc, press @kbd{q} or @kbd{M-# c} again.
958 @node Using Calc, History and Acknowledgements, Demonstration of Calc, Getting Started
962 Calc has several user interfaces that are specialized for
963 different kinds of tasks. As well as Calc's standard interface,
964 there are Quick mode, Keypad mode, and Embedded mode.
968 * The Standard Interface::
969 * Quick Mode Overview::
970 * Keypad Mode Overview::
971 * Standalone Operation::
972 * Embedded Mode Overview::
973 * Other M-# Commands::
976 @node Starting Calc, The Standard Interface, Using Calc, Using Calc
977 @subsection Starting Calc
980 On most systems, you can type @kbd{M-#} to start the Calculator.
981 The notation @kbd{M-#} is short for Meta-@kbd{#}. On most
982 keyboards this means holding down the Meta (or Alt) and
983 Shift keys while typing @kbd{3}.
986 Once again, if you don't have a Meta key on your keyboard you can type
987 @key{ESC} first, then @kbd{#}, to accomplish the same thing. If you
988 don't even have an @key{ESC} key, you can fake it by holding down
989 Control or @key{CTRL} while typing a left square bracket
990 (that's @kbd{C-[} in Emacs notation).
992 The key @kbd{M-#} is bound to the command @code{calc-dispatch},
993 which can be rebound if convenient.
994 (@xref{Key Bindings,,Customizing Key Bindings,emacs,
995 The GNU Emacs Manual}.)
997 When you press @kbd{M-#}, Emacs waits for you to press a second key to
998 complete the command. In this case, you will follow @kbd{M-#} with a
999 letter (upper- or lower-case, it doesn't matter for @kbd{M-#}) that says
1000 which Calc interface you want to use.
1002 To get Calc's standard interface, type @kbd{M-# c}. To get
1003 Keypad mode, type @kbd{M-# k}. Type @kbd{M-# ?} to get a brief
1004 list of the available options, and type a second @kbd{?} to get
1007 To ease typing, @kbd{M-# M-#} (or @kbd{M-# #} if that's easier)
1008 also works to start Calc. It starts the same interface (either
1009 @kbd{M-# c} or @w{@kbd{M-# k}}) that you last used, selecting the
1010 @kbd{M-# c} interface by default. (If your installation has
1011 a special function key set up to act like @kbd{M-#}, hitting that
1012 function key twice is just like hitting @kbd{M-# M-#}.)
1014 If @kbd{M-#} doesn't work for you, you can always type explicit
1015 commands like @kbd{M-x calc} (for the standard user interface) or
1016 @w{@kbd{M-x calc-keypad}} (for Keypad mode). First type @kbd{M-x}
1017 (that's Meta with the letter @kbd{x}), then, at the prompt,
1018 type the full command (like @kbd{calc-keypad}) and press Return.
1020 The same commands (like @kbd{M-# c} or @kbd{M-# M-#}) that start
1021 the Calculator also turn it off if it is already on.
1023 @node The Standard Interface, Quick Mode Overview, Starting Calc, Using Calc
1024 @subsection The Standard Calc Interface
1027 @cindex Standard user interface
1028 Calc's standard interface acts like a traditional RPN calculator,
1029 operated by the normal Emacs keyboard. When you type @kbd{M-# c}
1030 to start the Calculator, the Emacs screen splits into two windows
1031 with the file you were editing on top and Calc on the bottom.
1037 --**-Emacs: myfile (Fundamental)----All----------------------
1038 --- Emacs Calculator Mode --- |Emacs Calc Mode v2.1 ...
1046 --%%-Calc: 12 Deg (Calculator)----All----- --%%-Emacs: *Calc Trail*
1050 In this figure, the mode-line for @file{myfile} has moved up and the
1051 ``Calculator'' window has appeared below it. As you can see, Calc
1052 actually makes two windows side-by-side. The lefthand one is
1053 called the @dfn{stack window} and the righthand one is called the
1054 @dfn{trail window.} The stack holds the numbers involved in the
1055 calculation you are currently performing. The trail holds a complete
1056 record of all calculations you have done. In a desk calculator with
1057 a printer, the trail corresponds to the paper tape that records what
1060 In this case, the trail shows that four numbers (17.3, 3, 2, and 4)
1061 were first entered into the Calculator, then the 2 and 4 were
1062 multiplied to get 8, then the 3 and 8 were subtracted to get @mathit{-5}.
1063 (The @samp{>} symbol shows that this was the most recent calculation.)
1064 The net result is the two numbers 17.3 and @mathit{-5} sitting on the stack.
1066 Most Calculator commands deal explicitly with the stack only, but
1067 there is a set of commands that allow you to search back through
1068 the trail and retrieve any previous result.
1070 Calc commands use the digits, letters, and punctuation keys.
1071 Shifted (i.e., upper-case) letters are different from lowercase
1072 letters. Some letters are @dfn{prefix} keys that begin two-letter
1073 commands. For example, @kbd{e} means ``enter exponent'' and shifted
1074 @kbd{E} means @expr{e^x}. With the @kbd{d} (``display modes'') prefix
1075 the letter ``e'' takes on very different meanings: @kbd{d e} means
1076 ``engineering notation'' and @kbd{d E} means ``@dfn{eqn} language mode.''
1078 There is nothing stopping you from switching out of the Calc
1079 window and back into your editing window, say by using the Emacs
1080 @w{@kbd{C-x o}} (@code{other-window}) command. When the cursor is
1081 inside a regular window, Emacs acts just like normal. When the
1082 cursor is in the Calc stack or trail windows, keys are interpreted
1085 When you quit by pressing @kbd{M-# c} a second time, the Calculator
1086 windows go away but the actual Stack and Trail are not gone, just
1087 hidden. When you press @kbd{M-# c} once again you will get the
1088 same stack and trail contents you had when you last used the
1091 The Calculator does not remember its state between Emacs sessions.
1092 Thus if you quit Emacs and start it again, @kbd{M-# c} will give you
1093 a fresh stack and trail. There is a command (@kbd{m m}) that lets
1094 you save your favorite mode settings between sessions, though.
1095 One of the things it saves is which user interface (standard or
1096 Keypad) you last used; otherwise, a freshly started Emacs will
1097 always treat @kbd{M-# M-#} the same as @kbd{M-# c}.
1099 The @kbd{q} key is another equivalent way to turn the Calculator off.
1101 If you type @kbd{M-# b} first and then @kbd{M-# c}, you get a
1102 full-screen version of Calc (@code{full-calc}) in which the stack and
1103 trail windows are still side-by-side but are now as tall as the whole
1104 Emacs screen. When you press @kbd{q} or @kbd{M-# c} again to quit,
1105 the file you were editing before reappears. The @kbd{M-# b} key
1106 switches back and forth between ``big'' full-screen mode and the
1107 normal partial-screen mode.
1109 Finally, @kbd{M-# o} (@code{calc-other-window}) is like @kbd{M-# c}
1110 except that the Calc window is not selected. The buffer you were
1111 editing before remains selected instead. @kbd{M-# o} is a handy
1112 way to switch out of Calc momentarily to edit your file; type
1113 @kbd{M-# c} to switch back into Calc when you are done.
1115 @node Quick Mode Overview, Keypad Mode Overview, The Standard Interface, Using Calc
1116 @subsection Quick Mode (Overview)
1119 @dfn{Quick mode} is a quick way to use Calc when you don't need the
1120 full complexity of the stack and trail. To use it, type @kbd{M-# q}
1121 (@code{quick-calc}) in any regular editing buffer.
1123 Quick mode is very simple: It prompts you to type any formula in
1124 standard algebraic notation (like @samp{4 - 2/3}) and then displays
1125 the result at the bottom of the Emacs screen (@mathit{3.33333333333}
1126 in this case). You are then back in the same editing buffer you
1127 were in before, ready to continue editing or to type @kbd{M-# q}
1128 again to do another quick calculation. The result of the calculation
1129 will also be in the Emacs ``kill ring'' so that a @kbd{C-y} command
1130 at this point will yank the result into your editing buffer.
1132 Calc mode settings affect Quick mode, too, though you will have to
1133 go into regular Calc (with @kbd{M-# c}) to change the mode settings.
1135 @c [fix-ref Quick Calculator mode]
1136 @xref{Quick Calculator}, for further information.
1138 @node Keypad Mode Overview, Standalone Operation, Quick Mode Overview, Using Calc
1139 @subsection Keypad Mode (Overview)
1142 @dfn{Keypad mode} is a mouse-based interface to the Calculator.
1143 It is designed for use with terminals that support a mouse. If you
1144 don't have a mouse, you will have to operate Keypad mode with your
1145 arrow keys (which is probably more trouble than it's worth).
1147 Type @kbd{M-# k} to turn Keypad mode on or off. Once again you
1148 get two new windows, this time on the righthand side of the screen
1149 instead of at the bottom. The upper window is the familiar Calc
1150 Stack; the lower window is a picture of a typical calculator keypad.
1154 \advance \dimen0 by 24\baselineskip%
1155 \ifdim \dimen0>\pagegoal \vfill\eject \fi%
1160 |--- Emacs Calculator Mode ---
1164 |--%%-Calc: 12 Deg (Calcul
1165 |----+-----Calc 2.1------+----1
1166 |FLR |CEIL|RND |TRNC|CLN2|FLT |
1167 |----+----+----+----+----+----|
1168 | LN |EXP | |ABS |IDIV|MOD |
1169 |----+----+----+----+----+----|
1170 |SIN |COS |TAN |SQRT|y^x |1/x |
1171 |----+----+----+----+----+----|
1172 | ENTER |+/- |EEX |UNDO| <- |
1173 |-----+---+-+--+--+-+---++----|
1174 | INV | 7 | 8 | 9 | / |
1175 |-----+-----+-----+-----+-----|
1176 | HYP | 4 | 5 | 6 | * |
1177 |-----+-----+-----+-----+-----|
1178 |EXEC | 1 | 2 | 3 | - |
1179 |-----+-----+-----+-----+-----|
1180 | OFF | 0 | . | PI | + |
1181 |-----+-----+-----+-----+-----+
1185 Keypad mode is much easier for beginners to learn, because there
1186 is no need to memorize lots of obscure key sequences. But not all
1187 commands in regular Calc are available on the Keypad. You can
1188 always switch the cursor into the Calc stack window to use
1189 standard Calc commands if you need. Serious Calc users, though,
1190 often find they prefer the standard interface over Keypad mode.
1192 To operate the Calculator, just click on the ``buttons'' of the
1193 keypad using your left mouse button. To enter the two numbers
1194 shown here you would click @w{@kbd{1 7 .@: 3 ENTER 5 +/- ENTER}}; to
1195 add them together you would then click @kbd{+} (to get 12.3 on
1198 If you click the right mouse button, the top three rows of the
1199 keypad change to show other sets of commands, such as advanced
1200 math functions, vector operations, and operations on binary
1203 Because Keypad mode doesn't use the regular keyboard, Calc leaves
1204 the cursor in your original editing buffer. You can type in
1205 this buffer in the usual way while also clicking on the Calculator
1206 keypad. One advantage of Keypad mode is that you don't need an
1207 explicit command to switch between editing and calculating.
1209 If you press @kbd{M-# b} first, you get a full-screen Keypad mode
1210 (@code{full-calc-keypad}) with three windows: The keypad in the lower
1211 left, the stack in the lower right, and the trail on top.
1213 @c [fix-ref Keypad Mode]
1214 @xref{Keypad Mode}, for further information.
1216 @node Standalone Operation, Embedded Mode Overview, Keypad Mode Overview, Using Calc
1217 @subsection Standalone Operation
1220 @cindex Standalone Operation
1221 If you are not in Emacs at the moment but you wish to use Calc,
1222 you must start Emacs first. If all you want is to run Calc, you
1223 can give the commands:
1233 emacs -f full-calc-keypad
1237 which run a full-screen Calculator (as if by @kbd{M-# b M-# c}) or
1238 a full-screen X-based Calculator (as if by @kbd{M-# b M-# k}).
1239 In standalone operation, quitting the Calculator (by pressing
1240 @kbd{q} or clicking on the keypad @key{EXIT} button) quits Emacs
1243 @node Embedded Mode Overview, Other M-# Commands, Standalone Operation, Using Calc
1244 @subsection Embedded Mode (Overview)
1247 @dfn{Embedded mode} is a way to use Calc directly from inside an
1248 editing buffer. Suppose you have a formula written as part of a
1262 and you wish to have Calc compute and format the derivative for
1263 you and store this derivative in the buffer automatically. To
1264 do this with Embedded mode, first copy the formula down to where
1265 you want the result to be:
1279 Now, move the cursor onto this new formula and press @kbd{M-# e}.
1280 Calc will read the formula (using the surrounding blank lines to
1281 tell how much text to read), then push this formula (invisibly)
1282 onto the Calc stack. The cursor will stay on the formula in the
1283 editing buffer, but the buffer's mode line will change to look
1284 like the Calc mode line (with mode indicators like @samp{12 Deg}
1285 and so on). Even though you are still in your editing buffer,
1286 the keyboard now acts like the Calc keyboard, and any new result
1287 you get is copied from the stack back into the buffer. To take
1288 the derivative, you would type @kbd{a d x @key{RET}}.
1302 To make this look nicer, you might want to press @kbd{d =} to center
1303 the formula, and even @kbd{d B} to use Big display mode.
1312 % [calc-mode: justify: center]
1313 % [calc-mode: language: big]
1321 Calc has added annotations to the file to help it remember the modes
1322 that were used for this formula. They are formatted like comments
1323 in the @TeX{} typesetting language, just in case you are using @TeX{} or
1324 La@TeX{}. (In this example @TeX{} is not being used, so you might want
1325 to move these comments up to the top of the file or otherwise put them
1328 As an extra flourish, we can add an equation number using a
1329 righthand label: Type @kbd{d @} (1) @key{RET}}.
1333 % [calc-mode: justify: center]
1334 % [calc-mode: language: big]
1335 % [calc-mode: right-label: " (1)"]
1343 To leave Embedded mode, type @kbd{M-# e} again. The mode line
1344 and keyboard will revert to the way they were before.
1346 The related command @kbd{M-# w} operates on a single word, which
1347 generally means a single number, inside text. It uses any
1348 non-numeric characters rather than blank lines to delimit the
1349 formula it reads. Here's an example of its use:
1352 A slope of one-third corresponds to an angle of 1 degrees.
1355 Place the cursor on the @samp{1}, then type @kbd{M-# w} to enable
1356 Embedded mode on that number. Now type @kbd{3 /} (to get one-third),
1357 and @kbd{I T} (the Inverse Tangent converts a slope into an angle),
1358 then @w{@kbd{M-# w}} again to exit Embedded mode.
1361 A slope of one-third corresponds to an angle of 18.4349488229 degrees.
1364 @c [fix-ref Embedded Mode]
1365 @xref{Embedded Mode}, for full details.
1367 @node Other M-# Commands, , Embedded Mode Overview, Using Calc
1368 @subsection Other @kbd{M-#} Commands
1371 Two more Calc-related commands are @kbd{M-# g} and @kbd{M-# r},
1372 which ``grab'' data from a selected region of a buffer into the
1373 Calculator. The region is defined in the usual Emacs way, by
1374 a ``mark'' placed at one end of the region, and the Emacs
1375 cursor or ``point'' placed at the other.
1377 The @kbd{M-# g} command reads the region in the usual left-to-right,
1378 top-to-bottom order. The result is packaged into a Calc vector
1379 of numbers and placed on the stack. Calc (in its standard
1380 user interface) is then started. Type @kbd{v u} if you want
1381 to unpack this vector into separate numbers on the stack. Also,
1382 @kbd{C-u M-# g} interprets the region as a single number or
1385 The @kbd{M-# r} command reads a rectangle, with the point and
1386 mark defining opposite corners of the rectangle. The result
1387 is a matrix of numbers on the Calculator stack.
1389 Complementary to these is @kbd{M-# y}, which ``yanks'' the
1390 value at the top of the Calc stack back into an editing buffer.
1391 If you type @w{@kbd{M-# y}} while in such a buffer, the value is
1392 yanked at the current position. If you type @kbd{M-# y} while
1393 in the Calc buffer, Calc makes an educated guess as to which
1394 editing buffer you want to use. The Calc window does not have
1395 to be visible in order to use this command, as long as there
1396 is something on the Calc stack.
1398 Here, for reference, is the complete list of @kbd{M-#} commands.
1399 The shift, control, and meta keys are ignored for the keystroke
1400 following @kbd{M-#}.
1403 Commands for turning Calc on and off:
1407 Turn Calc on or off, employing the same user interface as last time.
1410 Turn Calc on or off using its standard bottom-of-the-screen
1411 interface. If Calc is already turned on but the cursor is not
1412 in the Calc window, move the cursor into the window.
1415 Same as @kbd{C}, but don't select the new Calc window. If
1416 Calc is already turned on and the cursor is in the Calc window,
1417 move it out of that window.
1420 Control whether @kbd{M-# c} and @kbd{M-# k} use the full screen.
1423 Use Quick mode for a single short calculation.
1426 Turn Calc Keypad mode on or off.
1429 Turn Calc Embedded mode on or off at the current formula.
1432 Turn Calc Embedded mode on or off, select the interesting part.
1435 Turn Calc Embedded mode on or off at the current word (number).
1438 Turn Calc on in a user-defined way, as defined by a @kbd{Z I} command.
1441 Quit Calc; turn off standard, Keypad, or Embedded mode if on.
1442 (This is like @kbd{q} or @key{OFF} inside of Calc.)
1449 Commands for moving data into and out of the Calculator:
1453 Grab the region into the Calculator as a vector.
1456 Grab the rectangular region into the Calculator as a matrix.
1459 Grab the rectangular region and compute the sums of its columns.
1462 Grab the rectangular region and compute the sums of its rows.
1465 Yank a value from the Calculator into the current editing buffer.
1472 Commands for use with Embedded mode:
1476 ``Activate'' the current buffer. Locate all formulas that
1477 contain @samp{:=} or @samp{=>} symbols and record their locations
1478 so that they can be updated automatically as variables are changed.
1481 Duplicate the current formula immediately below and select
1485 Insert a new formula at the current point.
1488 Move the cursor to the next active formula in the buffer.
1491 Move the cursor to the previous active formula in the buffer.
1494 Update (i.e., as if by the @kbd{=} key) the formula at the current point.
1497 Edit (as if by @code{calc-edit}) the formula at the current point.
1504 Miscellaneous commands:
1508 Run the Emacs Info system to read the Calc manual.
1509 (This is the same as @kbd{h i} inside of Calc.)
1512 Run the Emacs Info system to read the Calc Tutorial.
1515 Run the Emacs Info system to read the Calc Summary.
1518 Load Calc entirely into memory. (Normally the various parts
1519 are loaded only as they are needed.)
1522 Read a region of written keystroke names (like @kbd{C-n a b c @key{RET}})
1523 and record them as the current keyboard macro.
1526 (This is the ``zero'' digit key.) Reset the Calculator to
1527 its initial state: Empty stack, and initial mode settings.
1530 @node History and Acknowledgements, , Using Calc, Getting Started
1531 @section History and Acknowledgements
1534 Calc was originally started as a two-week project to occupy a lull
1535 in the author's schedule. Basically, a friend asked if I remembered
1537 @texline @math{2^{32}}.
1538 @infoline @expr{2^32}.
1539 I didn't offhand, but I said, ``that's easy, just call up an
1540 @code{xcalc}.'' @code{Xcalc} duly reported that the answer to our
1541 question was @samp{4.294967e+09}---with no way to see the full ten
1542 digits even though we knew they were there in the program's memory! I
1543 was so annoyed, I vowed to write a calculator of my own, once and for
1546 I chose Emacs Lisp, a) because I had always been curious about it
1547 and b) because, being only a text editor extension language after
1548 all, Emacs Lisp would surely reach its limits long before the project
1549 got too far out of hand.
1551 To make a long story short, Emacs Lisp turned out to be a distressingly
1552 solid implementation of Lisp, and the humble task of calculating
1553 turned out to be more open-ended than one might have expected.
1555 Emacs Lisp doesn't have built-in floating point math, so it had to be
1556 simulated in software. In fact, Emacs integers will only comfortably
1557 fit six decimal digits or so---not enough for a decent calculator. So
1558 I had to write my own high-precision integer code as well, and once I had
1559 this I figured that arbitrary-size integers were just as easy as large
1560 integers. Arbitrary floating-point precision was the logical next step.
1561 Also, since the large integer arithmetic was there anyway it seemed only
1562 fair to give the user direct access to it, which in turn made it practical
1563 to support fractions as well as floats. All these features inspired me
1564 to look around for other data types that might be worth having.
1566 Around this time, my friend Rick Koshi showed me his nifty new HP-28
1567 calculator. It allowed the user to manipulate formulas as well as
1568 numerical quantities, and it could also operate on matrices. I
1569 decided that these would be good for Calc to have, too. And once
1570 things had gone this far, I figured I might as well take a look at
1571 serious algebra systems for further ideas. Since these systems did
1572 far more than I could ever hope to implement, I decided to focus on
1573 rewrite rules and other programming features so that users could
1574 implement what they needed for themselves.
1576 Rick complained that matrices were hard to read, so I put in code to
1577 format them in a 2D style. Once these routines were in place, Big mode
1578 was obligatory. Gee, what other language modes would be useful?
1580 Scott Hemphill and Allen Knutson, two friends with a strong mathematical
1581 bent, contributed ideas and algorithms for a number of Calc features
1582 including modulo forms, primality testing, and float-to-fraction conversion.
1584 Units were added at the eager insistence of Mass Sivilotti. Later,
1585 Ulrich Mueller at CERN and Przemek Klosowski at NIST provided invaluable
1586 expert assistance with the units table. As far as I can remember, the
1587 idea of using algebraic formulas and variables to represent units dates
1588 back to an ancient article in Byte magazine about muMath, an early
1589 algebra system for microcomputers.
1591 Many people have contributed to Calc by reporting bugs and suggesting
1592 features, large and small. A few deserve special mention: Tim Peters,
1593 who helped develop the ideas that led to the selection commands, rewrite
1594 rules, and many other algebra features;
1595 @texline Fran\c{c}ois
1597 Pinard, who contributed an early prototype of the Calc Summary appendix
1598 as well as providing valuable suggestions in many other areas of Calc;
1599 Carl Witty, whose eagle eyes discovered many typographical and factual
1600 errors in the Calc manual; Tim Kay, who drove the development of
1601 Embedded mode; Ove Ewerlid, who made many suggestions relating to the
1602 algebra commands and contributed some code for polynomial operations;
1603 Randal Schwartz, who suggested the @code{calc-eval} function; Robert
1604 J. Chassell, who suggested the Calc Tutorial and exercises; and Juha
1605 Sarlin, who first worked out how to split Calc into quickly-loading
1606 parts. Bob Weiner helped immensely with the Lucid Emacs port.
1608 @cindex Bibliography
1609 @cindex Knuth, Art of Computer Programming
1610 @cindex Numerical Recipes
1611 @c Should these be expanded into more complete references?
1612 Among the books used in the development of Calc were Knuth's @emph{Art
1613 of Computer Programming} (especially volume II, @emph{Seminumerical
1614 Algorithms}); @emph{Numerical Recipes} by Press, Flannery, Teukolsky,
1615 and Vetterling; Bevington's @emph{Data Reduction and Error Analysis
1616 for the Physical Sciences}; @emph{Concrete Mathematics} by Graham,
1617 Knuth, and Patashnik; Steele's @emph{Common Lisp, the Language}; the
1618 @emph{CRC Standard Math Tables} (William H. Beyer, ed.); and
1619 Abramowitz and Stegun's venerable @emph{Handbook of Mathematical
1620 Functions}. Also, of course, Calc could not have been written without
1621 the excellent @emph{GNU Emacs Lisp Reference Manual}, by Bil Lewis and
1624 Final thanks go to Richard Stallman, without whose fine implementations
1625 of the Emacs editor, language, and environment, Calc would have been
1626 finished in two weeks.
1631 @c This node is accessed by the `M-# t' command.
1632 @node Interactive Tutorial, , , Top
1636 Some brief instructions on using the Emacs Info system for this tutorial:
1638 Press the space bar and Delete keys to go forward and backward in a
1639 section by screenfuls (or use the regular Emacs scrolling commands
1642 Press @kbd{n} or @kbd{p} to go to the Next or Previous section.
1643 If the section has a @dfn{menu}, press a digit key like @kbd{1}
1644 or @kbd{2} to go to a sub-section from the menu. Press @kbd{u} to
1645 go back up from a sub-section to the menu it is part of.
1647 Exercises in the tutorial all have cross-references to the
1648 appropriate page of the ``answers'' section. Press @kbd{f}, then
1649 the exercise number, to see the answer to an exercise. After
1650 you have followed a cross-reference, you can press the letter
1651 @kbd{l} to return to where you were before.
1653 You can press @kbd{?} at any time for a brief summary of Info commands.
1655 Press @kbd{1} now to enter the first section of the Tutorial.
1662 @node Tutorial, Introduction, Getting Started, Top
1666 This chapter explains how to use Calc and its many features, in
1667 a step-by-step, tutorial way. You are encouraged to run Calc and
1668 work along with the examples as you read (@pxref{Starting Calc}).
1669 If you are already familiar with advanced calculators, you may wish
1671 to skip on to the rest of this manual.
1673 @c to skip on to volume II of this manual, the @dfn{Calc Reference}.
1675 @c [fix-ref Embedded Mode]
1676 This tutorial describes the standard user interface of Calc only.
1677 The Quick mode and Keypad mode interfaces are fairly
1678 self-explanatory. @xref{Embedded Mode}, for a description of
1679 the Embedded mode interface.
1682 The easiest way to read this tutorial on-line is to have two windows on
1683 your Emacs screen, one with Calc and one with the Info system. (If you
1684 have a printed copy of the manual you can use that instead.) Press
1685 @kbd{M-# c} to turn Calc on or to switch into the Calc window, and
1686 press @kbd{M-# i} to start the Info system or to switch into its window.
1687 Or, you may prefer to use the tutorial in printed form.
1690 The easiest way to read this tutorial on-line is to have two windows on
1691 your Emacs screen, one with Calc and one with the Info system. (If you
1692 have a printed copy of the manual you can use that instead.) Press
1693 @kbd{M-# c} to turn Calc on or to switch into the Calc window, and
1694 press @kbd{M-# i} to start the Info system or to switch into its window.
1697 This tutorial is designed to be done in sequence. But the rest of this
1698 manual does not assume you have gone through the tutorial. The tutorial
1699 does not cover everything in the Calculator, but it touches on most
1703 You may wish to print out a copy of the Calc Summary and keep notes on
1704 it as you learn Calc. @xref{About This Manual}, to see how to make a
1705 printed summary. @xref{Summary}.
1708 The Calc Summary at the end of the reference manual includes some blank
1709 space for your own use. You may wish to keep notes there as you learn
1715 * Arithmetic Tutorial::
1716 * Vector/Matrix Tutorial::
1718 * Algebra Tutorial::
1719 * Programming Tutorial::
1721 * Answers to Exercises::
1724 @node Basic Tutorial, Arithmetic Tutorial, Tutorial, Tutorial
1725 @section Basic Tutorial
1728 In this section, we learn how RPN and algebraic-style calculations
1729 work, how to undo and redo an operation done by mistake, and how
1730 to control various modes of the Calculator.
1733 * RPN Tutorial:: Basic operations with the stack.
1734 * Algebraic Tutorial:: Algebraic entry; variables.
1735 * Undo Tutorial:: If you make a mistake: Undo and the trail.
1736 * Modes Tutorial:: Common mode-setting commands.
1739 @node RPN Tutorial, Algebraic Tutorial, Basic Tutorial, Basic Tutorial
1740 @subsection RPN Calculations and the Stack
1742 @cindex RPN notation
1745 Calc normally uses RPN notation. You may be familiar with the RPN
1746 system from Hewlett-Packard calculators, FORTH, or PostScript.
1747 (Reverse Polish Notation, RPN, is named after the Polish mathematician
1752 Calc normally uses RPN notation. You may be familiar with the RPN
1753 system from Hewlett-Packard calculators, FORTH, or PostScript.
1754 (Reverse Polish Notation, RPN, is named after the Polish mathematician
1758 The central component of an RPN calculator is the @dfn{stack}. A
1759 calculator stack is like a stack of dishes. New dishes (numbers) are
1760 added at the top of the stack, and numbers are normally only removed
1761 from the top of the stack.
1765 In an operation like @expr{2+3}, the 2 and 3 are called the @dfn{operands}
1766 and the @expr{+} is the @dfn{operator}. In an RPN calculator you always
1767 enter the operands first, then the operator. Each time you type a
1768 number, Calc adds or @dfn{pushes} it onto the top of the Stack.
1769 When you press an operator key like @kbd{+}, Calc @dfn{pops} the appropriate
1770 number of operands from the stack and pushes back the result.
1772 Thus we could add the numbers 2 and 3 in an RPN calculator by typing:
1773 @kbd{2 @key{RET} 3 @key{RET} +}. (The @key{RET} key, Return, corresponds to
1774 the @key{ENTER} key on traditional RPN calculators.) Try this now if
1775 you wish; type @kbd{M-# c} to switch into the Calc window (you can type
1776 @kbd{M-# c} again or @kbd{M-# o} to switch back to the Tutorial window).
1777 The first four keystrokes ``push'' the numbers 2 and 3 onto the stack.
1778 The @kbd{+} key ``pops'' the top two numbers from the stack, adds them,
1779 and pushes the result (5) back onto the stack. Here's how the stack
1780 will look at various points throughout the calculation:
1788 M-# c 2 @key{RET} 3 @key{RET} + @key{DEL}
1792 The @samp{.} symbol is a marker that represents the top of the stack.
1793 Note that the ``top'' of the stack is really shown at the bottom of
1794 the Stack window. This may seem backwards, but it turns out to be
1795 less distracting in regular use.
1797 @cindex Stack levels
1798 @cindex Levels of stack
1799 The numbers @samp{1:} and @samp{2:} on the left are @dfn{stack level
1800 numbers}. Old RPN calculators always had four stack levels called
1801 @expr{x}, @expr{y}, @expr{z}, and @expr{t}. Calc's stack can grow
1802 as large as you like, so it uses numbers instead of letters. Some
1803 stack-manipulation commands accept a numeric argument that says
1804 which stack level to work on. Normal commands like @kbd{+} always
1805 work on the top few levels of the stack.
1807 @c [fix-ref Truncating the Stack]
1808 The Stack buffer is just an Emacs buffer, and you can move around in
1809 it using the regular Emacs motion commands. But no matter where the
1810 cursor is, even if you have scrolled the @samp{.} marker out of
1811 view, most Calc commands always move the cursor back down to level 1
1812 before doing anything. It is possible to move the @samp{.} marker
1813 upwards through the stack, temporarily ``hiding'' some numbers from
1814 commands like @kbd{+}. This is called @dfn{stack truncation} and
1815 we will not cover it in this tutorial; @pxref{Truncating the Stack},
1816 if you are interested.
1818 You don't really need the second @key{RET} in @kbd{2 @key{RET} 3
1819 @key{RET} +}. That's because if you type any operator name or
1820 other non-numeric key when you are entering a number, the Calculator
1821 automatically enters that number and then does the requested command.
1822 Thus @kbd{2 @key{RET} 3 +} will work just as well.
1824 Examples in this tutorial will often omit @key{RET} even when the
1825 stack displays shown would only happen if you did press @key{RET}:
1838 Here, after pressing @kbd{3} the stack would really show @samp{1: 2}
1839 with @samp{Calc:@: 3} in the minibuffer. In these situations, you can
1840 press the optional @key{RET} to see the stack as the figure shows.
1842 (@bullet{}) @strong{Exercise 1.} (This tutorial will include exercises
1843 at various points. Try them if you wish. Answers to all the exercises
1844 are located at the end of the Tutorial chapter. Each exercise will
1845 include a cross-reference to its particular answer. If you are
1846 reading with the Emacs Info system, press @kbd{f} and the
1847 exercise number to go to the answer, then the letter @kbd{l} to
1848 return to where you were.)
1851 Here's the first exercise: What will the keystrokes @kbd{1 @key{RET} 2
1852 @key{RET} 3 @key{RET} 4 + * -} compute? (@samp{*} is the symbol for
1853 multiplication.) Figure it out by hand, then try it with Calc to see
1854 if you're right. @xref{RPN Answer 1, 1}. (@bullet{})
1856 (@bullet{}) @strong{Exercise 2.} Compute
1857 @texline @math{(2\times4) + (7\times9.4) + {5\over4}}
1858 @infoline @expr{2*4 + 7*9.5 + 5/4}
1859 using the stack. @xref{RPN Answer 2, 2}. (@bullet{})
1861 The @key{DEL} key is called Backspace on some keyboards. It is
1862 whatever key you would use to correct a simple typing error when
1863 regularly using Emacs. The @key{DEL} key pops and throws away the
1864 top value on the stack. (You can still get that value back from
1865 the Trail if you should need it later on.) There are many places
1866 in this tutorial where we assume you have used @key{DEL} to erase the
1867 results of the previous example at the beginning of a new example.
1868 In the few places where it is really important to use @key{DEL} to
1869 clear away old results, the text will remind you to do so.
1871 (It won't hurt to let things accumulate on the stack, except that
1872 whenever you give a display-mode-changing command Calc will have to
1873 spend a long time reformatting such a large stack.)
1875 Since the @kbd{-} key is also an operator (it subtracts the top two
1876 stack elements), how does one enter a negative number? Calc uses
1877 the @kbd{_} (underscore) key to act like the minus sign in a number.
1878 So, typing @kbd{-5 @key{RET}} won't work because the @kbd{-} key
1879 will try to do a subtraction, but @kbd{_5 @key{RET}} works just fine.
1881 You can also press @kbd{n}, which means ``change sign.'' It changes
1882 the number at the top of the stack (or the number being entered)
1883 from positive to negative or vice-versa: @kbd{5 n @key{RET}}.
1885 @cindex Duplicating a stack entry
1886 If you press @key{RET} when you're not entering a number, the effect
1887 is to duplicate the top number on the stack. Consider this calculation:
1891 1: 3 2: 3 1: 9 2: 9 1: 81
1895 3 @key{RET} @key{RET} * @key{RET} *
1900 (Of course, an easier way to do this would be @kbd{3 @key{RET} 4 ^},
1901 to raise 3 to the fourth power.)
1903 The space-bar key (denoted @key{SPC} here) performs the same function
1904 as @key{RET}; you could replace all three occurrences of @key{RET} in
1905 the above example with @key{SPC} and the effect would be the same.
1907 @cindex Exchanging stack entries
1908 Another stack manipulation key is @key{TAB}. This exchanges the top
1909 two stack entries. Suppose you have computed @kbd{2 @key{RET} 3 +}
1910 to get 5, and then you realize what you really wanted to compute
1911 was @expr{20 / (2+3)}.
1915 1: 5 2: 5 2: 20 1: 4
1919 2 @key{RET} 3 + 20 @key{TAB} /
1924 Planning ahead, the calculation would have gone like this:
1928 1: 20 2: 20 3: 20 2: 20 1: 4
1933 20 @key{RET} 2 @key{RET} 3 + /
1937 A related stack command is @kbd{M-@key{TAB}} (hold @key{META} and type
1938 @key{TAB}). It rotates the top three elements of the stack upward,
1939 bringing the object in level 3 to the top.
1943 1: 10 2: 10 3: 10 3: 20 3: 30
1944 . 1: 20 2: 20 2: 30 2: 10
1948 10 @key{RET} 20 @key{RET} 30 @key{RET} M-@key{TAB} M-@key{TAB}
1952 (@bullet{}) @strong{Exercise 3.} Suppose the numbers 10, 20, and 30 are
1953 on the stack. Figure out how to add one to the number in level 2
1954 without affecting the rest of the stack. Also figure out how to add
1955 one to the number in level 3. @xref{RPN Answer 3, 3}. (@bullet{})
1957 Operations like @kbd{+}, @kbd{-}, @kbd{*}, @kbd{/}, and @kbd{^} pop two
1958 arguments from the stack and push a result. Operations like @kbd{n} and
1959 @kbd{Q} (square root) pop a single number and push the result. You can
1960 think of them as simply operating on the top element of the stack.
1964 1: 3 1: 9 2: 9 1: 25 1: 5
1968 3 @key{RET} @key{RET} * 4 @key{RET} @key{RET} * + Q
1973 (Note that capital @kbd{Q} means to hold down the Shift key while
1974 typing @kbd{q}. Remember, plain unshifted @kbd{q} is the Quit command.)
1976 @cindex Pythagorean Theorem
1977 Here we've used the Pythagorean Theorem to determine the hypotenuse of a
1978 right triangle. Calc actually has a built-in command for that called
1979 @kbd{f h}, but let's suppose we can't remember the necessary keystrokes.
1980 We can still enter it by its full name using @kbd{M-x} notation:
1988 3 @key{RET} 4 @key{RET} M-x calc-hypot
1992 All Calculator commands begin with the word @samp{calc-}. Since it
1993 gets tiring to type this, Calc provides an @kbd{x} key which is just
1994 like the regular Emacs @kbd{M-x} key except that it types the @samp{calc-}
2003 3 @key{RET} 4 @key{RET} x hypot
2007 What happens if you take the square root of a negative number?
2011 1: 4 1: -4 1: (0, 2)
2019 The notation @expr{(a, b)} represents a complex number.
2020 Complex numbers are more traditionally written @expr{a + b i};
2021 Calc can display in this format, too, but for now we'll stick to the
2022 @expr{(a, b)} notation.
2024 If you don't know how complex numbers work, you can safely ignore this
2025 feature. Complex numbers only arise from operations that would be
2026 errors in a calculator that didn't have complex numbers. (For example,
2027 taking the square root or logarithm of a negative number produces a
2030 Complex numbers are entered in the notation shown. The @kbd{(} and
2031 @kbd{,} and @kbd{)} keys manipulate ``incomplete complex numbers.''
2035 1: ( ... 2: ( ... 1: (2, ... 1: (2, ... 1: (2, 3)
2043 You can perform calculations while entering parts of incomplete objects.
2044 However, an incomplete object cannot actually participate in a calculation:
2048 1: ( ... 2: ( ... 3: ( ... 1: ( ... 1: ( ...
2058 Adding 5 to an incomplete object makes no sense, so the last command
2059 produces an error message and leaves the stack the same.
2061 Incomplete objects can't participate in arithmetic, but they can be
2062 moved around by the regular stack commands.
2066 2: 2 3: 2 3: 3 1: ( ... 1: (2, 3)
2067 1: 3 2: 3 2: ( ... 2 .
2071 2 @key{RET} 3 @key{RET} ( M-@key{TAB} M-@key{TAB} )
2076 Note that the @kbd{,} (comma) key did not have to be used here.
2077 When you press @kbd{)} all the stack entries between the incomplete
2078 entry and the top are collected, so there's never really a reason
2079 to use the comma. It's up to you.
2081 (@bullet{}) @strong{Exercise 4.} To enter the complex number @expr{(2, 3)},
2082 your friend Joe typed @kbd{( 2 , @key{SPC} 3 )}. What happened?
2083 (Joe thought of a clever way to correct his mistake in only two
2084 keystrokes, but it didn't quite work. Try it to find out why.)
2085 @xref{RPN Answer 4, 4}. (@bullet{})
2087 Vectors are entered the same way as complex numbers, but with square
2088 brackets in place of parentheses. We'll meet vectors again later in
2091 Any Emacs command can be given a @dfn{numeric prefix argument} by
2092 typing a series of @key{META}-digits beforehand. If @key{META} is
2093 awkward for you, you can instead type @kbd{C-u} followed by the
2094 necessary digits. Numeric prefix arguments can be negative, as in
2095 @kbd{M-- M-3 M-5} or @w{@kbd{C-u - 3 5}}. Calc commands use numeric
2096 prefix arguments in a variety of ways. For example, a numeric prefix
2097 on the @kbd{+} operator adds any number of stack entries at once:
2101 1: 10 2: 10 3: 10 3: 10 1: 60
2102 . 1: 20 2: 20 2: 20 .
2106 10 @key{RET} 20 @key{RET} 30 @key{RET} C-u 3 +
2110 For stack manipulation commands like @key{RET}, a positive numeric
2111 prefix argument operates on the top @var{n} stack entries at once. A
2112 negative argument operates on the entry in level @var{n} only. An
2113 argument of zero operates on the entire stack. In this example, we copy
2114 the second-to-top element of the stack:
2118 1: 10 2: 10 3: 10 3: 10 4: 10
2119 . 1: 20 2: 20 2: 20 3: 20
2124 10 @key{RET} 20 @key{RET} 30 @key{RET} C-u -2 @key{RET}
2128 @cindex Clearing the stack
2129 @cindex Emptying the stack
2130 Another common idiom is @kbd{M-0 @key{DEL}}, which clears the stack.
2131 (The @kbd{M-0} numeric prefix tells @key{DEL} to operate on the
2134 @node Algebraic Tutorial, Undo Tutorial, RPN Tutorial, Basic Tutorial
2135 @subsection Algebraic-Style Calculations
2138 If you are not used to RPN notation, you may prefer to operate the
2139 Calculator in Algebraic mode, which is closer to the way
2140 non-RPN calculators work. In Algebraic mode, you enter formulas
2141 in traditional @expr{2+3} notation.
2143 You don't really need any special ``mode'' to enter algebraic formulas.
2144 You can enter a formula at any time by pressing the apostrophe (@kbd{'})
2145 key. Answer the prompt with the desired formula, then press @key{RET}.
2146 The formula is evaluated and the result is pushed onto the RPN stack.
2147 If you don't want to think in RPN at all, you can enter your whole
2148 computation as a formula, read the result from the stack, then press
2149 @key{DEL} to delete it from the stack.
2151 Try pressing the apostrophe key, then @kbd{2+3+4}, then @key{RET}.
2152 The result should be the number 9.
2154 Algebraic formulas use the operators @samp{+}, @samp{-}, @samp{*},
2155 @samp{/}, and @samp{^}. You can use parentheses to make the order
2156 of evaluation clear. In the absence of parentheses, @samp{^} is
2157 evaluated first, then @samp{*}, then @samp{/}, then finally
2158 @samp{+} and @samp{-}. For example, the expression
2161 2 + 3*4*5 / 6*7^8 - 9
2168 2 + ((3*4*5) / (6*(7^8)) - 9
2172 or, in large mathematical notation,
2187 $$ 2 + { 3 \times 4 \times 5 \over 6 \times 7^8 } - 9 $$
2192 The result of this expression will be the number @mathit{-6.99999826533}.
2194 Calc's order of evaluation is the same as for most computer languages,
2195 except that @samp{*} binds more strongly than @samp{/}, as the above
2196 example shows. As in normal mathematical notation, the @samp{*} symbol
2197 can often be omitted: @samp{2 a} is the same as @samp{2*a}.
2199 Operators at the same level are evaluated from left to right, except
2200 that @samp{^} is evaluated from right to left. Thus, @samp{2-3-4} is
2201 equivalent to @samp{(2-3)-4} or @mathit{-5}, whereas @samp{2^3^4} is equivalent
2202 to @samp{2^(3^4)} (a very large integer; try it!).
2204 If you tire of typing the apostrophe all the time, there is
2205 Algebraic mode, where Calc automatically senses
2206 when you are about to type an algebraic expression. To enter this
2207 mode, press the two letters @w{@kbd{m a}}. (An @samp{Alg} indicator
2208 should appear in the Calc window's mode line.)
2210 Press @kbd{m a}, then @kbd{2+3+4} with no apostrophe, then @key{RET}.
2212 In Algebraic mode, when you press any key that would normally begin
2213 entering a number (such as a digit, a decimal point, or the @kbd{_}
2214 key), or if you press @kbd{(} or @kbd{[}, Calc automatically begins
2217 Functions which do not have operator symbols like @samp{+} and @samp{*}
2218 must be entered in formulas using function-call notation. For example,
2219 the function name corresponding to the square-root key @kbd{Q} is
2220 @code{sqrt}. To compute a square root in a formula, you would use
2221 the notation @samp{sqrt(@var{x})}.
2223 Press the apostrophe, then type @kbd{sqrt(5*2) - 3}. The result should
2224 be @expr{0.16227766017}.
2226 Note that if the formula begins with a function name, you need to use
2227 the apostrophe even if you are in Algebraic mode. If you type @kbd{arcsin}
2228 out of the blue, the @kbd{a r} will be taken as an Algebraic Rewrite
2229 command, and the @kbd{csin} will be taken as the name of the rewrite
2232 Some people prefer to enter complex numbers and vectors in algebraic
2233 form because they find RPN entry with incomplete objects to be too
2234 distracting, even though they otherwise use Calc as an RPN calculator.
2236 Still in Algebraic mode, type:
2240 1: (2, 3) 2: (2, 3) 1: (8, -1) 2: (8, -1) 1: (9, -1)
2241 . 1: (1, -2) . 1: 1 .
2244 (2,3) @key{RET} (1,-2) @key{RET} * 1 @key{RET} +
2248 Algebraic mode allows us to enter complex numbers without pressing
2249 an apostrophe first, but it also means we need to press @key{RET}
2250 after every entry, even for a simple number like @expr{1}.
2252 (You can type @kbd{C-u m a} to enable a special Incomplete Algebraic
2253 mode in which the @kbd{(} and @kbd{[} keys use algebraic entry even
2254 though regular numeric keys still use RPN numeric entry. There is also
2255 Total Algebraic mode, started by typing @kbd{m t}, in which all
2256 normal keys begin algebraic entry. You must then use the @key{META} key
2257 to type Calc commands: @kbd{M-m t} to get back out of Total Algebraic
2258 mode, @kbd{M-q} to quit, etc.)
2260 If you're still in Algebraic mode, press @kbd{m a} again to turn it off.
2262 Actual non-RPN calculators use a mixture of algebraic and RPN styles.
2263 In general, operators of two numbers (like @kbd{+} and @kbd{*})
2264 use algebraic form, but operators of one number (like @kbd{n} and @kbd{Q})
2265 use RPN form. Also, a non-RPN calculator allows you to see the
2266 intermediate results of a calculation as you go along. You can
2267 accomplish this in Calc by performing your calculation as a series
2268 of algebraic entries, using the @kbd{$} sign to tie them together.
2269 In an algebraic formula, @kbd{$} represents the number on the top
2270 of the stack. Here, we perform the calculation
2271 @texline @math{\sqrt{2\times4+1}},
2272 @infoline @expr{sqrt(2*4+1)},
2273 which on a traditional calculator would be done by pressing
2274 @kbd{2 * 4 + 1 =} and then the square-root key.
2281 ' 2*4 @key{RET} $+1 @key{RET} Q
2286 Notice that we didn't need to press an apostrophe for the @kbd{$+1},
2287 because the dollar sign always begins an algebraic entry.
2289 (@bullet{}) @strong{Exercise 1.} How could you get the same effect as
2290 pressing @kbd{Q} but using an algebraic entry instead? How about
2291 if the @kbd{Q} key on your keyboard were broken?
2292 @xref{Algebraic Answer 1, 1}. (@bullet{})
2294 The notations @kbd{$$}, @kbd{$$$}, and so on stand for higher stack
2295 entries. For example, @kbd{' $$+$ @key{RET}} is just like typing @kbd{+}.
2297 Algebraic formulas can include @dfn{variables}. To store in a
2298 variable, press @kbd{s s}, then type the variable name, then press
2299 @key{RET}. (There are actually two flavors of store command:
2300 @kbd{s s} stores a number in a variable but also leaves the number
2301 on the stack, while @w{@kbd{s t}} removes a number from the stack and
2302 stores it in the variable.) A variable name should consist of one
2303 or more letters or digits, beginning with a letter.
2307 1: 17 . 1: a + a^2 1: 306
2310 17 s t a @key{RET} ' a+a^2 @key{RET} =
2315 The @kbd{=} key @dfn{evaluates} a formula by replacing all its
2316 variables by the values that were stored in them.
2318 For RPN calculations, you can recall a variable's value on the
2319 stack either by entering its name as a formula and pressing @kbd{=},
2320 or by using the @kbd{s r} command.
2324 1: 17 2: 17 3: 17 2: 17 1: 306
2325 . 1: 17 2: 17 1: 289 .
2329 s r a @key{RET} ' a @key{RET} = 2 ^ +
2333 If you press a single digit for a variable name (as in @kbd{s t 3}, you
2334 get one of ten @dfn{quick variables} @code{q0} through @code{q9}.
2335 They are ``quick'' simply because you don't have to type the letter
2336 @code{q} or the @key{RET} after their names. In fact, you can type
2337 simply @kbd{s 3} as a shorthand for @kbd{s s 3}, and likewise for
2338 @kbd{t 3} and @w{@kbd{r 3}}.
2340 Any variables in an algebraic formula for which you have not stored
2341 values are left alone, even when you evaluate the formula.
2345 1: 2 a + 2 b 1: 34 + 2 b
2352 Calls to function names which are undefined in Calc are also left
2353 alone, as are calls for which the value is undefined.
2357 1: 2 + log10(0) + log10(x) + log10(5, 6) + foo(3)
2360 ' log10(100) + log10(0) + log10(x) + log10(5,6) + foo(3) @key{RET}
2365 In this example, the first call to @code{log10} works, but the other
2366 calls are not evaluated. In the second call, the logarithm is
2367 undefined for that value of the argument; in the third, the argument
2368 is symbolic, and in the fourth, there are too many arguments. In the
2369 fifth case, there is no function called @code{foo}. You will see a
2370 ``Wrong number of arguments'' message referring to @samp{log10(5,6)}.
2371 Press the @kbd{w} (``why'') key to see any other messages that may
2372 have arisen from the last calculation. In this case you will get
2373 ``logarithm of zero,'' then ``number expected: @code{x}''. Calc
2374 automatically displays the first message only if the message is
2375 sufficiently important; for example, Calc considers ``wrong number
2376 of arguments'' and ``logarithm of zero'' to be important enough to
2377 report automatically, while a message like ``number expected: @code{x}''
2378 will only show up if you explicitly press the @kbd{w} key.
2380 (@bullet{}) @strong{Exercise 2.} Joe entered the formula @samp{2 x y},
2381 stored 5 in @code{x}, pressed @kbd{=}, and got the expected result,
2382 @samp{10 y}. He then tried the same for the formula @samp{2 x (1+y)},
2383 expecting @samp{10 (1+y)}, but it didn't work. Why not?
2384 @xref{Algebraic Answer 2, 2}. (@bullet{})
2386 (@bullet{}) @strong{Exercise 3.} What result would you expect
2387 @kbd{1 @key{RET} 0 /} to give? What if you then type @kbd{0 *}?
2388 @xref{Algebraic Answer 3, 3}. (@bullet{})
2390 One interesting way to work with variables is to use the
2391 @dfn{evaluates-to} (@samp{=>}) operator. It works like this:
2392 Enter a formula algebraically in the usual way, but follow
2393 the formula with an @samp{=>} symbol. (There is also an @kbd{s =}
2394 command which builds an @samp{=>} formula using the stack.) On
2395 the stack, you will see two copies of the formula with an @samp{=>}
2396 between them. The lefthand formula is exactly like you typed it;
2397 the righthand formula has been evaluated as if by typing @kbd{=}.
2401 2: 2 + 3 => 5 2: 2 + 3 => 5
2402 1: 2 a + 2 b => 34 + 2 b 1: 2 a + 2 b => 20 + 2 b
2405 ' 2+3 => @key{RET} ' 2a+2b @key{RET} s = 10 s t a @key{RET}
2410 Notice that the instant we stored a new value in @code{a}, all
2411 @samp{=>} operators already on the stack that referred to @expr{a}
2412 were updated to use the new value. With @samp{=>}, you can push a
2413 set of formulas on the stack, then change the variables experimentally
2414 to see the effects on the formulas' values.
2416 You can also ``unstore'' a variable when you are through with it:
2421 1: 2 a + 2 b => 2 a + 2 b
2428 We will encounter formulas involving variables and functions again
2429 when we discuss the algebra and calculus features of the Calculator.
2431 @node Undo Tutorial, Modes Tutorial, Algebraic Tutorial, Basic Tutorial
2432 @subsection Undo and Redo
2435 If you make a mistake, you can usually correct it by pressing shift-@kbd{U},
2436 the ``undo'' command. First, clear the stack (@kbd{M-0 @key{DEL}}) and exit
2437 and restart Calc (@kbd{M-# M-# M-# M-#}) to make sure things start off
2438 with a clean slate. Now:
2442 1: 2 2: 2 1: 8 2: 2 1: 6
2450 You can undo any number of times. Calc keeps a complete record of
2451 all you have done since you last opened the Calc window. After the
2452 above example, you could type:
2464 You can also type @kbd{D} to ``redo'' a command that you have undone
2469 . 1: 2 2: 2 1: 6 1: 6
2478 It was not possible to redo past the @expr{6}, since that was placed there
2479 by something other than an undo command.
2482 You can think of undo and redo as a sort of ``time machine.'' Press
2483 @kbd{U} to go backward in time, @kbd{D} to go forward. If you go
2484 backward and do something (like @kbd{*}) then, as any science fiction
2485 reader knows, you have changed your future and you cannot go forward
2486 again. Thus, the inability to redo past the @expr{6} even though there
2487 was an earlier undo command.
2489 You can always recall an earlier result using the Trail. We've ignored
2490 the trail so far, but it has been faithfully recording everything we
2491 did since we loaded the Calculator. If the Trail is not displayed,
2492 press @kbd{t d} now to turn it on.
2494 Let's try grabbing an earlier result. The @expr{8} we computed was
2495 undone by a @kbd{U} command, and was lost even to Redo when we pressed
2496 @kbd{*}, but it's still there in the trail. There should be a little
2497 @samp{>} arrow (the @dfn{trail pointer}) resting on the last trail
2498 entry. If there isn't, press @kbd{t ]} to reset the trail pointer.
2499 Now, press @w{@kbd{t p}} to move the arrow onto the line containing
2500 @expr{8}, and press @w{@kbd{t y}} to ``yank'' that number back onto the
2503 If you press @kbd{t ]} again, you will see that even our Yank command
2504 went into the trail.
2506 Let's go further back in time. Earlier in the tutorial we computed
2507 a huge integer using the formula @samp{2^3^4}. We don't remember
2508 what it was, but the first digits were ``241''. Press @kbd{t r}
2509 (which stands for trail-search-reverse), then type @kbd{241}.
2510 The trail cursor will jump back to the next previous occurrence of
2511 the string ``241'' in the trail. This is just a regular Emacs
2512 incremental search; you can now press @kbd{C-s} or @kbd{C-r} to
2513 continue the search forwards or backwards as you like.
2515 To finish the search, press @key{RET}. This halts the incremental
2516 search and leaves the trail pointer at the thing we found. Now we
2517 can type @kbd{t y} to yank that number onto the stack. If we hadn't
2518 remembered the ``241'', we could simply have searched for @kbd{2^3^4},
2519 then pressed @kbd{@key{RET} t n} to halt and then move to the next item.
2521 You may have noticed that all the trail-related commands begin with
2522 the letter @kbd{t}. (The store-and-recall commands, on the other hand,
2523 all began with @kbd{s}.) Calc has so many commands that there aren't
2524 enough keys for all of them, so various commands are grouped into
2525 two-letter sequences where the first letter is called the @dfn{prefix}
2526 key. If you type a prefix key by accident, you can press @kbd{C-g}
2527 to cancel it. (In fact, you can press @kbd{C-g} to cancel almost
2528 anything in Emacs.) To get help on a prefix key, press that key
2529 followed by @kbd{?}. Some prefixes have several lines of help,
2530 so you need to press @kbd{?} repeatedly to see them all.
2531 You can also type @kbd{h h} to see all the help at once.
2533 Try pressing @kbd{t ?} now. You will see a line of the form,
2536 trail/time: Display; Fwd, Back; Next, Prev, Here, [, ]; Yank: [MORE] t-
2540 The word ``trail'' indicates that the @kbd{t} prefix key contains
2541 trail-related commands. Each entry on the line shows one command,
2542 with a single capital letter showing which letter you press to get
2543 that command. We have used @kbd{t n}, @kbd{t p}, @kbd{t ]}, and
2544 @kbd{t y} so far. The @samp{[MORE]} means you can press @kbd{?}
2545 again to see more @kbd{t}-prefix commands. Notice that the commands
2546 are roughly divided (by semicolons) into related groups.
2548 When you are in the help display for a prefix key, the prefix is
2549 still active. If you press another key, like @kbd{y} for example,
2550 it will be interpreted as a @kbd{t y} command. If all you wanted
2551 was to look at the help messages, press @kbd{C-g} afterwards to cancel
2554 One more way to correct an error is by editing the stack entries.
2555 The actual Stack buffer is marked read-only and must not be edited
2556 directly, but you can press @kbd{`} (the backquote or accent grave)
2557 to edit a stack entry.
2559 Try entering @samp{3.141439} now. If this is supposed to represent
2560 @cpi{}, it's got several errors. Press @kbd{`} to edit this number.
2561 Now use the normal Emacs cursor motion and editing keys to change
2562 the second 4 to a 5, and to transpose the 3 and the 9. When you
2563 press @key{RET}, the number on the stack will be replaced by your
2564 new number. This works for formulas, vectors, and all other types
2565 of values you can put on the stack. The @kbd{`} key also works
2566 during entry of a number or algebraic formula.
2568 @node Modes Tutorial, , Undo Tutorial, Basic Tutorial
2569 @subsection Mode-Setting Commands
2572 Calc has many types of @dfn{modes} that affect the way it interprets
2573 your commands or the way it displays data. We have already seen one
2574 mode, namely Algebraic mode. There are many others, too; we'll
2575 try some of the most common ones here.
2577 Perhaps the most fundamental mode in Calc is the current @dfn{precision}.
2578 Notice the @samp{12} on the Calc window's mode line:
2581 --%%-Calc: 12 Deg (Calculator)----All------
2585 Most of the symbols there are Emacs things you don't need to worry
2586 about, but the @samp{12} and the @samp{Deg} are mode indicators.
2587 The @samp{12} means that calculations should always be carried to
2588 12 significant figures. That is why, when we type @kbd{1 @key{RET} 7 /},
2589 we get @expr{0.142857142857} with exactly 12 digits, not counting
2590 leading and trailing zeros.
2592 You can set the precision to anything you like by pressing @kbd{p},
2593 then entering a suitable number. Try pressing @kbd{p 30 @key{RET}},
2594 then doing @kbd{1 @key{RET} 7 /} again:
2599 2: 0.142857142857142857142857142857
2604 Although the precision can be set arbitrarily high, Calc always
2605 has to have @emph{some} value for the current precision. After
2606 all, the true value @expr{1/7} is an infinitely repeating decimal;
2607 Calc has to stop somewhere.
2609 Of course, calculations are slower the more digits you request.
2610 Press @w{@kbd{p 12}} now to set the precision back down to the default.
2612 Calculations always use the current precision. For example, even
2613 though we have a 30-digit value for @expr{1/7} on the stack, if
2614 we use it in a calculation in 12-digit mode it will be rounded
2615 down to 12 digits before it is used. Try it; press @key{RET} to
2616 duplicate the number, then @w{@kbd{1 +}}. Notice that the @key{RET}
2617 key didn't round the number, because it doesn't do any calculation.
2618 But the instant we pressed @kbd{+}, the number was rounded down.
2623 2: 0.142857142857142857142857142857
2630 In fact, since we added a digit on the left, we had to lose one
2631 digit on the right from even the 12-digit value of @expr{1/7}.
2633 How did we get more than 12 digits when we computed @samp{2^3^4}? The
2634 answer is that Calc makes a distinction between @dfn{integers} and
2635 @dfn{floating-point} numbers, or @dfn{floats}. An integer is a number
2636 that does not contain a decimal point. There is no such thing as an
2637 ``infinitely repeating fraction integer,'' so Calc doesn't have to limit
2638 itself. If you asked for @samp{2^10000} (don't try this!), you would
2639 have to wait a long time but you would eventually get an exact answer.
2640 If you ask for @samp{2.^10000}, you will quickly get an answer which is
2641 correct only to 12 places. The decimal point tells Calc that it should
2642 use floating-point arithmetic to get the answer, not exact integer
2645 You can use the @kbd{F} (@code{calc-floor}) command to convert a
2646 floating-point value to an integer, and @kbd{c f} (@code{calc-float})
2647 to convert an integer to floating-point form.
2649 Let's try entering that last calculation:
2653 1: 2. 2: 2. 1: 1.99506311689e3010
2657 2.0 @key{RET} 10000 @key{RET} ^
2662 @cindex Scientific notation, entry of
2663 Notice the letter @samp{e} in there. It represents ``times ten to the
2664 power of,'' and is used by Calc automatically whenever writing the
2665 number out fully would introduce more extra zeros than you probably
2666 want to see. You can enter numbers in this notation, too.
2670 1: 2. 2: 2. 1: 1.99506311678e3010
2674 2.0 @key{RET} 1e4 @key{RET} ^
2678 @cindex Round-off errors
2680 Hey, the answer is different! Look closely at the middle columns
2681 of the two examples. In the first, the stack contained the
2682 exact integer @expr{10000}, but in the second it contained
2683 a floating-point value with a decimal point. When you raise a
2684 number to an integer power, Calc uses repeated squaring and
2685 multiplication to get the answer. When you use a floating-point
2686 power, Calc uses logarithms and exponentials. As you can see,
2687 a slight error crept in during one of these methods. Which
2688 one should we trust? Let's raise the precision a bit and find
2693 . 1: 2. 2: 2. 1: 1.995063116880828e3010
2697 p 16 @key{RET} 2. @key{RET} 1e4 ^ p 12 @key{RET}
2702 @cindex Guard digits
2703 Presumably, it doesn't matter whether we do this higher-precision
2704 calculation using an integer or floating-point power, since we
2705 have added enough ``guard digits'' to trust the first 12 digits
2706 no matter what. And the verdict is@dots{} Integer powers were more
2707 accurate; in fact, the result was only off by one unit in the
2710 @cindex Guard digits
2711 Calc does many of its internal calculations to a slightly higher
2712 precision, but it doesn't always bump the precision up enough.
2713 In each case, Calc added about two digits of precision during
2714 its calculation and then rounded back down to 12 digits
2715 afterward. In one case, it was enough; in the other, it
2716 wasn't. If you really need @var{x} digits of precision, it
2717 never hurts to do the calculation with a few extra guard digits.
2719 What if we want guard digits but don't want to look at them?
2720 We can set the @dfn{float format}. Calc supports four major
2721 formats for floating-point numbers, called @dfn{normal},
2722 @dfn{fixed-point}, @dfn{scientific notation}, and @dfn{engineering
2723 notation}. You get them by pressing @w{@kbd{d n}}, @kbd{d f},
2724 @kbd{d s}, and @kbd{d e}, respectively. In each case, you can
2725 supply a numeric prefix argument which says how many digits
2726 should be displayed. As an example, let's put a few numbers
2727 onto the stack and try some different display modes. First,
2728 use @kbd{M-0 @key{DEL}} to clear the stack, then enter the four
2733 4: 12345 4: 12345 4: 12345 4: 12345 4: 12345
2734 3: 12345. 3: 12300. 3: 1.2345e4 3: 1.23e4 3: 12345.000
2735 2: 123.45 2: 123. 2: 1.2345e2 2: 1.23e2 2: 123.450
2736 1: 12.345 1: 12.3 1: 1.2345e1 1: 1.23e1 1: 12.345
2739 d n M-3 d n d s M-3 d s M-3 d f
2744 Notice that when we typed @kbd{M-3 d n}, the numbers were rounded down
2745 to three significant digits, but then when we typed @kbd{d s} all
2746 five significant figures reappeared. The float format does not
2747 affect how numbers are stored, it only affects how they are
2748 displayed. Only the current precision governs the actual rounding
2749 of numbers in the Calculator's memory.
2751 Engineering notation, not shown here, is like scientific notation
2752 except the exponent (the power-of-ten part) is always adjusted to be
2753 a multiple of three (as in ``kilo,'' ``micro,'' etc.). As a result
2754 there will be one, two, or three digits before the decimal point.
2756 Whenever you change a display-related mode, Calc redraws everything
2757 in the stack. This may be slow if there are many things on the stack,
2758 so Calc allows you to type shift-@kbd{H} before any mode command to
2759 prevent it from updating the stack. Anything Calc displays after the
2760 mode-changing command will appear in the new format.
2764 4: 12345 4: 12345 4: 12345 4: 12345 4: 12345
2765 3: 12345.000 3: 12345.000 3: 12345.000 3: 1.2345e4 3: 12345.
2766 2: 123.450 2: 123.450 2: 1.2345e1 2: 1.2345e1 2: 123.45
2767 1: 12.345 1: 1.2345e1 1: 1.2345e2 1: 1.2345e2 1: 12.345
2770 H d s @key{DEL} U @key{TAB} d @key{SPC} d n
2775 Here the @kbd{H d s} command changes to scientific notation but without
2776 updating the screen. Deleting the top stack entry and undoing it back
2777 causes it to show up in the new format; swapping the top two stack
2778 entries reformats both entries. The @kbd{d @key{SPC}} command refreshes the
2779 whole stack. The @kbd{d n} command changes back to the normal float
2780 format; since it doesn't have an @kbd{H} prefix, it also updates all
2781 the stack entries to be in @kbd{d n} format.
2783 Notice that the integer @expr{12345} was not affected by any
2784 of the float formats. Integers are integers, and are always
2787 @cindex Large numbers, readability
2788 Large integers have their own problems. Let's look back at
2789 the result of @kbd{2^3^4}.
2792 2417851639229258349412352
2796 Quick---how many digits does this have? Try typing @kbd{d g}:
2799 2,417,851,639,229,258,349,412,352
2803 Now how many digits does this have? It's much easier to tell!
2804 We can actually group digits into clumps of any size. Some
2805 people prefer @kbd{M-5 d g}:
2808 24178,51639,22925,83494,12352
2811 Let's see what happens to floating-point numbers when they are grouped.
2812 First, type @kbd{p 25 @key{RET}} to make sure we have enough precision
2813 to get ourselves into trouble. Now, type @kbd{1e13 /}:
2816 24,17851,63922.9258349412352
2820 The integer part is grouped but the fractional part isn't. Now try
2821 @kbd{M-- M-5 d g} (that's meta-minus-sign, meta-five):
2824 24,17851,63922.92583,49412,352
2827 If you find it hard to tell the decimal point from the commas, try
2828 changing the grouping character to a space with @kbd{d , @key{SPC}}:
2831 24 17851 63922.92583 49412 352
2834 Type @kbd{d , ,} to restore the normal grouping character, then
2835 @kbd{d g} again to turn grouping off. Also, press @kbd{p 12} to
2836 restore the default precision.
2838 Press @kbd{U} enough times to get the original big integer back.
2839 (Notice that @kbd{U} does not undo each mode-setting command; if
2840 you want to undo a mode-setting command, you have to do it yourself.)
2841 Now, type @kbd{d r 16 @key{RET}}:
2844 16#200000000000000000000
2848 The number is now displayed in @dfn{hexadecimal}, or ``base-16'' form.
2849 Suddenly it looks pretty simple; this should be no surprise, since we
2850 got this number by computing a power of two, and 16 is a power of 2.
2851 In fact, we can use @w{@kbd{d r 2 @key{RET}}} to see it in actual binary
2855 2#1000000000000000000000000000000000000000000000000000000 @dots{}
2859 We don't have enough space here to show all the zeros! They won't
2860 fit on a typical screen, either, so you will have to use horizontal
2861 scrolling to see them all. Press @kbd{<} and @kbd{>} to scroll the
2862 stack window left and right by half its width. Another way to view
2863 something large is to press @kbd{`} (back-quote) to edit the top of
2864 stack in a separate window. (Press @kbd{C-c C-c} when you are done.)
2866 You can enter non-decimal numbers using the @kbd{#} symbol, too.
2867 Let's see what the hexadecimal number @samp{5FE} looks like in
2868 binary. Type @kbd{16#5FE} (the letters can be typed in upper or
2869 lower case; they will always appear in upper case). It will also
2870 help to turn grouping on with @kbd{d g}:
2876 Notice that @kbd{d g} groups by fours by default if the display radix
2877 is binary or hexadecimal, but by threes if it is decimal, octal, or any
2880 Now let's see that number in decimal; type @kbd{d r 10}:
2886 Numbers are not @emph{stored} with any particular radix attached. They're
2887 just numbers; they can be entered in any radix, and are always displayed
2888 in whatever radix you've chosen with @kbd{d r}. The current radix applies
2889 to integers, fractions, and floats.
2891 @cindex Roundoff errors, in non-decimal numbers
2892 (@bullet{}) @strong{Exercise 1.} Your friend Joe tried to enter one-third
2893 as @samp{3#0.1} in @kbd{d r 3} mode with a precision of 12. He got
2894 @samp{3#0.0222222...} (with 25 2's) in the display. When he multiplied
2895 that by three, he got @samp{3#0.222222...} instead of the expected
2896 @samp{3#1}. Next, Joe entered @samp{3#0.2} and, to his great relief,
2897 saw @samp{3#0.2} on the screen. But when he typed @kbd{2 /}, he got
2898 @samp{3#0.10000001} (some zeros omitted). What's going on here?
2899 @xref{Modes Answer 1, 1}. (@bullet{})
2901 @cindex Scientific notation, in non-decimal numbers
2902 (@bullet{}) @strong{Exercise 2.} Scientific notation works in non-decimal
2903 modes in the natural way (the exponent is a power of the radix instead of
2904 a power of ten, although the exponent itself is always written in decimal).
2905 Thus @samp{8#1.23e3 = 8#1230.0}. Suppose we have the hexadecimal number
2906 @samp{f.e8f} times 16 to the 15th power: We write @samp{16#f.e8fe15}.
2907 What is wrong with this picture? What could we write instead that would
2908 work better? @xref{Modes Answer 2, 2}. (@bullet{})
2910 The @kbd{m} prefix key has another set of modes, relating to the way
2911 Calc interprets your inputs and does computations. Whereas @kbd{d}-prefix
2912 modes generally affect the way things look, @kbd{m}-prefix modes affect
2913 the way they are actually computed.
2915 The most popular @kbd{m}-prefix mode is the @dfn{angular mode}. Notice
2916 the @samp{Deg} indicator in the mode line. This means that if you use
2917 a command that interprets a number as an angle, it will assume the
2918 angle is measured in degrees. For example,
2922 1: 45 1: 0.707106781187 1: 0.500000000001 1: 0.5
2930 The shift-@kbd{S} command computes the sine of an angle. The sine
2932 @texline @math{\sqrt{2}/2};
2933 @infoline @expr{sqrt(2)/2};
2934 squaring this yields @expr{2/4 = 0.5}. However, there has been a slight
2935 roundoff error because the representation of
2936 @texline @math{\sqrt{2}/2}
2937 @infoline @expr{sqrt(2)/2}
2938 wasn't exact. The @kbd{c 1} command is a handy way to clean up numbers
2939 in this case; it temporarily reduces the precision by one digit while it
2940 re-rounds the number on the top of the stack.
2942 @cindex Roundoff errors, examples
2943 (@bullet{}) @strong{Exercise 3.} Your friend Joe computed the sine
2944 of 45 degrees as shown above, then, hoping to avoid an inexact
2945 result, he increased the precision to 16 digits before squaring.
2946 What happened? @xref{Modes Answer 3, 3}. (@bullet{})
2948 To do this calculation in radians, we would type @kbd{m r} first.
2949 (The indicator changes to @samp{Rad}.) 45 degrees corresponds to
2950 @cpiover{4} radians. To get @cpi{}, press the @kbd{P} key. (Once
2951 again, this is a shifted capital @kbd{P}. Remember, unshifted
2952 @kbd{p} sets the precision.)
2956 1: 3.14159265359 1: 0.785398163398 1: 0.707106781187
2963 Likewise, inverse trigonometric functions generate results in
2964 either radians or degrees, depending on the current angular mode.
2968 1: 0.707106781187 1: 0.785398163398 1: 45.
2971 .5 Q m r I S m d U I S
2976 Here we compute the Inverse Sine of
2977 @texline @math{\sqrt{0.5}},
2978 @infoline @expr{sqrt(0.5)},
2979 first in radians, then in degrees.
2981 Use @kbd{c d} and @kbd{c r} to convert a number from radians to degrees
2986 1: 45 1: 0.785398163397 1: 45.
2993 Another interesting mode is @dfn{Fraction mode}. Normally,
2994 dividing two integers produces a floating-point result if the
2995 quotient can't be expressed as an exact integer. Fraction mode
2996 causes integer division to produce a fraction, i.e., a rational
3001 2: 12 1: 1.33333333333 1: 4:3
3005 12 @key{RET} 9 / m f U / m f
3010 In the first case, we get an approximate floating-point result.
3011 In the second case, we get an exact fractional result (four-thirds).
3013 You can enter a fraction at any time using @kbd{:} notation.
3014 (Calc uses @kbd{:} instead of @kbd{/} as the fraction separator
3015 because @kbd{/} is already used to divide the top two stack
3016 elements.) Calculations involving fractions will always
3017 produce exact fractional results; Fraction mode only says
3018 what to do when dividing two integers.
3020 @cindex Fractions vs. floats
3021 @cindex Floats vs. fractions
3022 (@bullet{}) @strong{Exercise 4.} If fractional arithmetic is exact,
3023 why would you ever use floating-point numbers instead?
3024 @xref{Modes Answer 4, 4}. (@bullet{})
3026 Typing @kbd{m f} doesn't change any existing values in the stack.
3027 In the above example, we had to Undo the division and do it over
3028 again when we changed to Fraction mode. But if you use the
3029 evaluates-to operator you can get commands like @kbd{m f} to
3034 1: 12 / 9 => 1.33333333333 1: 12 / 9 => 1.333 1: 12 / 9 => 4:3
3037 ' 12/9 => @key{RET} p 4 @key{RET} m f
3042 In this example, the righthand side of the @samp{=>} operator
3043 on the stack is recomputed when we change the precision, then
3044 again when we change to Fraction mode. All @samp{=>} expressions
3045 on the stack are recomputed every time you change any mode that
3046 might affect their values.
3048 @node Arithmetic Tutorial, Vector/Matrix Tutorial, Basic Tutorial, Tutorial
3049 @section Arithmetic Tutorial
3052 In this section, we explore the arithmetic and scientific functions
3053 available in the Calculator.
3055 The standard arithmetic commands are @kbd{+}, @kbd{-}, @kbd{*}, @kbd{/},
3056 and @kbd{^}. Each normally takes two numbers from the top of the stack
3057 and pushes back a result. The @kbd{n} and @kbd{&} keys perform
3058 change-sign and reciprocal operations, respectively.
3062 1: 5 1: 0.2 1: 5. 1: -5. 1: 5.
3069 @cindex Binary operators
3070 You can apply a ``binary operator'' like @kbd{+} across any number of
3071 stack entries by giving it a numeric prefix. You can also apply it
3072 pairwise to several stack elements along with the top one if you use
3077 3: 2 1: 9 3: 2 4: 2 3: 12
3078 2: 3 . 2: 3 3: 3 2: 13
3079 1: 4 1: 4 2: 4 1: 14
3083 2 @key{RET} 3 @key{RET} 4 M-3 + U 10 M-- M-3 +
3087 @cindex Unary operators
3088 You can apply a ``unary operator'' like @kbd{&} to the top @var{n}
3089 stack entries with a numeric prefix, too.
3094 2: 3 2: 0.333333333333 2: 3.
3098 2 @key{RET} 3 @key{RET} 4 M-3 & M-2 &
3102 Notice that the results here are left in floating-point form.
3103 We can convert them back to integers by pressing @kbd{F}, the
3104 ``floor'' function. This function rounds down to the next lower
3105 integer. There is also @kbd{R}, which rounds to the nearest
3123 Since dividing-and-flooring (i.e., ``integer quotient'') is such a
3124 common operation, Calc provides a special command for that purpose, the
3125 backslash @kbd{\}. Another common arithmetic operator is @kbd{%}, which
3126 computes the remainder that would arise from a @kbd{\} operation, i.e.,
3127 the ``modulo'' of two numbers. For example,
3131 2: 1234 1: 12 2: 1234 1: 34
3135 1234 @key{RET} 100 \ U %
3139 These commands actually work for any real numbers, not just integers.
3143 2: 3.1415 1: 3 2: 3.1415 1: 0.1415
3147 3.1415 @key{RET} 1 \ U %
3151 (@bullet{}) @strong{Exercise 1.} The @kbd{\} command would appear to be a
3152 frill, since you could always do the same thing with @kbd{/ F}. Think
3153 of a situation where this is not true---@kbd{/ F} would be inadequate.
3154 Now think of a way you could get around the problem if Calc didn't
3155 provide a @kbd{\} command. @xref{Arithmetic Answer 1, 1}. (@bullet{})
3157 We've already seen the @kbd{Q} (square root) and @kbd{S} (sine)
3158 commands. Other commands along those lines are @kbd{C} (cosine),
3159 @kbd{T} (tangent), @kbd{E} (@expr{e^x}) and @kbd{L} (natural
3160 logarithm). These can be modified by the @kbd{I} (inverse) and
3161 @kbd{H} (hyperbolic) prefix keys.
3163 Let's compute the sine and cosine of an angle, and verify the
3165 @texline @math{\sin^2x + \cos^2x = 1}.
3166 @infoline @expr{sin(x)^2 + cos(x)^2 = 1}.
3167 We'll arbitrarily pick @mathit{-64} degrees as a good value for @expr{x}.
3168 With the angular mode set to degrees (type @w{@kbd{m d}}), do:
3172 2: -64 2: -64 2: -0.89879 2: -0.89879 1: 1.
3173 1: -64 1: -0.89879 1: -64 1: 0.43837 .
3176 64 n @key{RET} @key{RET} S @key{TAB} C f h
3181 (For brevity, we're showing only five digits of the results here.
3182 You can of course do these calculations to any precision you like.)
3184 Remember, @kbd{f h} is the @code{calc-hypot}, or square-root of sum
3185 of squares, command.
3188 @texline @math{\displaystyle\tan x = {\sin x \over \cos x}}.
3189 @infoline @expr{tan(x) = sin(x) / cos(x)}.
3193 2: -0.89879 1: -2.0503 1: -64.
3201 A physical interpretation of this calculation is that if you move
3202 @expr{0.89879} units downward and @expr{0.43837} units to the right,
3203 your direction of motion is @mathit{-64} degrees from horizontal. Suppose
3204 we move in the opposite direction, up and to the left:
3208 2: -0.89879 2: 0.89879 1: -2.0503 1: -64.
3209 1: 0.43837 1: -0.43837 . .
3217 How can the angle be the same? The answer is that the @kbd{/} operation
3218 loses information about the signs of its inputs. Because the quotient
3219 is negative, we know exactly one of the inputs was negative, but we
3220 can't tell which one. There is an @kbd{f T} [@code{arctan2}] function which
3221 computes the inverse tangent of the quotient of a pair of numbers.
3222 Since you feed it the two original numbers, it has enough information
3223 to give you a full 360-degree answer.
3227 2: 0.89879 1: 116. 3: 116. 2: 116. 1: 180.
3228 1: -0.43837 . 2: -0.89879 1: -64. .
3232 U U f T M-@key{RET} M-2 n f T -
3237 The resulting angles differ by 180 degrees; in other words, they
3238 point in opposite directions, just as we would expect.
3240 The @key{META}-@key{RET} we used in the third step is the
3241 ``last-arguments'' command. It is sort of like Undo, except that it
3242 restores the arguments of the last command to the stack without removing
3243 the command's result. It is useful in situations like this one,
3244 where we need to do several operations on the same inputs. We could
3245 have accomplished the same thing by using @kbd{M-2 @key{RET}} to duplicate
3246 the top two stack elements right after the @kbd{U U}, then a pair of
3247 @kbd{M-@key{TAB}} commands to cycle the 116 up around the duplicates.
3249 A similar identity is supposed to hold for hyperbolic sines and cosines,
3250 except that it is the @emph{difference}
3251 @texline @math{\cosh^2x - \sinh^2x}
3252 @infoline @expr{cosh(x)^2 - sinh(x)^2}
3253 that always equals one. Let's try to verify this identity.
3257 2: -64 2: -64 2: -64 2: 9.7192e54 2: 9.7192e54
3258 1: -64 1: -3.1175e27 1: 9.7192e54 1: -64 1: 9.7192e54
3261 64 n @key{RET} @key{RET} H C 2 ^ @key{TAB} H S 2 ^
3266 @cindex Roundoff errors, examples
3267 Something's obviously wrong, because when we subtract these numbers
3268 the answer will clearly be zero! But if you think about it, if these
3269 numbers @emph{did} differ by one, it would be in the 55th decimal
3270 place. The difference we seek has been lost entirely to roundoff
3273 We could verify this hypothesis by doing the actual calculation with,
3274 say, 60 decimal places of precision. This will be slow, but not
3275 enormously so. Try it if you wish; sure enough, the answer is
3276 0.99999, reasonably close to 1.
3278 Of course, a more reasonable way to verify the identity is to use
3279 a more reasonable value for @expr{x}!
3281 @cindex Common logarithm
3282 Some Calculator commands use the Hyperbolic prefix for other purposes.
3283 The logarithm and exponential functions, for example, work to the base
3284 @expr{e} normally but use base-10 instead if you use the Hyperbolic
3289 1: 1000 1: 6.9077 1: 1000 1: 3
3297 First, we mistakenly compute a natural logarithm. Then we undo
3298 and compute a common logarithm instead.
3300 The @kbd{B} key computes a general base-@var{b} logarithm for any
3305 2: 1000 1: 3 1: 1000. 2: 1000. 1: 6.9077
3306 1: 10 . . 1: 2.71828 .
3309 1000 @key{RET} 10 B H E H P B
3314 Here we first use @kbd{B} to compute the base-10 logarithm, then use
3315 the ``hyperbolic'' exponential as a cheap hack to recover the number
3316 1000, then use @kbd{B} again to compute the natural logarithm. Note
3317 that @kbd{P} with the hyperbolic prefix pushes the constant @expr{e}
3320 You may have noticed that both times we took the base-10 logarithm
3321 of 1000, we got an exact integer result. Calc always tries to give
3322 an exact rational result for calculations involving rational numbers
3323 where possible. But when we used @kbd{H E}, the result was a
3324 floating-point number for no apparent reason. In fact, if we had
3325 computed @kbd{10 @key{RET} 3 ^} we @emph{would} have gotten an
3326 exact integer 1000. But the @kbd{H E} command is rigged to generate
3327 a floating-point result all of the time so that @kbd{1000 H E} will
3328 not waste time computing a thousand-digit integer when all you
3329 probably wanted was @samp{1e1000}.
3331 (@bullet{}) @strong{Exercise 2.} Find a pair of integer inputs to
3332 the @kbd{B} command for which Calc could find an exact rational
3333 result but doesn't. @xref{Arithmetic Answer 2, 2}. (@bullet{})
3335 The Calculator also has a set of functions relating to combinatorics
3336 and statistics. You may be familiar with the @dfn{factorial} function,
3337 which computes the product of all the integers up to a given number.
3341 1: 100 1: 93326215443... 1: 100. 1: 9.3326e157
3349 Recall, the @kbd{c f} command converts the integer or fraction at the
3350 top of the stack to floating-point format. If you take the factorial
3351 of a floating-point number, you get a floating-point result
3352 accurate to the current precision. But if you give @kbd{!} an
3353 exact integer, you get an exact integer result (158 digits long
3356 If you take the factorial of a non-integer, Calc uses a generalized
3357 factorial function defined in terms of Euler's Gamma function
3358 @texline @math{\Gamma(n)}
3359 @infoline @expr{gamma(n)}
3360 (which is itself available as the @kbd{f g} command).
3364 3: 4. 3: 24. 1: 5.5 1: 52.342777847
3365 2: 4.5 2: 52.3427777847 . .
3369 M-3 ! M-0 @key{DEL} 5.5 f g
3374 Here we verify the identity
3375 @texline @math{n! = \Gamma(n+1)}.
3376 @infoline @expr{@var{n}!@: = gamma(@var{n}+1)}.
3378 The binomial coefficient @var{n}-choose-@var{m}
3379 @texline or @math{\displaystyle {n \choose m}}
3381 @texline @math{\displaystyle {n! \over m! \, (n-m)!}}
3382 @infoline @expr{n!@: / m!@: (n-m)!}
3383 for all reals @expr{n} and @expr{m}. The intermediate results in this
3384 formula can become quite large even if the final result is small; the
3385 @kbd{k c} command computes a binomial coefficient in a way that avoids
3386 large intermediate values.
3388 The @kbd{k} prefix key defines several common functions out of
3389 combinatorics and number theory. Here we compute the binomial
3390 coefficient 30-choose-20, then determine its prime factorization.
3394 2: 30 1: 30045015 1: [3, 3, 5, 7, 11, 13, 23, 29]
3398 30 @key{RET} 20 k c k f
3403 You can verify these prime factors by using @kbd{v u} to ``unpack''
3404 this vector into 8 separate stack entries, then @kbd{M-8 *} to
3405 multiply them back together. The result is the original number,
3409 Suppose a program you are writing needs a hash table with at least
3410 10000 entries. It's best to use a prime number as the actual size
3411 of a hash table. Calc can compute the next prime number after 10000:
3415 1: 10000 1: 10007 1: 9973
3423 Just for kicks we've also computed the next prime @emph{less} than
3426 @c [fix-ref Financial Functions]
3427 @xref{Financial Functions}, for a description of the Calculator
3428 commands that deal with business and financial calculations (functions
3429 like @code{pv}, @code{rate}, and @code{sln}).
3431 @c [fix-ref Binary Number Functions]
3432 @xref{Binary Functions}, to read about the commands for operating
3433 on binary numbers (like @code{and}, @code{xor}, and @code{lsh}).
3435 @node Vector/Matrix Tutorial, Types Tutorial, Arithmetic Tutorial, Tutorial
3436 @section Vector/Matrix Tutorial
3439 A @dfn{vector} is a list of numbers or other Calc data objects.
3440 Calc provides a large set of commands that operate on vectors. Some
3441 are familiar operations from vector analysis. Others simply treat
3442 a vector as a list of objects.
3445 * Vector Analysis Tutorial::
3450 @node Vector Analysis Tutorial, Matrix Tutorial, Vector/Matrix Tutorial, Vector/Matrix Tutorial
3451 @subsection Vector Analysis
3454 If you add two vectors, the result is a vector of the sums of the
3455 elements, taken pairwise.
3459 1: [1, 2, 3] 2: [1, 2, 3] 1: [8, 8, 3]
3463 [1,2,3] s 1 [7 6 0] s 2 +
3468 Note that we can separate the vector elements with either commas or
3469 spaces. This is true whether we are using incomplete vectors or
3470 algebraic entry. The @kbd{s 1} and @kbd{s 2} commands save these
3471 vectors so we can easily reuse them later.
3473 If you multiply two vectors, the result is the sum of the products
3474 of the elements taken pairwise. This is called the @dfn{dot product}
3488 The dot product of two vectors is equal to the product of their
3489 lengths times the cosine of the angle between them. (Here the vector
3490 is interpreted as a line from the origin @expr{(0,0,0)} to the
3491 specified point in three-dimensional space.) The @kbd{A}
3492 (absolute value) command can be used to compute the length of a
3497 3: 19 3: 19 1: 0.550782 1: 56.579
3498 2: [1, 2, 3] 2: 3.741657 . .
3499 1: [7, 6, 0] 1: 9.219544
3502 M-@key{RET} M-2 A * / I C
3507 First we recall the arguments to the dot product command, then
3508 we compute the absolute values of the top two stack entries to
3509 obtain the lengths of the vectors, then we divide the dot product
3510 by the product of the lengths to get the cosine of the angle.
3511 The inverse cosine finds that the angle between the vectors
3512 is about 56 degrees.
3514 @cindex Cross product
3515 @cindex Perpendicular vectors
3516 The @dfn{cross product} of two vectors is a vector whose length
3517 is the product of the lengths of the inputs times the sine of the
3518 angle between them, and whose direction is perpendicular to both
3519 input vectors. Unlike the dot product, the cross product is
3520 defined only for three-dimensional vectors. Let's double-check
3521 our computation of the angle using the cross product.
3525 2: [1, 2, 3] 3: [-18, 21, -8] 1: [-0.52, 0.61, -0.23] 1: 56.579
3526 1: [7, 6, 0] 2: [1, 2, 3] . .
3530 r 1 r 2 V C s 3 M-@key{RET} M-2 A * / A I S
3535 First we recall the original vectors and compute their cross product,
3536 which we also store for later reference. Now we divide the vector
3537 by the product of the lengths of the original vectors. The length of
3538 this vector should be the sine of the angle; sure enough, it is!
3540 @c [fix-ref General Mode Commands]
3541 Vector-related commands generally begin with the @kbd{v} prefix key.
3542 Some are uppercase letters and some are lowercase. To make it easier
3543 to type these commands, the shift-@kbd{V} prefix key acts the same as
3544 the @kbd{v} key. (@xref{General Mode Commands}, for a way to make all
3545 prefix keys have this property.)
3547 If we take the dot product of two perpendicular vectors we expect
3548 to get zero, since the cosine of 90 degrees is zero. Let's check
3549 that the cross product is indeed perpendicular to both inputs:
3553 2: [1, 2, 3] 1: 0 2: [7, 6, 0] 1: 0
3554 1: [-18, 21, -8] . 1: [-18, 21, -8] .
3557 r 1 r 3 * @key{DEL} r 2 r 3 *
3561 @cindex Normalizing a vector
3562 @cindex Unit vectors
3563 (@bullet{}) @strong{Exercise 1.} Given a vector on the top of the
3564 stack, what keystrokes would you use to @dfn{normalize} the
3565 vector, i.e., to reduce its length to one without changing its
3566 direction? @xref{Vector Answer 1, 1}. (@bullet{})
3568 (@bullet{}) @strong{Exercise 2.} Suppose a certain particle can be
3569 at any of several positions along a ruler. You have a list of
3570 those positions in the form of a vector, and another list of the
3571 probabilities for the particle to be at the corresponding positions.
3572 Find the average position of the particle.
3573 @xref{Vector Answer 2, 2}. (@bullet{})
3575 @node Matrix Tutorial, List Tutorial, Vector Analysis Tutorial, Vector/Matrix Tutorial
3576 @subsection Matrices
3579 A @dfn{matrix} is just a vector of vectors, all the same length.
3580 This means you can enter a matrix using nested brackets. You can
3581 also use the semicolon character to enter a matrix. We'll show
3586 1: [ [ 1, 2, 3 ] 1: [ [ 1, 2, 3 ]
3587 [ 4, 5, 6 ] ] [ 4, 5, 6 ] ]
3590 [[1 2 3] [4 5 6]] ' [1 2 3; 4 5 6] @key{RET}
3595 We'll be using this matrix again, so type @kbd{s 4} to save it now.
3597 Note that semicolons work with incomplete vectors, but they work
3598 better in algebraic entry. That's why we use the apostrophe in
3601 When two matrices are multiplied, the lefthand matrix must have
3602 the same number of columns as the righthand matrix has rows.
3603 Row @expr{i}, column @expr{j} of the result is effectively the
3604 dot product of row @expr{i} of the left matrix by column @expr{j}
3605 of the right matrix.
3607 If we try to duplicate this matrix and multiply it by itself,
3608 the dimensions are wrong and the multiplication cannot take place:
3612 1: [ [ 1, 2, 3 ] * [ [ 1, 2, 3 ]
3613 [ 4, 5, 6 ] ] [ 4, 5, 6 ] ]
3621 Though rather hard to read, this is a formula which shows the product
3622 of two matrices. The @samp{*} function, having invalid arguments, has
3623 been left in symbolic form.
3625 We can multiply the matrices if we @dfn{transpose} one of them first.
3629 2: [ [ 1, 2, 3 ] 1: [ [ 14, 32 ] 1: [ [ 17, 22, 27 ]
3630 [ 4, 5, 6 ] ] [ 32, 77 ] ] [ 22, 29, 36 ]
3631 1: [ [ 1, 4 ] . [ 27, 36, 45 ] ]
3636 U v t * U @key{TAB} *
3640 Matrix multiplication is not commutative; indeed, switching the
3641 order of the operands can even change the dimensions of the result
3642 matrix, as happened here!
3644 If you multiply a plain vector by a matrix, it is treated as a
3645 single row or column depending on which side of the matrix it is
3646 on. The result is a plain vector which should also be interpreted
3647 as a row or column as appropriate.
3651 2: [ [ 1, 2, 3 ] 1: [14, 32]
3660 Multiplying in the other order wouldn't work because the number of
3661 rows in the matrix is different from the number of elements in the
3664 (@bullet{}) @strong{Exercise 1.} Use @samp{*} to sum along the rows
3666 @texline @math{2\times3}
3668 matrix to get @expr{[6, 15]}. Now use @samp{*} to sum along the columns
3669 to get @expr{[5, 7, 9]}.
3670 @xref{Matrix Answer 1, 1}. (@bullet{})
3672 @cindex Identity matrix
3673 An @dfn{identity matrix} is a square matrix with ones along the
3674 diagonal and zeros elsewhere. It has the property that multiplication
3675 by an identity matrix, on the left or on the right, always produces
3676 the original matrix.
3680 1: [ [ 1, 2, 3 ] 2: [ [ 1, 2, 3 ] 1: [ [ 1, 2, 3 ]
3681 [ 4, 5, 6 ] ] [ 4, 5, 6 ] ] [ 4, 5, 6 ] ]
3682 . 1: [ [ 1, 0, 0 ] .
3687 r 4 v i 3 @key{RET} *
3691 If a matrix is square, it is often possible to find its @dfn{inverse},
3692 that is, a matrix which, when multiplied by the original matrix, yields
3693 an identity matrix. The @kbd{&} (reciprocal) key also computes the
3694 inverse of a matrix.
3698 1: [ [ 1, 2, 3 ] 1: [ [ -2.4, 1.2, -0.2 ]
3699 [ 4, 5, 6 ] [ 2.8, -1.4, 0.4 ]
3700 [ 7, 6, 0 ] ] [ -0.73333, 0.53333, -0.2 ] ]
3708 The vertical bar @kbd{|} @dfn{concatenates} numbers, vectors, and
3709 matrices together. Here we have used it to add a new row onto
3710 our matrix to make it square.
3712 We can multiply these two matrices in either order to get an identity.
3716 1: [ [ 1., 0., 0. ] 1: [ [ 1., 0., 0. ]
3717 [ 0., 1., 0. ] [ 0., 1., 0. ]
3718 [ 0., 0., 1. ] ] [ 0., 0., 1. ] ]
3721 M-@key{RET} * U @key{TAB} *
3725 @cindex Systems of linear equations
3726 @cindex Linear equations, systems of
3727 Matrix inverses are related to systems of linear equations in algebra.
3728 Suppose we had the following set of equations:
3742 $$ \openup1\jot \tabskip=0pt plus1fil
3743 \halign to\displaywidth{\tabskip=0pt
3744 $\hfil#$&$\hfil{}#{}$&
3745 $\hfil#$&$\hfil{}#{}$&
3746 $\hfil#$&${}#\hfil$\tabskip=0pt plus1fil\cr
3755 This can be cast into the matrix equation,
3760 [ [ 1, 2, 3 ] [ [ a ] [ [ 6 ]
3761 [ 4, 5, 6 ] * [ b ] = [ 2 ]
3762 [ 7, 6, 0 ] ] [ c ] ] [ 3 ] ]
3769 $$ \pmatrix{ 1 & 2 & 3 \cr 4 & 5 & 6 \cr 7 & 6 & 0 }
3771 \pmatrix{ a \cr b \cr c } = \pmatrix{ 6 \cr 2 \cr 3 }
3776 We can solve this system of equations by multiplying both sides by the
3777 inverse of the matrix. Calc can do this all in one step:
3781 2: [6, 2, 3] 1: [-12.6, 15.2, -3.93333]
3792 The result is the @expr{[a, b, c]} vector that solves the equations.
3793 (Dividing by a square matrix is equivalent to multiplying by its
3796 Let's verify this solution:
3800 2: [ [ 1, 2, 3 ] 1: [6., 2., 3.]
3803 1: [-12.6, 15.2, -3.93333]
3811 Note that we had to be careful about the order in which we multiplied
3812 the matrix and vector. If we multiplied in the other order, Calc would
3813 assume the vector was a row vector in order to make the dimensions
3814 come out right, and the answer would be incorrect. If you
3815 don't feel safe letting Calc take either interpretation of your
3816 vectors, use explicit
3817 @texline @math{N\times1}
3820 @texline @math{1\times N}
3822 matrices instead. In this case, you would enter the original column
3823 vector as @samp{[[6], [2], [3]]} or @samp{[6; 2; 3]}.
3825 (@bullet{}) @strong{Exercise 2.} Algebraic entry allows you to make
3826 vectors and matrices that include variables. Solve the following
3827 system of equations to get expressions for @expr{x} and @expr{y}
3828 in terms of @expr{a} and @expr{b}.
3841 $$ \eqalign{ x &+ a y = 6 \cr
3848 @xref{Matrix Answer 2, 2}. (@bullet{})
3850 @cindex Least-squares for over-determined systems
3851 @cindex Over-determined systems of equations
3852 (@bullet{}) @strong{Exercise 3.} A system of equations is ``over-determined''
3853 if it has more equations than variables. It is often the case that
3854 there are no values for the variables that will satisfy all the
3855 equations at once, but it is still useful to find a set of values
3856 which ``nearly'' satisfy all the equations. In terms of matrix equations,
3857 you can't solve @expr{A X = B} directly because the matrix @expr{A}
3858 is not square for an over-determined system. Matrix inversion works
3859 only for square matrices. One common trick is to multiply both sides
3860 on the left by the transpose of @expr{A}:
3862 @samp{trn(A)*A*X = trn(A)*B}.
3866 $A^T A \, X = A^T B$, where $A^T$ is the transpose \samp{trn(A)}.
3869 @texline @math{A^T A}
3870 @infoline @expr{trn(A)*A}
3871 is a square matrix so a solution is possible. It turns out that the
3872 @expr{X} vector you compute in this way will be a ``least-squares''
3873 solution, which can be regarded as the ``closest'' solution to the set
3874 of equations. Use Calc to solve the following over-determined
3890 $$ \openup1\jot \tabskip=0pt plus1fil
3891 \halign to\displaywidth{\tabskip=0pt
3892 $\hfil#$&$\hfil{}#{}$&
3893 $\hfil#$&$\hfil{}#{}$&
3894 $\hfil#$&${}#\hfil$\tabskip=0pt plus1fil\cr
3898 2a&+&4b&+&6c&=11 \cr}
3904 @xref{Matrix Answer 3, 3}. (@bullet{})
3906 @node List Tutorial, , Matrix Tutorial, Vector/Matrix Tutorial
3907 @subsection Vectors as Lists
3911 Although Calc has a number of features for manipulating vectors and
3912 matrices as mathematical objects, you can also treat vectors as
3913 simple lists of values. For example, we saw that the @kbd{k f}
3914 command returns a vector which is a list of the prime factors of a
3917 You can pack and unpack stack entries into vectors:
3921 3: 10 1: [10, 20, 30] 3: 10
3930 You can also build vectors out of consecutive integers, or out
3931 of many copies of a given value:
3935 1: [1, 2, 3, 4] 2: [1, 2, 3, 4] 2: [1, 2, 3, 4]
3936 . 1: 17 1: [17, 17, 17, 17]
3939 v x 4 @key{RET} 17 v b 4 @key{RET}
3943 You can apply an operator to every element of a vector using the
3948 1: [17, 34, 51, 68] 1: [289, 1156, 2601, 4624] 1: [17, 34, 51, 68]
3956 In the first step, we multiply the vector of integers by the vector
3957 of 17's elementwise. In the second step, we raise each element to
3958 the power two. (The general rule is that both operands must be
3959 vectors of the same length, or else one must be a vector and the
3960 other a plain number.) In the final step, we take the square root
3963 (@bullet{}) @strong{Exercise 1.} Compute a vector of powers of two
3965 @texline @math{2^{-4}}
3966 @infoline @expr{2^-4}
3967 to @expr{2^4}. @xref{List Answer 1, 1}. (@bullet{})
3969 You can also @dfn{reduce} a binary operator across a vector.
3970 For example, reducing @samp{*} computes the product of all the
3971 elements in the vector:
3975 1: 123123 1: [3, 7, 11, 13, 41] 1: 123123
3983 In this example, we decompose 123123 into its prime factors, then
3984 multiply those factors together again to yield the original number.
3986 We could compute a dot product ``by hand'' using mapping and
3991 2: [1, 2, 3] 1: [7, 12, 0] 1: 19
4000 Recalling two vectors from the previous section, we compute the
4001 sum of pairwise products of the elements to get the same answer
4002 for the dot product as before.
4004 A slight variant of vector reduction is the @dfn{accumulate} operation,
4005 @kbd{V U}. This produces a vector of the intermediate results from
4006 a corresponding reduction. Here we compute a table of factorials:
4010 1: [1, 2, 3, 4, 5, 6] 1: [1, 2, 6, 24, 120, 720]
4013 v x 6 @key{RET} V U *
4017 Calc allows vectors to grow as large as you like, although it gets
4018 rather slow if vectors have more than about a hundred elements.
4019 Actually, most of the time is spent formatting these large vectors
4020 for display, not calculating on them. Try the following experiment
4021 (if your computer is very fast you may need to substitute a larger
4026 1: [1, 2, 3, 4, ... 1: [2, 3, 4, 5, ...
4029 v x 500 @key{RET} 1 V M +
4033 Now press @kbd{v .} (the letter @kbd{v}, then a period) and try the
4034 experiment again. In @kbd{v .} mode, long vectors are displayed
4035 ``abbreviated'' like this:
4039 1: [1, 2, 3, ..., 500] 1: [2, 3, 4, ..., 501]
4042 v x 500 @key{RET} 1 V M +
4047 (where now the @samp{...} is actually part of the Calc display).
4048 You will find both operations are now much faster. But notice that
4049 even in @w{@kbd{v .}} mode, the full vectors are still shown in the Trail.
4050 Type @w{@kbd{t .}} to cause the trail to abbreviate as well, and try the
4051 experiment one more time. Operations on long vectors are now quite
4052 fast! (But of course if you use @kbd{t .} you will lose the ability
4053 to get old vectors back using the @kbd{t y} command.)
4055 An easy way to view a full vector when @kbd{v .} mode is active is
4056 to press @kbd{`} (back-quote) to edit the vector; editing always works
4057 with the full, unabbreviated value.
4059 @cindex Least-squares for fitting a straight line
4060 @cindex Fitting data to a line
4061 @cindex Line, fitting data to
4062 @cindex Data, extracting from buffers
4063 @cindex Columns of data, extracting
4064 As a larger example, let's try to fit a straight line to some data,
4065 using the method of least squares. (Calc has a built-in command for
4066 least-squares curve fitting, but we'll do it by hand here just to
4067 practice working with vectors.) Suppose we have the following list
4068 of values in a file we have loaded into Emacs:
4095 If you are reading this tutorial in printed form, you will find it
4096 easiest to press @kbd{M-# i} to enter the on-line Info version of
4097 the manual and find this table there. (Press @kbd{g}, then type
4098 @kbd{List Tutorial}, to jump straight to this section.)
4100 Position the cursor at the upper-left corner of this table, just
4101 to the left of the @expr{1.34}. Press @kbd{C-@@} to set the mark.
4102 (On your system this may be @kbd{C-2}, @kbd{C-@key{SPC}}, or @kbd{NUL}.)
4103 Now position the cursor to the lower-right, just after the @expr{1.354}.
4104 You have now defined this region as an Emacs ``rectangle.'' Still
4105 in the Info buffer, type @kbd{M-# r}. This command
4106 (@code{calc-grab-rectangle}) will pop you back into the Calculator, with
4107 the contents of the rectangle you specified in the form of a matrix.
4111 1: [ [ 1.34, 0.234 ]
4118 (You may wish to use @kbd{v .} mode to abbreviate the display of this
4121 We want to treat this as a pair of lists. The first step is to
4122 transpose this matrix into a pair of rows. Remember, a matrix is
4123 just a vector of vectors. So we can unpack the matrix into a pair
4124 of row vectors on the stack.
4128 1: [ [ 1.34, 1.41, 1.49, ... ] 2: [1.34, 1.41, 1.49, ... ]
4129 [ 0.234, 0.298, 0.402, ... ] ] 1: [0.234, 0.298, 0.402, ... ]
4137 Let's store these in quick variables 1 and 2, respectively.
4141 1: [1.34, 1.41, 1.49, ... ] .
4149 (Recall that @kbd{t 2} is a variant of @kbd{s 2} that removes the
4150 stored value from the stack.)
4152 In a least squares fit, the slope @expr{m} is given by the formula
4156 m = (N sum(x y) - sum(x) sum(y)) / (N sum(x^2) - sum(x)^2)
4162 $$ m = {N \sum x y - \sum x \sum y \over
4163 N \sum x^2 - \left( \sum x \right)^2} $$
4169 @texline @math{\sum x}
4170 @infoline @expr{sum(x)}
4171 represents the sum of all the values of @expr{x}. While there is an
4172 actual @code{sum} function in Calc, it's easier to sum a vector using a
4173 simple reduction. First, let's compute the four different sums that
4181 r 1 V R + t 3 r 1 2 V M ^ V R + t 4
4188 1: 13.613 1: 33.36554
4191 r 2 V R + t 5 r 1 r 2 V M * V R + t 6
4197 These are @samp{sum(x)}, @samp{sum(x^2)}, @samp{sum(y)}, and @samp{sum(x y)},
4198 respectively. (We could have used @kbd{*} to compute @samp{sum(x^2)} and
4203 These are $\sum x$, $\sum x^2$, $\sum y$, and $\sum x y$,
4204 respectively. (We could have used \kbd{*} to compute $\sum x^2$ and
4208 Finally, we also need @expr{N}, the number of data points. This is just
4209 the length of either of our lists.
4221 (That's @kbd{v} followed by a lower-case @kbd{l}.)
4223 Now we grind through the formula:
4227 1: 633.94526 2: 633.94526 1: 67.23607
4231 r 7 r 6 * r 3 r 5 * -
4238 2: 67.23607 3: 67.23607 2: 67.23607 1: 0.52141679
4239 1: 1862.0057 2: 1862.0057 1: 128.9488 .
4243 r 7 r 4 * r 3 2 ^ - / t 8
4247 That gives us the slope @expr{m}. The y-intercept @expr{b} can now
4248 be found with the simple formula,
4252 b = (sum(y) - m sum(x)) / N
4258 $$ b = {\sum y - m \sum x \over N} $$
4265 1: 13.613 2: 13.613 1: -8.09358 1: -0.425978
4269 r 5 r 8 r 3 * - r 7 / t 9
4273 Let's ``plot'' this straight line approximation,
4274 @texline @math{y \approx m x + b},
4275 @infoline @expr{m x + b},
4276 and compare it with the original data.
4280 1: [0.699, 0.735, ... ] 1: [0.273, 0.309, ... ]
4288 Notice that multiplying a vector by a constant, and adding a constant
4289 to a vector, can be done without mapping commands since these are
4290 common operations from vector algebra. As far as Calc is concerned,
4291 we've just been doing geometry in 19-dimensional space!
4293 We can subtract this vector from our original @expr{y} vector to get
4294 a feel for the error of our fit. Let's find the maximum error:
4298 1: [0.0387, 0.0112, ... ] 1: [0.0387, 0.0112, ... ] 1: 0.0897
4306 First we compute a vector of differences, then we take the absolute
4307 values of these differences, then we reduce the @code{max} function
4308 across the vector. (The @code{max} function is on the two-key sequence
4309 @kbd{f x}; because it is so common to use @code{max} in a vector
4310 operation, the letters @kbd{X} and @kbd{N} are also accepted for
4311 @code{max} and @code{min} in this context. In general, you answer
4312 the @kbd{V M} or @kbd{V R} prompt with the actual key sequence that
4313 invokes the function you want. You could have typed @kbd{V R f x} or
4314 even @kbd{V R x max @key{RET}} if you had preferred.)
4316 If your system has the GNUPLOT program, you can see graphs of your
4317 data and your straight line to see how well they match. (If you have
4318 GNUPLOT 3.0 or higher, the following instructions will work regardless
4319 of the kind of display you have. Some GNUPLOT 2.0, non-X-windows systems
4320 may require additional steps to view the graphs.)
4322 Let's start by plotting the original data. Recall the ``@var{x}'' and ``@var{y}''
4323 vectors onto the stack and press @kbd{g f}. This ``fast'' graphing
4324 command does everything you need to do for simple, straightforward
4329 2: [1.34, 1.41, 1.49, ... ]
4330 1: [0.234, 0.298, 0.402, ... ]
4337 If all goes well, you will shortly get a new window containing a graph
4338 of the data. (If not, contact your GNUPLOT or Calc installer to find
4339 out what went wrong.) In the X window system, this will be a separate
4340 graphics window. For other kinds of displays, the default is to
4341 display the graph in Emacs itself using rough character graphics.
4342 Press @kbd{q} when you are done viewing the character graphics.
4344 Next, let's add the line we got from our least-squares fit.
4346 (If you are reading this tutorial on-line while running Calc, typing
4347 @kbd{g a} may cause the tutorial to disappear from its window and be
4348 replaced by a buffer named @samp{*Gnuplot Commands*}. The tutorial
4349 will reappear when you terminate GNUPLOT by typing @kbd{g q}.)
4354 2: [1.34, 1.41, 1.49, ... ]
4355 1: [0.273, 0.309, 0.351, ... ]
4358 @key{DEL} r 0 g a g p
4362 It's not very useful to get symbols to mark the data points on this
4363 second curve; you can type @kbd{g S g p} to remove them. Type @kbd{g q}
4364 when you are done to remove the X graphics window and terminate GNUPLOT.
4366 (@bullet{}) @strong{Exercise 2.} An earlier exercise showed how to do
4367 least squares fitting to a general system of equations. Our 19 data
4368 points are really 19 equations of the form @expr{y_i = m x_i + b} for
4369 different pairs of @expr{(x_i,y_i)}. Use the matrix-transpose method
4370 to solve for @expr{m} and @expr{b}, duplicating the above result.
4371 @xref{List Answer 2, 2}. (@bullet{})
4373 @cindex Geometric mean
4374 (@bullet{}) @strong{Exercise 3.} If the input data do not form a
4375 rectangle, you can use @w{@kbd{M-# g}} (@code{calc-grab-region})
4376 to grab the data the way Emacs normally works with regions---it reads
4377 left-to-right, top-to-bottom, treating line breaks the same as spaces.
4378 Use this command to find the geometric mean of the following numbers.
4379 (The geometric mean is the @var{n}th root of the product of @var{n} numbers.)
4388 The @kbd{M-# g} command accepts numbers separated by spaces or commas,
4389 with or without surrounding vector brackets.
4390 @xref{List Answer 3, 3}. (@bullet{})
4393 As another example, a theorem about binomial coefficients tells
4394 us that the alternating sum of binomial coefficients
4395 @var{n}-choose-0 minus @var{n}-choose-1 plus @var{n}-choose-2, and so
4396 on up to @var{n}-choose-@var{n},
4397 always comes out to zero. Let's verify this
4401 As another example, a theorem about binomial coefficients tells
4402 us that the alternating sum of binomial coefficients
4403 ${n \choose 0} - {n \choose 1} + {n \choose 2} - \cdots \pm {n \choose n}$
4404 always comes out to zero. Let's verify this
4410 1: [1, 2, 3, 4, 5, 6, 7] 1: [0, 1, 2, 3, 4, 5, 6]
4420 1: [1, -6, 15, -20, 15, -6, 1] 1: 0
4423 V M ' (-1)^$ choose(6,$) @key{RET} V R +
4427 The @kbd{V M '} command prompts you to enter any algebraic expression
4428 to define the function to map over the vector. The symbol @samp{$}
4429 inside this expression represents the argument to the function.
4430 The Calculator applies this formula to each element of the vector,
4431 substituting each element's value for the @samp{$} sign(s) in turn.
4433 To define a two-argument function, use @samp{$$} for the first
4434 argument and @samp{$} for the second: @kbd{V M ' $$-$ @key{RET}} is
4435 equivalent to @kbd{V M -}. This is analogous to regular algebraic
4436 entry, where @samp{$$} would refer to the next-to-top stack entry
4437 and @samp{$} would refer to the top stack entry, and @kbd{' $$-$ @key{RET}}
4438 would act exactly like @kbd{-}.
4440 Notice that the @kbd{V M '} command has recorded two things in the
4441 trail: The result, as usual, and also a funny-looking thing marked
4442 @samp{oper} that represents the operator function you typed in.
4443 The function is enclosed in @samp{< >} brackets, and the argument is
4444 denoted by a @samp{#} sign. If there were several arguments, they
4445 would be shown as @samp{#1}, @samp{#2}, and so on. (For example,
4446 @kbd{V M ' $$-$} will put the function @samp{<#1 - #2>} on the
4447 trail.) This object is a ``nameless function''; you can use nameless
4448 @w{@samp{< >}} notation to answer the @kbd{V M '} prompt if you like.
4449 Nameless function notation has the interesting, occasionally useful
4450 property that a nameless function is not actually evaluated until
4451 it is used. For example, @kbd{V M ' $+random(2.0)} evaluates
4452 @samp{random(2.0)} once and adds that random number to all elements
4453 of the vector, but @kbd{V M ' <#+random(2.0)>} evaluates the
4454 @samp{random(2.0)} separately for each vector element.
4456 Another group of operators that are often useful with @kbd{V M} are
4457 the relational operators: @kbd{a =}, for example, compares two numbers
4458 and gives the result 1 if they are equal, or 0 if not. Similarly,
4459 @w{@kbd{a <}} checks for one number being less than another.
4461 Other useful vector operations include @kbd{v v}, to reverse a
4462 vector end-for-end; @kbd{V S}, to sort the elements of a vector
4463 into increasing order; and @kbd{v r} and @w{@kbd{v c}}, to extract
4464 one row or column of a matrix, or (in both cases) to extract one
4465 element of a plain vector. With a negative argument, @kbd{v r}
4466 and @kbd{v c} instead delete one row, column, or vector element.
4468 @cindex Divisor functions
4469 (@bullet{}) @strong{Exercise 4.} The @expr{k}th @dfn{divisor function}
4473 is the sum of the @expr{k}th powers of all the divisors of an
4474 integer @expr{n}. Figure out a method for computing the divisor
4475 function for reasonably small values of @expr{n}. As a test,
4476 the 0th and 1st divisor functions of 30 are 8 and 72, respectively.
4477 @xref{List Answer 4, 4}. (@bullet{})
4479 @cindex Square-free numbers
4480 @cindex Duplicate values in a list
4481 (@bullet{}) @strong{Exercise 5.} The @kbd{k f} command produces a
4482 list of prime factors for a number. Sometimes it is important to
4483 know that a number is @dfn{square-free}, i.e., that no prime occurs
4484 more than once in its list of prime factors. Find a sequence of
4485 keystrokes to tell if a number is square-free; your method should
4486 leave 1 on the stack if it is, or 0 if it isn't.
4487 @xref{List Answer 5, 5}. (@bullet{})
4489 @cindex Triangular lists
4490 (@bullet{}) @strong{Exercise 6.} Build a list of lists that looks
4491 like the following diagram. (You may wish to use the @kbd{v /}
4492 command to enable multi-line display of vectors.)
4501 [1, 2, 3, 4, 5, 6] ]
4506 @xref{List Answer 6, 6}. (@bullet{})
4508 (@bullet{}) @strong{Exercise 7.} Build the following list of lists.
4516 [10, 11, 12, 13, 14],
4517 [15, 16, 17, 18, 19, 20] ]
4522 @xref{List Answer 7, 7}. (@bullet{})
4524 @cindex Maximizing a function over a list of values
4525 @c [fix-ref Numerical Solutions]
4526 (@bullet{}) @strong{Exercise 8.} Compute a list of values of Bessel's
4527 @texline @math{J_1(x)}
4529 function @samp{besJ(1,x)} for @expr{x} from 0 to 5 in steps of 0.25.
4530 Find the value of @expr{x} (from among the above set of values) for
4531 which @samp{besJ(1,x)} is a maximum. Use an ``automatic'' method,
4532 i.e., just reading along the list by hand to find the largest value
4533 is not allowed! (There is an @kbd{a X} command which does this kind
4534 of thing automatically; @pxref{Numerical Solutions}.)
4535 @xref{List Answer 8, 8}. (@bullet{})
4537 @cindex Digits, vectors of
4538 (@bullet{}) @strong{Exercise 9.} You are given an integer in the range
4539 @texline @math{0 \le N < 10^m}
4540 @infoline @expr{0 <= N < 10^m}
4541 for @expr{m=12} (i.e., an integer of less than
4542 twelve digits). Convert this integer into a vector of @expr{m}
4543 digits, each in the range from 0 to 9. In vector-of-digits notation,
4544 add one to this integer to produce a vector of @expr{m+1} digits
4545 (since there could be a carry out of the most significant digit).
4546 Convert this vector back into a regular integer. A good integer
4547 to try is 25129925999. @xref{List Answer 9, 9}. (@bullet{})
4549 (@bullet{}) @strong{Exercise 10.} Your friend Joe tried to use
4550 @kbd{V R a =} to test if all numbers in a list were equal. What
4551 happened? How would you do this test? @xref{List Answer 10, 10}. (@bullet{})
4553 (@bullet{}) @strong{Exercise 11.} The area of a circle of radius one
4554 is @cpi{}. The area of the
4555 @texline @math{2\times2}
4557 square that encloses that circle is 4. So if we throw @var{n} darts at
4558 random points in the square, about @cpiover{4} of them will land inside
4559 the circle. This gives us an entertaining way to estimate the value of
4560 @cpi{}. The @w{@kbd{k r}}
4561 command picks a random number between zero and the value on the stack.
4562 We could get a random floating-point number between @mathit{-1} and 1 by typing
4563 @w{@kbd{2.0 k r 1 -}}. Build a vector of 100 random @expr{(x,y)} points in
4564 this square, then use vector mapping and reduction to count how many
4565 points lie inside the unit circle. Hint: Use the @kbd{v b} command.
4566 @xref{List Answer 11, 11}. (@bullet{})
4568 @cindex Matchstick problem
4569 (@bullet{}) @strong{Exercise 12.} The @dfn{matchstick problem} provides
4570 another way to calculate @cpi{}. Say you have an infinite field
4571 of vertical lines with a spacing of one inch. Toss a one-inch matchstick
4572 onto the field. The probability that the matchstick will land crossing
4573 a line turns out to be
4574 @texline @math{2/\pi}.
4575 @infoline @expr{2/pi}.
4576 Toss 100 matchsticks to estimate @cpi{}. (If you want still more fun,
4577 the probability that the GCD (@w{@kbd{k g}}) of two large integers is
4579 @texline @math{6/\pi^2}.
4580 @infoline @expr{6/pi^2}.
4581 That provides yet another way to estimate @cpi{}.)
4582 @xref{List Answer 12, 12}. (@bullet{})
4584 (@bullet{}) @strong{Exercise 13.} An algebraic entry of a string in
4585 double-quote marks, @samp{"hello"}, creates a vector of the numerical
4586 (ASCII) codes of the characters (here, @expr{[104, 101, 108, 108, 111]}).
4587 Sometimes it is convenient to compute a @dfn{hash code} of a string,
4588 which is just an integer that represents the value of that string.
4589 Two equal strings have the same hash code; two different strings
4590 @dfn{probably} have different hash codes. (For example, Calc has
4591 over 400 function names, but Emacs can quickly find the definition for
4592 any given name because it has sorted the functions into ``buckets'' by
4593 their hash codes. Sometimes a few names will hash into the same bucket,
4594 but it is easier to search among a few names than among all the names.)
4595 One popular hash function is computed as follows: First set @expr{h = 0}.
4596 Then, for each character from the string in turn, set @expr{h = 3h + c_i}
4597 where @expr{c_i} is the character's ASCII code. If we have 511 buckets,
4598 we then take the hash code modulo 511 to get the bucket number. Develop a
4599 simple command or commands for converting string vectors into hash codes.
4600 The hash code for @samp{"Testing, 1, 2, 3"} is 1960915098, which modulo
4601 511 is 121. @xref{List Answer 13, 13}. (@bullet{})
4603 (@bullet{}) @strong{Exercise 14.} The @kbd{H V R} and @kbd{H V U}
4604 commands do nested function evaluations. @kbd{H V U} takes a starting
4605 value and a number of steps @var{n} from the stack; it then applies the
4606 function you give to the starting value 0, 1, 2, up to @var{n} times
4607 and returns a vector of the results. Use this command to create a
4608 ``random walk'' of 50 steps. Start with the two-dimensional point
4609 @expr{(0,0)}; then take one step a random distance between @mathit{-1} and 1
4610 in both @expr{x} and @expr{y}; then take another step, and so on. Use the
4611 @kbd{g f} command to display this random walk. Now modify your random
4612 walk to walk a unit distance, but in a random direction, at each step.
4613 (Hint: The @code{sincos} function returns a vector of the cosine and
4614 sine of an angle.) @xref{List Answer 14, 14}. (@bullet{})
4616 @node Types Tutorial, Algebra Tutorial, Vector/Matrix Tutorial, Tutorial
4617 @section Types Tutorial
4620 Calc understands a variety of data types as well as simple numbers.
4621 In this section, we'll experiment with each of these types in turn.
4623 The numbers we've been using so far have mainly been either @dfn{integers}
4624 or @dfn{floats}. We saw that floats are usually a good approximation to
4625 the mathematical concept of real numbers, but they are only approximations
4626 and are susceptible to roundoff error. Calc also supports @dfn{fractions},
4627 which can exactly represent any rational number.
4631 1: 3628800 2: 3628800 1: 518400:7 1: 518414:7 1: 7:518414
4635 10 ! 49 @key{RET} : 2 + &
4640 The @kbd{:} command divides two integers to get a fraction; @kbd{/}
4641 would normally divide integers to get a floating-point result.
4642 Notice we had to type @key{RET} between the @kbd{49} and the @kbd{:}
4643 since the @kbd{:} would otherwise be interpreted as part of a
4644 fraction beginning with 49.
4646 You can convert between floating-point and fractional format using
4647 @kbd{c f} and @kbd{c F}:
4651 1: 1.35027217629e-5 1: 7:518414
4658 The @kbd{c F} command replaces a floating-point number with the
4659 ``simplest'' fraction whose floating-point representation is the
4660 same, to within the current precision.
4664 1: 3.14159265359 1: 1146408:364913 1: 3.1416 1: 355:113
4667 P c F @key{DEL} p 5 @key{RET} P c F
4671 (@bullet{}) @strong{Exercise 1.} A calculation has produced the
4672 result 1.26508260337. You suspect it is the square root of the
4673 product of @cpi{} and some rational number. Is it? (Be sure
4674 to allow for roundoff error!) @xref{Types Answer 1, 1}. (@bullet{})
4676 @dfn{Complex numbers} can be stored in both rectangular and polar form.
4680 1: -9 1: (0, 3) 1: (3; 90.) 1: (6; 90.) 1: (2.4495; 45.)
4688 The square root of @mathit{-9} is by default rendered in rectangular form
4689 (@w{@expr{0 + 3i}}), but we can convert it to polar form (3 with a
4690 phase angle of 90 degrees). All the usual arithmetic and scientific
4691 operations are defined on both types of complex numbers.
4693 Another generalized kind of number is @dfn{infinity}. Infinity
4694 isn't really a number, but it can sometimes be treated like one.
4695 Calc uses the symbol @code{inf} to represent positive infinity,
4696 i.e., a value greater than any real number. Naturally, you can
4697 also write @samp{-inf} for minus infinity, a value less than any
4698 real number. The word @code{inf} can only be input using
4703 2: inf 2: -inf 2: -inf 2: -inf 1: nan
4704 1: -17 1: -inf 1: -inf 1: inf .
4707 ' inf @key{RET} 17 n * @key{RET} 72 + A +
4712 Since infinity is infinitely large, multiplying it by any finite
4713 number (like @mathit{-17}) has no effect, except that since @mathit{-17}
4714 is negative, it changes a plus infinity to a minus infinity.
4715 (``A huge positive number, multiplied by @mathit{-17}, yields a huge
4716 negative number.'') Adding any finite number to infinity also
4717 leaves it unchanged. Taking an absolute value gives us plus
4718 infinity again. Finally, we add this plus infinity to the minus
4719 infinity we had earlier. If you work it out, you might expect
4720 the answer to be @mathit{-72} for this. But the 72 has been completely
4721 lost next to the infinities; by the time we compute @w{@samp{inf - inf}}
4722 the finite difference between them, if any, is undetectable.
4723 So we say the result is @dfn{indeterminate}, which Calc writes
4724 with the symbol @code{nan} (for Not A Number).
4726 Dividing by zero is normally treated as an error, but you can get
4727 Calc to write an answer in terms of infinity by pressing @kbd{m i}
4728 to turn on Infinite mode.
4732 3: nan 2: nan 2: nan 2: nan 1: nan
4733 2: 1 1: 1 / 0 1: uinf 1: uinf .
4737 1 @key{RET} 0 / m i U / 17 n * +
4742 Dividing by zero normally is left unevaluated, but after @kbd{m i}
4743 it instead gives an infinite result. The answer is actually
4744 @code{uinf}, ``undirected infinity.'' If you look at a graph of
4745 @expr{1 / x} around @w{@expr{x = 0}}, you'll see that it goes toward
4746 plus infinity as you approach zero from above, but toward minus
4747 infinity as you approach from below. Since we said only @expr{1 / 0},
4748 Calc knows that the answer is infinite but not in which direction.
4749 That's what @code{uinf} means. Notice that multiplying @code{uinf}
4750 by a negative number still leaves plain @code{uinf}; there's no
4751 point in saying @samp{-uinf} because the sign of @code{uinf} is
4752 unknown anyway. Finally, we add @code{uinf} to our @code{nan},
4753 yielding @code{nan} again. It's easy to see that, because
4754 @code{nan} means ``totally unknown'' while @code{uinf} means
4755 ``unknown sign but known to be infinite,'' the more mysterious
4756 @code{nan} wins out when it is combined with @code{uinf}, or, for
4757 that matter, with anything else.
4759 (@bullet{}) @strong{Exercise 2.} Predict what Calc will answer
4760 for each of these formulas: @samp{inf / inf}, @samp{exp(inf)},
4761 @samp{exp(-inf)}, @samp{sqrt(-inf)}, @samp{sqrt(uinf)},
4762 @samp{abs(uinf)}, @samp{ln(0)}.
4763 @xref{Types Answer 2, 2}. (@bullet{})
4765 (@bullet{}) @strong{Exercise 3.} We saw that @samp{inf - inf = nan},
4766 which stands for an unknown value. Can @code{nan} stand for
4767 a complex number? Can it stand for infinity?
4768 @xref{Types Answer 3, 3}. (@bullet{})
4770 @dfn{HMS forms} represent a value in terms of hours, minutes, and
4775 1: 2@@ 30' 0" 1: 3@@ 30' 0" 2: 3@@ 30' 0" 1: 2.
4776 . . 1: 1@@ 45' 0." .
4779 2@@ 30' @key{RET} 1 + @key{RET} 2 / /
4783 HMS forms can also be used to hold angles in degrees, minutes, and
4788 1: 0.5 1: 26.56505 1: 26@@ 33' 54.18" 1: 0.44721
4796 First we convert the inverse tangent of 0.5 to degrees-minutes-seconds
4797 form, then we take the sine of that angle. Note that the trigonometric
4798 functions will accept HMS forms directly as input.
4801 (@bullet{}) @strong{Exercise 4.} The Beatles' @emph{Abbey Road} is
4802 47 minutes and 26 seconds long, and contains 17 songs. What is the
4803 average length of a song on @emph{Abbey Road}? If the Extended Disco
4804 Version of @emph{Abbey Road} added 20 seconds to the length of each
4805 song, how long would the album be? @xref{Types Answer 4, 4}. (@bullet{})
4807 A @dfn{date form} represents a date, or a date and time. Dates must
4808 be entered using algebraic entry. Date forms are surrounded by
4809 @samp{< >} symbols; most standard formats for dates are recognized.
4813 2: <Sun Jan 13, 1991> 1: 2.25
4814 1: <6:00pm Thu Jan 10, 1991> .
4817 ' <13 Jan 1991>, <1/10/91, 6pm> @key{RET} -
4822 In this example, we enter two dates, then subtract to find the
4823 number of days between them. It is also possible to add an
4824 HMS form or a number (of days) to a date form to get another
4829 1: <4:45:59pm Mon Jan 14, 1991> 1: <2:50:59am Thu Jan 17, 1991>
4836 @c [fix-ref Date Arithmetic]
4838 The @kbd{t N} (``now'') command pushes the current date and time on the
4839 stack; then we add two days, ten hours and five minutes to the date and
4840 time. Other date-and-time related commands include @kbd{t J}, which
4841 does Julian day conversions, @kbd{t W}, which finds the beginning of
4842 the week in which a date form lies, and @kbd{t I}, which increments a
4843 date by one or several months. @xref{Date Arithmetic}, for more.
4845 (@bullet{}) @strong{Exercise 5.} How many days until the next
4846 Friday the 13th? @xref{Types Answer 5, 5}. (@bullet{})
4848 (@bullet{}) @strong{Exercise 6.} How many leap years will there be
4849 between now and the year 10001 A.D.? @xref{Types Answer 6, 6}. (@bullet{})
4851 @cindex Slope and angle of a line
4852 @cindex Angle and slope of a line
4853 An @dfn{error form} represents a mean value with an attached standard
4854 deviation, or error estimate. Suppose our measurements indicate that
4855 a certain telephone pole is about 30 meters away, with an estimated
4856 error of 1 meter, and 8 meters tall, with an estimated error of 0.2
4857 meters. What is the slope of a line from here to the top of the
4858 pole, and what is the equivalent angle in degrees?
4862 1: 8 +/- 0.2 2: 8 +/- 0.2 1: 0.266 +/- 0.011 1: 14.93 +/- 0.594
4866 8 p .2 @key{RET} 30 p 1 / I T
4871 This means that the angle is about 15 degrees, and, assuming our
4872 original error estimates were valid standard deviations, there is about
4873 a 60% chance that the result is correct within 0.59 degrees.
4875 @cindex Torus, volume of
4876 (@bullet{}) @strong{Exercise 7.} The volume of a torus (a donut shape) is
4877 @texline @math{2 \pi^2 R r^2}
4878 @infoline @w{@expr{2 pi^2 R r^2}}
4879 where @expr{R} is the radius of the circle that
4880 defines the center of the tube and @expr{r} is the radius of the tube
4881 itself. Suppose @expr{R} is 20 cm and @expr{r} is 4 cm, each known to
4882 within 5 percent. What is the volume and the relative uncertainty of
4883 the volume? @xref{Types Answer 7, 7}. (@bullet{})
4885 An @dfn{interval form} represents a range of values. While an
4886 error form is best for making statistical estimates, intervals give
4887 you exact bounds on an answer. Suppose we additionally know that
4888 our telephone pole is definitely between 28 and 31 meters away,
4889 and that it is between 7.7 and 8.1 meters tall.
4893 1: [7.7 .. 8.1] 2: [7.7 .. 8.1] 1: [0.24 .. 0.28] 1: [13.9 .. 16.1]
4897 [ 7.7 .. 8.1 ] [ 28 .. 31 ] / I T
4902 If our bounds were correct, then the angle to the top of the pole
4903 is sure to lie in the range shown.
4905 The square brackets around these intervals indicate that the endpoints
4906 themselves are allowable values. In other words, the distance to the
4907 telephone pole is between 28 and 31, @emph{inclusive}. You can also
4908 make an interval that is exclusive of its endpoints by writing
4909 parentheses instead of square brackets. You can even make an interval
4910 which is inclusive (``closed'') on one end and exclusive (``open'') on
4915 1: [1 .. 10) 1: (0.1 .. 1] 2: (0.1 .. 1] 1: (0.2 .. 3)
4919 [ 1 .. 10 ) & [ 2 .. 3 ) *
4924 The Calculator automatically keeps track of which end values should
4925 be open and which should be closed. You can also make infinite or
4926 semi-infinite intervals by using @samp{-inf} or @samp{inf} for one
4929 (@bullet{}) @strong{Exercise 8.} What answer would you expect from
4930 @samp{@w{1 /} @w{(0 .. 10)}}? What about @samp{@w{1 /} @w{(-10 .. 0)}}? What
4931 about @samp{@w{1 /} @w{[0 .. 10]}} (where the interval actually includes
4932 zero)? What about @samp{@w{1 /} @w{(-10 .. 10)}}?
4933 @xref{Types Answer 8, 8}. (@bullet{})
4935 (@bullet{}) @strong{Exercise 9.} Two easy ways of squaring a number
4936 are @kbd{@key{RET} *} and @w{@kbd{2 ^}}. Normally these produce the same
4937 answer. Would you expect this still to hold true for interval forms?
4938 If not, which of these will result in a larger interval?
4939 @xref{Types Answer 9, 9}. (@bullet{})
4941 A @dfn{modulo form} is used for performing arithmetic modulo @var{m}.
4942 For example, arithmetic involving time is generally done modulo 12
4947 1: 17 mod 24 1: 3 mod 24 1: 21 mod 24 1: 9 mod 24
4950 17 M 24 @key{RET} 10 + n 5 /
4955 In this last step, Calc has divided by 5 modulo 24; i.e., it has found a
4956 new number which, when multiplied by 5 modulo 24, produces the original
4957 number, 21. If @var{m} is prime and the divisor is not a multiple of
4958 @var{m}, it is always possible to find such a number. For non-prime
4959 @var{m} like 24, it is only sometimes possible.
4963 1: 10 mod 24 1: 16 mod 24 1: 1000000... 1: 16
4966 10 M 24 @key{RET} 100 ^ 10 @key{RET} 100 ^ 24 %
4971 These two calculations get the same answer, but the first one is
4972 much more efficient because it avoids the huge intermediate value
4973 that arises in the second one.
4975 @cindex Fermat, primality test of
4976 (@bullet{}) @strong{Exercise 10.} A theorem of Pierre de Fermat
4978 @texline @w{@math{x^{n-1} \bmod n = 1}}
4979 @infoline @expr{x^(n-1) mod n = 1}
4980 if @expr{n} is a prime number and @expr{x} is an integer less than
4981 @expr{n}. If @expr{n} is @emph{not} a prime number, this will
4982 @emph{not} be true for most values of @expr{x}. Thus we can test
4983 informally if a number is prime by trying this formula for several
4984 values of @expr{x}. Use this test to tell whether the following numbers
4985 are prime: 811749613, 15485863. @xref{Types Answer 10, 10}. (@bullet{})
4987 It is possible to use HMS forms as parts of error forms, intervals,
4988 modulo forms, or as the phase part of a polar complex number.
4989 For example, the @code{calc-time} command pushes the current time
4990 of day on the stack as an HMS/modulo form.
4994 1: 17@@ 34' 45" mod 24@@ 0' 0" 1: 6@@ 22' 15" mod 24@@ 0' 0"
5002 This calculation tells me it is six hours and 22 minutes until midnight.
5004 (@bullet{}) @strong{Exercise 11.} A rule of thumb is that one year
5006 @texline @math{\pi \times 10^7}
5007 @infoline @w{@expr{pi * 10^7}}
5008 seconds. What time will it be that many seconds from right now?
5009 @xref{Types Answer 11, 11}. (@bullet{})
5011 (@bullet{}) @strong{Exercise 12.} You are preparing to order packaging
5012 for the CD release of the Extended Disco Version of @emph{Abbey Road}.
5013 You are told that the songs will actually be anywhere from 20 to 60
5014 seconds longer than the originals. One CD can hold about 75 minutes
5015 of music. Should you order single or double packages?
5016 @xref{Types Answer 12, 12}. (@bullet{})
5018 Another kind of data the Calculator can manipulate is numbers with
5019 @dfn{units}. This isn't strictly a new data type; it's simply an
5020 application of algebraic expressions, where we use variables with
5021 suggestive names like @samp{cm} and @samp{in} to represent units
5022 like centimeters and inches.
5026 1: 2 in 1: 5.08 cm 1: 0.027778 fath 1: 0.0508 m
5029 ' 2in @key{RET} u c cm @key{RET} u c fath @key{RET} u b
5034 We enter the quantity ``2 inches'' (actually an algebraic expression
5035 which means two times the variable @samp{in}), then we convert it
5036 first to centimeters, then to fathoms, then finally to ``base'' units,
5037 which in this case means meters.
5041 1: 9 acre 1: 3 sqrt(acre) 1: 190.84 m 1: 190.84 m + 30 cm
5044 ' 9 acre @key{RET} Q u s ' $+30 cm @key{RET}
5051 1: 191.14 m 1: 36536.3046 m^2 1: 365363046 cm^2
5059 Since units expressions are really just formulas, taking the square
5060 root of @samp{acre} is undefined. After all, @code{acre} might be an
5061 algebraic variable that you will someday assign a value. We use the
5062 ``units-simplify'' command to simplify the expression with variables
5063 being interpreted as unit names.
5065 In the final step, we have converted not to a particular unit, but to a
5066 units system. The ``cgs'' system uses centimeters instead of meters
5067 as its standard unit of length.
5069 There is a wide variety of units defined in the Calculator.
5073 1: 55 mph 1: 88.5139 kph 1: 88.5139 km / hr 1: 8.201407e-8 c
5076 ' 55 mph @key{RET} u c kph @key{RET} u c km/hr @key{RET} u c c @key{RET}
5081 We express a speed first in miles per hour, then in kilometers per
5082 hour, then again using a slightly more explicit notation, then
5083 finally in terms of fractions of the speed of light.
5085 Temperature conversions are a bit more tricky. There are two ways to
5086 interpret ``20 degrees Fahrenheit''---it could mean an actual
5087 temperature, or it could mean a change in temperature. For normal
5088 units there is no difference, but temperature units have an offset
5089 as well as a scale factor and so there must be two explicit commands
5094 1: 20 degF 1: 11.1111 degC 1: -20:3 degC 1: -6.666 degC
5097 ' 20 degF @key{RET} u c degC @key{RET} U u t degC @key{RET} c f
5102 First we convert a change of 20 degrees Fahrenheit into an equivalent
5103 change in degrees Celsius (or Centigrade). Then, we convert the
5104 absolute temperature 20 degrees Fahrenheit into Celsius. Since
5105 this comes out as an exact fraction, we then convert to floating-point
5106 for easier comparison with the other result.
5108 For simple unit conversions, you can put a plain number on the stack.
5109 Then @kbd{u c} and @kbd{u t} will prompt for both old and new units.
5110 When you use this method, you're responsible for remembering which
5111 numbers are in which units:
5115 1: 55 1: 88.5139 1: 8.201407e-8
5118 55 u c mph @key{RET} kph @key{RET} u c km/hr @key{RET} c @key{RET}
5122 To see a complete list of built-in units, type @kbd{u v}. Press
5123 @w{@kbd{M-# c}} again to re-enter the Calculator when you're done looking
5126 (@bullet{}) @strong{Exercise 13.} How many seconds are there really
5127 in a year? @xref{Types Answer 13, 13}. (@bullet{})
5129 @cindex Speed of light
5130 (@bullet{}) @strong{Exercise 14.} Supercomputer designs are limited by
5131 the speed of light (and of electricity, which is nearly as fast).
5132 Suppose a computer has a 4.1 ns (nanosecond) clock cycle, and its
5133 cabinet is one meter across. Is speed of light going to be a
5134 significant factor in its design? @xref{Types Answer 14, 14}. (@bullet{})
5136 (@bullet{}) @strong{Exercise 15.} Sam the Slug normally travels about
5137 five yards in an hour. He has obtained a supply of Power Pills; each
5138 Power Pill he eats doubles his speed. How many Power Pills can he
5139 swallow and still travel legally on most US highways?
5140 @xref{Types Answer 15, 15}. (@bullet{})
5142 @node Algebra Tutorial, Programming Tutorial, Types Tutorial, Tutorial
5143 @section Algebra and Calculus Tutorial
5146 This section shows how to use Calc's algebra facilities to solve
5147 equations, do simple calculus problems, and manipulate algebraic
5151 * Basic Algebra Tutorial::
5152 * Rewrites Tutorial::
5155 @node Basic Algebra Tutorial, Rewrites Tutorial, Algebra Tutorial, Algebra Tutorial
5156 @subsection Basic Algebra
5159 If you enter a formula in Algebraic mode that refers to variables,
5160 the formula itself is pushed onto the stack. You can manipulate
5161 formulas as regular data objects.
5165 1: 2 x^2 - 6 1: 6 - 2 x^2 1: (6 - 2 x^2) (3 x^2 + y)
5168 ' 2x^2-6 @key{RET} n ' 3x^2+y @key{RET} *
5172 (@bullet{}) @strong{Exercise 1.} Do @kbd{' x @key{RET} Q 2 ^} and
5173 @kbd{' x @key{RET} 2 ^ Q} both wind up with the same result (@samp{x})?
5174 Why or why not? @xref{Algebra Answer 1, 1}. (@bullet{})
5176 There are also commands for doing common algebraic operations on
5177 formulas. Continuing with the formula from the last example,
5181 1: 18 x^2 + 6 y - 6 x^4 - 2 x^2 y 1: (18 - 2 y) x^2 - 6 x^4 + 6 y
5189 First we ``expand'' using the distributive law, then we ``collect''
5190 terms involving like powers of @expr{x}.
5192 Let's find the value of this expression when @expr{x} is 2 and @expr{y}
5197 1: 17 x^2 - 6 x^4 + 3 1: -25
5200 1:2 s l y @key{RET} 2 s l x @key{RET}
5205 The @kbd{s l} command means ``let''; it takes a number from the top of
5206 the stack and temporarily assigns it as the value of the variable
5207 you specify. It then evaluates (as if by the @kbd{=} key) the
5208 next expression on the stack. After this command, the variable goes
5209 back to its original value, if any.
5211 (An earlier exercise in this tutorial involved storing a value in the
5212 variable @code{x}; if this value is still there, you will have to
5213 unstore it with @kbd{s u x @key{RET}} before the above example will work
5216 @cindex Maximum of a function using Calculus
5217 Let's find the maximum value of our original expression when @expr{y}
5218 is one-half and @expr{x} ranges over all possible values. We can
5219 do this by taking the derivative with respect to @expr{x} and examining
5220 values of @expr{x} for which the derivative is zero. If the second
5221 derivative of the function at that value of @expr{x} is negative,
5222 the function has a local maximum there.
5226 1: 17 x^2 - 6 x^4 + 3 1: 34 x - 24 x^3
5229 U @key{DEL} s 1 a d x @key{RET} s 2
5234 Well, the derivative is clearly zero when @expr{x} is zero. To find
5235 the other root(s), let's divide through by @expr{x} and then solve:
5239 1: (34 x - 24 x^3) / x 1: 34 x / x - 24 x^3 / x 1: 34 - 24 x^2
5242 ' x @key{RET} / a x a s
5249 1: 34 - 24 x^2 = 0 1: x = 1.19023
5252 0 a = s 3 a S x @key{RET}
5257 Notice the use of @kbd{a s} to ``simplify'' the formula. When the
5258 default algebraic simplifications don't do enough, you can use
5259 @kbd{a s} to tell Calc to spend more time on the job.
5261 Now we compute the second derivative and plug in our values of @expr{x}:
5265 1: 1.19023 2: 1.19023 2: 1.19023
5266 . 1: 34 x - 24 x^3 1: 34 - 72 x^2
5269 a . r 2 a d x @key{RET} s 4
5274 (The @kbd{a .} command extracts just the righthand side of an equation.
5275 Another method would have been to use @kbd{v u} to unpack the equation
5276 @w{@samp{x = 1.19}} to @samp{x} and @samp{1.19}, then use @kbd{M-- M-2 @key{DEL}}
5277 to delete the @samp{x}.)
5281 2: 34 - 72 x^2 1: -68. 2: 34 - 72 x^2 1: 34
5285 @key{TAB} s l x @key{RET} U @key{DEL} 0 s l x @key{RET}
5290 The first of these second derivatives is negative, so we know the function
5291 has a maximum value at @expr{x = 1.19023}. (The function also has a
5292 local @emph{minimum} at @expr{x = 0}.)
5294 When we solved for @expr{x}, we got only one value even though
5295 @expr{34 - 24 x^2 = 0} is a quadratic equation that ought to have
5296 two solutions. The reason is that @w{@kbd{a S}} normally returns a
5297 single ``principal'' solution. If it needs to come up with an
5298 arbitrary sign (as occurs in the quadratic formula) it picks @expr{+}.
5299 If it needs an arbitrary integer, it picks zero. We can get a full
5300 solution by pressing @kbd{H} (the Hyperbolic flag) before @kbd{a S}.
5304 1: 34 - 24 x^2 = 0 1: x = 1.19023 s1 1: x = -1.19023
5307 r 3 H a S x @key{RET} s 5 1 n s l s1 @key{RET}
5312 Calc has invented the variable @samp{s1} to represent an unknown sign;
5313 it is supposed to be either @mathit{+1} or @mathit{-1}. Here we have used
5314 the ``let'' command to evaluate the expression when the sign is negative.
5315 If we plugged this into our second derivative we would get the same,
5316 negative, answer, so @expr{x = -1.19023} is also a maximum.
5318 To find the actual maximum value, we must plug our two values of @expr{x}
5319 into the original formula.
5323 2: 17 x^2 - 6 x^4 + 3 1: 24.08333 s1^2 - 12.04166 s1^4 + 3
5327 r 1 r 5 s l @key{RET}
5332 (Here we see another way to use @kbd{s l}; if its input is an equation
5333 with a variable on the lefthand side, then @kbd{s l} treats the equation
5334 like an assignment to that variable if you don't give a variable name.)
5336 It's clear that this will have the same value for either sign of
5337 @code{s1}, but let's work it out anyway, just for the exercise:
5341 2: [-1, 1] 1: [15.04166, 15.04166]
5342 1: 24.08333 s1^2 ... .
5345 [ 1 n , 1 ] @key{TAB} V M $ @key{RET}
5350 Here we have used a vector mapping operation to evaluate the function
5351 at several values of @samp{s1} at once. @kbd{V M $} is like @kbd{V M '}
5352 except that it takes the formula from the top of the stack. The
5353 formula is interpreted as a function to apply across the vector at the
5354 next-to-top stack level. Since a formula on the stack can't contain
5355 @samp{$} signs, Calc assumes the variables in the formula stand for
5356 different arguments. It prompts you for an @dfn{argument list}, giving
5357 the list of all variables in the formula in alphabetical order as the
5358 default list. In this case the default is @samp{(s1)}, which is just
5359 what we want so we simply press @key{RET} at the prompt.
5361 If there had been several different values, we could have used
5362 @w{@kbd{V R X}} to find the global maximum.
5364 Calc has a built-in @kbd{a P} command that solves an equation using
5365 @w{@kbd{H a S}} and returns a vector of all the solutions. It simply
5366 automates the job we just did by hand. Applied to our original
5367 cubic polynomial, it would produce the vector of solutions
5368 @expr{[1.19023, -1.19023, 0]}. (There is also an @kbd{a X} command
5369 which finds a local maximum of a function. It uses a numerical search
5370 method rather than examining the derivatives, and thus requires you
5371 to provide some kind of initial guess to show it where to look.)
5373 (@bullet{}) @strong{Exercise 2.} Given a vector of the roots of a
5374 polynomial (such as the output of an @kbd{a P} command), what
5375 sequence of commands would you use to reconstruct the original
5376 polynomial? (The answer will be unique to within a constant
5377 multiple; choose the solution where the leading coefficient is one.)
5378 @xref{Algebra Answer 2, 2}. (@bullet{})
5380 The @kbd{m s} command enables Symbolic mode, in which formulas
5381 like @samp{sqrt(5)} that can't be evaluated exactly are left in
5382 symbolic form rather than giving a floating-point approximate answer.
5383 Fraction mode (@kbd{m f}) is also useful when doing algebra.
5387 2: 34 x - 24 x^3 2: 34 x - 24 x^3
5388 1: 34 x - 24 x^3 1: [sqrt(51) / 6, sqrt(51) / -6, 0]
5391 r 2 @key{RET} m s m f a P x @key{RET}
5395 One more mode that makes reading formulas easier is Big mode.
5404 1: [-----, -----, 0]
5413 Here things like powers, square roots, and quotients and fractions
5414 are displayed in a two-dimensional pictorial form. Calc has other
5415 language modes as well, such as C mode, FORTRAN mode, @TeX{} mode
5420 2: 34*x - 24*pow(x, 3) 2: 34*x - 24*x**3
5421 1: @{sqrt(51) / 6, sqrt(51) / -6, 0@} 1: /sqrt(51) / 6, sqrt(51) / -6, 0/
5432 2: [@{\sqrt@{51@} \over 6@}, @{\sqrt@{51@} \over -6@}, 0]
5433 1: @{2 \over 3@} \sqrt@{5@}
5436 d T ' 2 \sqrt@{5@} \over 3 @key{RET}
5441 As you can see, language modes affect both entry and display of
5442 formulas. They affect such things as the names used for built-in
5443 functions, the set of arithmetic operators and their precedences,
5444 and notations for vectors and matrices.
5446 Notice that @samp{sqrt(51)} may cause problems with older
5447 implementations of C and FORTRAN, which would require something more
5448 like @samp{sqrt(51.0)}. It is always wise to check over the formulas
5449 produced by the various language modes to make sure they are fully
5452 Type @kbd{m s}, @kbd{m f}, and @kbd{d N} to reset these modes. (You
5453 may prefer to remain in Big mode, but all the examples in the tutorial
5454 are shown in normal mode.)
5456 @cindex Area under a curve
5457 What is the area under the portion of this curve from @expr{x = 1} to @expr{2}?
5458 This is simply the integral of the function:
5462 1: 17 x^2 - 6 x^4 + 3 1: 5.6666 x^3 - 1.2 x^5 + 3 x
5470 We want to evaluate this at our two values for @expr{x} and subtract.
5471 One way to do it is again with vector mapping and reduction:
5475 2: [2, 1] 1: [12.93333, 7.46666] 1: 5.46666
5476 1: 5.6666 x^3 ... . .
5478 [ 2 , 1 ] @key{TAB} V M $ @key{RET} V R -
5482 (@bullet{}) @strong{Exercise 3.} Find the integral from 1 to @expr{y}
5484 @texline @math{x \sin \pi x}
5485 @infoline @w{@expr{x sin(pi x)}}
5486 (where the sine is calculated in radians). Find the values of the
5487 integral for integers @expr{y} from 1 to 5. @xref{Algebra Answer 3,
5490 Calc's integrator can do many simple integrals symbolically, but many
5491 others are beyond its capabilities. Suppose we wish to find the area
5493 @texline @math{\sin x \ln x}
5494 @infoline @expr{sin(x) ln(x)}
5495 over the same range of @expr{x}. If you entered this formula and typed
5496 @kbd{a i x @key{RET}} (don't bother to try this), Calc would work for a
5497 long time but would be unable to find a solution. In fact, there is no
5498 closed-form solution to this integral. Now what do we do?
5500 @cindex Integration, numerical
5501 @cindex Numerical integration
5502 One approach would be to do the integral numerically. It is not hard
5503 to do this by hand using vector mapping and reduction. It is rather
5504 slow, though, since the sine and logarithm functions take a long time.
5505 We can save some time by reducing the working precision.
5509 3: 10 1: [1, 1.1, 1.2, ... , 1.8, 1.9]
5514 10 @key{RET} 1 @key{RET} .1 @key{RET} C-u v x
5519 (Note that we have used the extended version of @kbd{v x}; we could
5520 also have used plain @kbd{v x} as follows: @kbd{v x 10 @key{RET} 9 + .1 *}.)
5524 2: [1, 1.1, ... ] 1: [0., 0.084941, 0.16993, ... ]
5528 ' sin(x) ln(x) @key{RET} s 1 m r p 5 @key{RET} V M $ @key{RET}
5543 (If you got wildly different results, did you remember to switch
5546 Here we have divided the curve into ten segments of equal width;
5547 approximating these segments as rectangular boxes (i.e., assuming
5548 the curve is nearly flat at that resolution), we compute the areas
5549 of the boxes (height times width), then sum the areas. (It is
5550 faster to sum first, then multiply by the width, since the width
5551 is the same for every box.)
5553 The true value of this integral turns out to be about 0.374, so
5554 we're not doing too well. Let's try another approach.
5558 1: sin(x) ln(x) 1: 0.84147 x - 0.84147 + 0.11957 (x - 1)^2 - ...
5561 r 1 a t x=1 @key{RET} 4 @key{RET}
5566 Here we have computed the Taylor series expansion of the function
5567 about the point @expr{x=1}. We can now integrate this polynomial
5568 approximation, since polynomials are easy to integrate.
5572 1: 0.42074 x^2 + ... 1: [-0.0446, -0.42073] 1: 0.3761
5575 a i x @key{RET} [ 2 , 1 ] @key{TAB} V M $ @key{RET} V R -
5580 Better! By increasing the precision and/or asking for more terms
5581 in the Taylor series, we can get a result as accurate as we like.
5582 (Taylor series converge better away from singularities in the
5583 function such as the one at @code{ln(0)}, so it would also help to
5584 expand the series about the points @expr{x=2} or @expr{x=1.5} instead
5587 @cindex Simpson's rule
5588 @cindex Integration by Simpson's rule
5589 (@bullet{}) @strong{Exercise 4.} Our first method approximated the
5590 curve by stairsteps of width 0.1; the total area was then the sum
5591 of the areas of the rectangles under these stairsteps. Our second
5592 method approximated the function by a polynomial, which turned out
5593 to be a better approximation than stairsteps. A third method is
5594 @dfn{Simpson's rule}, which is like the stairstep method except
5595 that the steps are not required to be flat. Simpson's rule boils
5596 down to the formula,
5600 (h/3) * (f(a) + 4 f(a+h) + 2 f(a+2h) + 4 f(a+3h) + ...
5601 + 2 f(a+(n-2)*h) + 4 f(a+(n-1)*h) + f(a+n*h))
5608 \qquad {h \over 3} (f(a) + 4 f(a+h) + 2 f(a+2h) + 4 f(a+3h) + \cdots
5609 \hfill \cr \hfill {} + 2 f(a+(n-2)h) + 4 f(a+(n-1)h) + f(a+n h)) \qquad
5615 where @expr{n} (which must be even) is the number of slices and @expr{h}
5616 is the width of each slice. These are 10 and 0.1 in our example.
5617 For reference, here is the corresponding formula for the stairstep
5622 h * (f(a) + f(a+h) + f(a+2h) + f(a+3h) + ...
5623 + f(a+(n-2)*h) + f(a+(n-1)*h))
5629 $$ h (f(a) + f(a+h) + f(a+2h) + f(a+3h) + \cdots
5630 + f(a+(n-2)h) + f(a+(n-1)h)) $$
5634 Compute the integral from 1 to 2 of
5635 @texline @math{\sin x \ln x}
5636 @infoline @expr{sin(x) ln(x)}
5637 using Simpson's rule with 10 slices.
5638 @xref{Algebra Answer 4, 4}. (@bullet{})
5640 Calc has a built-in @kbd{a I} command for doing numerical integration.
5641 It uses @dfn{Romberg's method}, which is a more sophisticated cousin
5642 of Simpson's rule. In particular, it knows how to keep refining the
5643 result until the current precision is satisfied.
5645 @c [fix-ref Selecting Sub-Formulas]
5646 Aside from the commands we've seen so far, Calc also provides a
5647 large set of commands for operating on parts of formulas. You
5648 indicate the desired sub-formula by placing the cursor on any part
5649 of the formula before giving a @dfn{selection} command. Selections won't
5650 be covered in the tutorial; @pxref{Selecting Subformulas}, for
5651 details and examples.
5653 @c hard exercise: simplify (2^(n r) - 2^(r*(n - 1))) / (2^r - 1) 2^(n - 1)
5654 @c to 2^((n-1)*(r-1)).
5656 @node Rewrites Tutorial, , Basic Algebra Tutorial, Algebra Tutorial
5657 @subsection Rewrite Rules
5660 No matter how many built-in commands Calc provided for doing algebra,
5661 there would always be something you wanted to do that Calc didn't have
5662 in its repertoire. So Calc also provides a @dfn{rewrite rule} system
5663 that you can use to define your own algebraic manipulations.
5665 Suppose we want to simplify this trigonometric formula:
5669 1: 1 / cos(x) - sin(x) tan(x)
5672 ' 1/cos(x) - sin(x) tan(x) @key{RET} s 1
5677 If we were simplifying this by hand, we'd probably replace the
5678 @samp{tan} with a @samp{sin/cos} first, then combine over a common
5679 denominator. There is no Calc command to do the former; the @kbd{a n}
5680 algebra command will do the latter but we'll do both with rewrite
5681 rules just for practice.
5683 Rewrite rules are written with the @samp{:=} symbol.
5687 1: 1 / cos(x) - sin(x)^2 / cos(x)
5690 a r tan(a) := sin(a)/cos(a) @key{RET}
5695 (The ``assignment operator'' @samp{:=} has several uses in Calc. All
5696 by itself the formula @samp{tan(a) := sin(a)/cos(a)} doesn't do anything,
5697 but when it is given to the @kbd{a r} command, that command interprets
5698 it as a rewrite rule.)
5700 The lefthand side, @samp{tan(a)}, is called the @dfn{pattern} of the
5701 rewrite rule. Calc searches the formula on the stack for parts that
5702 match the pattern. Variables in a rewrite pattern are called
5703 @dfn{meta-variables}, and when matching the pattern each meta-variable
5704 can match any sub-formula. Here, the meta-variable @samp{a} matched
5705 the actual variable @samp{x}.
5707 When the pattern part of a rewrite rule matches a part of the formula,
5708 that part is replaced by the righthand side with all the meta-variables
5709 substituted with the things they matched. So the result is
5710 @samp{sin(x) / cos(x)}. Calc's normal algebraic simplifications then
5711 mix this in with the rest of the original formula.
5713 To merge over a common denominator, we can use another simple rule:
5717 1: (1 - sin(x)^2) / cos(x)
5720 a r a/x + b/x := (a+b)/x @key{RET}
5724 This rule points out several interesting features of rewrite patterns.
5725 First, if a meta-variable appears several times in a pattern, it must
5726 match the same thing everywhere. This rule detects common denominators
5727 because the same meta-variable @samp{x} is used in both of the
5730 Second, meta-variable names are independent from variables in the
5731 target formula. Notice that the meta-variable @samp{x} here matches
5732 the subformula @samp{cos(x)}; Calc never confuses the two meanings of
5735 And third, rewrite patterns know a little bit about the algebraic
5736 properties of formulas. The pattern called for a sum of two quotients;
5737 Calc was able to match a difference of two quotients by matching
5738 @samp{a = 1}, @samp{b = -sin(x)^2}, and @samp{x = cos(x)}.
5740 @c [fix-ref Algebraic Properties of Rewrite Rules]
5741 We could just as easily have written @samp{a/x - b/x := (a-b)/x} for
5742 the rule. It would have worked just the same in all cases. (If we
5743 really wanted the rule to apply only to @samp{+} or only to @samp{-},
5744 we could have used the @code{plain} symbol. @xref{Algebraic Properties
5745 of Rewrite Rules}, for some examples of this.)
5747 One more rewrite will complete the job. We want to use the identity
5748 @samp{sin(x)^2 + cos(x)^2 = 1}, but of course we must first rearrange
5749 the identity in a way that matches our formula. The obvious rule
5750 would be @samp{@w{1 - sin(x)^2} := cos(x)^2}, but a little thought shows
5751 that the rule @samp{sin(x)^2 := 1 - cos(x)^2} will also work. The
5752 latter rule has a more general pattern so it will work in many other
5757 1: (1 + cos(x)^2 - 1) / cos(x) 1: cos(x)
5760 a r sin(x)^2 := 1 - cos(x)^2 @key{RET} a s
5764 You may ask, what's the point of using the most general rule if you
5765 have to type it in every time anyway? The answer is that Calc allows
5766 you to store a rewrite rule in a variable, then give the variable
5767 name in the @kbd{a r} command. In fact, this is the preferred way to
5768 use rewrites. For one, if you need a rule once you'll most likely
5769 need it again later. Also, if the rule doesn't work quite right you
5770 can simply Undo, edit the variable, and run the rule again without
5771 having to retype it.
5775 ' tan(x) := sin(x)/cos(x) @key{RET} s t tsc @key{RET}
5776 ' a/x + b/x := (a+b)/x @key{RET} s t merge @key{RET}
5777 ' sin(x)^2 := 1 - cos(x)^2 @key{RET} s t sinsqr @key{RET}
5779 1: 1 / cos(x) - sin(x) tan(x) 1: cos(x)
5782 r 1 a r tsc @key{RET} a r merge @key{RET} a r sinsqr @key{RET} a s
5786 To edit a variable, type @kbd{s e} and the variable name, use regular
5787 Emacs editing commands as necessary, then type @kbd{C-c C-c} to store
5788 the edited value back into the variable.
5789 You can also use @w{@kbd{s e}} to create a new variable if you wish.
5791 Notice that the first time you use each rule, Calc puts up a ``compiling''
5792 message briefly. The pattern matcher converts rules into a special
5793 optimized pattern-matching language rather than using them directly.
5794 This allows @kbd{a r} to apply even rather complicated rules very
5795 efficiently. If the rule is stored in a variable, Calc compiles it
5796 only once and stores the compiled form along with the variable. That's
5797 another good reason to store your rules in variables rather than
5798 entering them on the fly.
5800 (@bullet{}) @strong{Exercise 1.} Type @kbd{m s} to get Symbolic
5801 mode, then enter the formula @samp{@w{(2 + sqrt(2))} / @w{(1 + sqrt(2))}}.
5802 Using a rewrite rule, simplify this formula by multiplying the top and
5803 bottom by the conjugate @w{@samp{1 - sqrt(2)}}. The result will have
5804 to be expanded by the distributive law; do this with another
5805 rewrite. @xref{Rewrites Answer 1, 1}. (@bullet{})
5807 The @kbd{a r} command can also accept a vector of rewrite rules, or
5808 a variable containing a vector of rules.
5812 1: [tsc, merge, sinsqr] 1: [tan(x) := sin(x) / cos(x), ... ]
5815 ' [tsc,merge,sinsqr] @key{RET} =
5822 1: 1 / cos(x) - sin(x) tan(x) 1: cos(x)
5825 s t trig @key{RET} r 1 a r trig @key{RET} a s
5829 @c [fix-ref Nested Formulas with Rewrite Rules]
5830 Calc tries all the rules you give against all parts of the formula,
5831 repeating until no further change is possible. (The exact order in
5832 which things are tried is rather complex, but for simple rules like
5833 the ones we've used here the order doesn't really matter.
5834 @xref{Nested Formulas with Rewrite Rules}.)
5836 Calc actually repeats only up to 100 times, just in case your rule set
5837 has gotten into an infinite loop. You can give a numeric prefix argument
5838 to @kbd{a r} to specify any limit. In particular, @kbd{M-1 a r} does
5839 only one rewrite at a time.
5843 1: 1 / cos(x) - sin(x)^2 / cos(x) 1: (1 - sin(x)^2) / cos(x)
5846 r 1 M-1 a r trig @key{RET} M-1 a r trig @key{RET}
5850 You can type @kbd{M-0 a r} if you want no limit at all on the number
5851 of rewrites that occur.
5853 Rewrite rules can also be @dfn{conditional}. Simply follow the rule
5854 with a @samp{::} symbol and the desired condition. For example,
5858 1: exp(2 pi i) + exp(3 pi i) + exp(4 pi i)
5861 ' exp(2 pi i) + exp(3 pi i) + exp(4 pi i) @key{RET}
5868 1: 1 + exp(3 pi i) + 1
5871 a r exp(k pi i) := 1 :: k % 2 = 0 @key{RET}
5876 (Recall, @samp{k % 2} is the remainder from dividing @samp{k} by 2,
5877 which will be zero only when @samp{k} is an even integer.)
5879 An interesting point is that the variables @samp{pi} and @samp{i}
5880 were matched literally rather than acting as meta-variables.
5881 This is because they are special-constant variables. The special
5882 constants @samp{e}, @samp{phi}, and so on also match literally.
5883 A common error with rewrite
5884 rules is to write, say, @samp{f(a,b,c,d,e) := g(a+b+c+d+e)}, expecting
5885 to match any @samp{f} with five arguments but in fact matching
5886 only when the fifth argument is literally @samp{e}!
5888 @cindex Fibonacci numbers
5893 Rewrite rules provide an interesting way to define your own functions.
5894 Suppose we want to define @samp{fib(n)} to produce the @var{n}th
5895 Fibonacci number. The first two Fibonacci numbers are each 1;
5896 later numbers are formed by summing the two preceding numbers in
5897 the sequence. This is easy to express in a set of three rules:
5901 ' [fib(1) := 1, fib(2) := 1, fib(n) := fib(n-1) + fib(n-2)] @key{RET} s t fib
5906 ' fib(7) @key{RET} a r fib @key{RET}
5910 One thing that is guaranteed about the order that rewrites are tried
5911 is that, for any given subformula, earlier rules in the rule set will
5912 be tried for that subformula before later ones. So even though the
5913 first and third rules both match @samp{fib(1)}, we know the first will
5914 be used preferentially.
5916 This rule set has one dangerous bug: Suppose we apply it to the
5917 formula @samp{fib(x)}? (Don't actually try this.) The third rule
5918 will match @samp{fib(x)} and replace it with @w{@samp{fib(x-1) + fib(x-2)}}.
5919 Each of these will then be replaced to get @samp{fib(x-2) + 2 fib(x-3) +
5920 fib(x-4)}, and so on, expanding forever. What we really want is to apply
5921 the third rule only when @samp{n} is an integer greater than two. Type
5922 @w{@kbd{s e fib @key{RET}}}, then edit the third rule to:
5925 fib(n) := fib(n-1) + fib(n-2) :: integer(n) :: n > 2
5933 1: fib(6) + fib(x) + fib(0) 1: 8 + fib(x) + fib(0)
5936 ' fib(6)+fib(x)+fib(0) @key{RET} a r fib @key{RET}
5941 We've created a new function, @code{fib}, and a new command,
5942 @w{@kbd{a r fib @key{RET}}}, which means ``evaluate all @code{fib} calls in
5943 this formula.'' To make things easier still, we can tell Calc to
5944 apply these rules automatically by storing them in the special
5945 variable @code{EvalRules}.
5949 1: [fib(1) := ...] . 1: [8, 13]
5952 s r fib @key{RET} s t EvalRules @key{RET} ' [fib(6), fib(7)] @key{RET}
5956 It turns out that this rule set has the problem that it does far
5957 more work than it needs to when @samp{n} is large. Consider the
5958 first few steps of the computation of @samp{fib(6)}:
5964 fib(4) + fib(3) + fib(3) + fib(2) =
5965 fib(3) + fib(2) + fib(2) + fib(1) + fib(2) + fib(1) + 1 = ...
5970 Note that @samp{fib(3)} appears three times here. Unless Calc's
5971 algebraic simplifier notices the multiple @samp{fib(3)}s and combines
5972 them (and, as it happens, it doesn't), this rule set does lots of
5973 needless recomputation. To cure the problem, type @code{s e EvalRules}
5974 to edit the rules (or just @kbd{s E}, a shorthand command for editing
5975 @code{EvalRules}) and add another condition:
5978 fib(n) := fib(n-1) + fib(n-2) :: integer(n) :: n > 2 :: remember
5982 If a @samp{:: remember} condition appears anywhere in a rule, then if
5983 that rule succeeds Calc will add another rule that describes that match
5984 to the front of the rule set. (Remembering works in any rule set, but
5985 for technical reasons it is most effective in @code{EvalRules}.) For
5986 example, if the rule rewrites @samp{fib(7)} to something that evaluates
5987 to 13, then the rule @samp{fib(7) := 13} will be added to the rule set.
5989 Type @kbd{' fib(8) @key{RET}} to compute the eighth Fibonacci number, then
5990 type @kbd{s E} again to see what has happened to the rule set.
5992 With the @code{remember} feature, our rule set can now compute
5993 @samp{fib(@var{n})} in just @var{n} steps. In the process it builds
5994 up a table of all Fibonacci numbers up to @var{n}. After we have
5995 computed the result for a particular @var{n}, we can get it back
5996 (and the results for all smaller @var{n}) later in just one step.
5998 All Calc operations will run somewhat slower whenever @code{EvalRules}
5999 contains any rules. You should type @kbd{s u EvalRules @key{RET}} now to
6000 un-store the variable.
6002 (@bullet{}) @strong{Exercise 2.} Sometimes it is possible to reformulate
6003 a problem to reduce the amount of recursion necessary to solve it.
6004 Create a rule that, in about @var{n} simple steps and without recourse
6005 to the @code{remember} option, replaces @samp{fib(@var{n}, 1, 1)} with
6006 @samp{fib(1, @var{x}, @var{y})} where @var{x} and @var{y} are the
6007 @var{n}th and @var{n+1}st Fibonacci numbers, respectively. This rule is
6008 rather clunky to use, so add a couple more rules to make the ``user
6009 interface'' the same as for our first version: enter @samp{fib(@var{n})},
6010 get back a plain number. @xref{Rewrites Answer 2, 2}. (@bullet{})
6012 There are many more things that rewrites can do. For example, there
6013 are @samp{&&&} and @samp{|||} pattern operators that create ``and''
6014 and ``or'' combinations of rules. As one really simple example, we
6015 could combine our first two Fibonacci rules thusly:
6018 [fib(1 ||| 2) := 1, fib(n) := ... ]
6022 That means ``@code{fib} of something matching either 1 or 2 rewrites
6025 You can also make meta-variables optional by enclosing them in @code{opt}.
6026 For example, the pattern @samp{a + b x} matches @samp{2 + 3 x} but not
6027 @samp{2 + x} or @samp{3 x} or @samp{x}. The pattern @samp{opt(a) + opt(b) x}
6028 matches all of these forms, filling in a default of zero for @samp{a}
6029 and one for @samp{b}.
6031 (@bullet{}) @strong{Exercise 3.} Your friend Joe had @samp{2 + 3 x}
6032 on the stack and tried to use the rule
6033 @samp{opt(a) + opt(b) x := f(a, b, x)}. What happened?
6034 @xref{Rewrites Answer 3, 3}. (@bullet{})
6036 (@bullet{}) @strong{Exercise 4.} Starting with a positive integer @expr{a},
6037 divide @expr{a} by two if it is even, otherwise compute @expr{3 a + 1}.
6038 Now repeat this step over and over. A famous unproved conjecture
6039 is that for any starting @expr{a}, the sequence always eventually
6040 reaches 1. Given the formula @samp{seq(@var{a}, 0)}, write a set of
6041 rules that convert this into @samp{seq(1, @var{n})} where @var{n}
6042 is the number of steps it took the sequence to reach the value 1.
6043 Now enhance the rules to accept @samp{seq(@var{a})} as a starting
6044 configuration, and to stop with just the number @var{n} by itself.
6045 Now make the result be a vector of values in the sequence, from @var{a}
6046 to 1. (The formula @samp{@var{x}|@var{y}} appends the vectors @var{x}
6047 and @var{y}.) For example, rewriting @samp{seq(6)} should yield the
6048 vector @expr{[6, 3, 10, 5, 16, 8, 4, 2, 1]}.
6049 @xref{Rewrites Answer 4, 4}. (@bullet{})
6051 (@bullet{}) @strong{Exercise 5.} Define, using rewrite rules, a function
6052 @samp{nterms(@var{x})} that returns the number of terms in the sum
6053 @var{x}, or 1 if @var{x} is not a sum. (A @dfn{sum} for our purposes
6054 is one or more non-sum terms separated by @samp{+} or @samp{-} signs,
6055 so that @expr{2 - 3 (x + y) + x y} is a sum of three terms.)
6056 @xref{Rewrites Answer 5, 5}. (@bullet{})
6058 (@bullet{}) @strong{Exercise 6.} A Taylor series for a function is an
6059 infinite series that exactly equals the value of that function at
6060 values of @expr{x} near zero.
6064 cos(x) = 1 - x^2 / 2! + x^4 / 4! - x^6 / 6! + ...
6070 $$ \cos x = 1 - {x^2 \over 2!} + {x^4 \over 4!} - {x^6 \over 6!} + \cdots $$
6074 The @kbd{a t} command produces a @dfn{truncated Taylor series} which
6075 is obtained by dropping all the terms higher than, say, @expr{x^2}.
6076 Calc represents the truncated Taylor series as a polynomial in @expr{x}.
6077 Mathematicians often write a truncated series using a ``big-O'' notation
6078 that records what was the lowest term that was truncated.
6082 cos(x) = 1 - x^2 / 2! + O(x^3)
6088 $$ \cos x = 1 - {x^2 \over 2!} + O(x^3) $$
6093 The meaning of @expr{O(x^3)} is ``a quantity which is negligibly small
6094 if @expr{x^3} is considered negligibly small as @expr{x} goes to zero.''
6096 The exercise is to create rewrite rules that simplify sums and products of
6097 power series represented as @samp{@var{polynomial} + O(@var{var}^@var{n})}.
6098 For example, given @samp{1 - x^2 / 2 + O(x^3)} and @samp{x - x^3 / 6 + O(x^4)}
6099 on the stack, we want to be able to type @kbd{*} and get the result
6100 @samp{x - 2:3 x^3 + O(x^4)}. Don't worry if the terms of the sum are
6101 rearranged or if @kbd{a s} needs to be typed after rewriting. (This one
6102 is rather tricky; the solution at the end of this chapter uses 6 rewrite
6103 rules. Hint: The @samp{constant(x)} condition tests whether @samp{x} is
6104 a number.) @xref{Rewrites Answer 6, 6}. (@bullet{})
6106 Just for kicks, try adding the rule @code{2+3 := 6} to @code{EvalRules}.
6107 What happens? (Be sure to remove this rule afterward, or you might get
6108 a nasty surprise when you use Calc to balance your checkbook!)
6110 @xref{Rewrite Rules}, for the whole story on rewrite rules.
6112 @node Programming Tutorial, Answers to Exercises, Algebra Tutorial, Tutorial
6113 @section Programming Tutorial
6116 The Calculator is written entirely in Emacs Lisp, a highly extensible
6117 language. If you know Lisp, you can program the Calculator to do
6118 anything you like. Rewrite rules also work as a powerful programming
6119 system. But Lisp and rewrite rules take a while to master, and often
6120 all you want to do is define a new function or repeat a command a few
6121 times. Calc has features that allow you to do these things easily.
6123 One very limited form of programming is defining your own functions.
6124 Calc's @kbd{Z F} command allows you to define a function name and
6125 key sequence to correspond to any formula. Programming commands use
6126 the shift-@kbd{Z} prefix; the user commands they create use the lower
6127 case @kbd{z} prefix.
6131 1: 1 + x + x^2 / 2 + x^3 / 6 1: 1 + x + x^2 / 2 + x^3 / 6
6134 ' 1 + x + x^2/2! + x^3/3! @key{RET} Z F e myexp @key{RET} @key{RET} @key{RET} y
6138 This polynomial is a Taylor series approximation to @samp{exp(x)}.
6139 The @kbd{Z F} command asks a number of questions. The above answers
6140 say that the key sequence for our function should be @kbd{z e}; the
6141 @kbd{M-x} equivalent should be @code{calc-myexp}; the name of the
6142 function in algebraic formulas should also be @code{myexp}; the
6143 default argument list @samp{(x)} is acceptable; and finally @kbd{y}
6144 answers the question ``leave it in symbolic form for non-constant
6149 1: 1.3495 2: 1.3495 3: 1.3495
6150 . 1: 1.34986 2: 1.34986
6154 .3 z e .3 E ' a+1 @key{RET} z e
6159 First we call our new @code{exp} approximation with 0.3 as an
6160 argument, and compare it with the true @code{exp} function. Then
6161 we note that, as requested, if we try to give @kbd{z e} an
6162 argument that isn't a plain number, it leaves the @code{myexp}
6163 function call in symbolic form. If we had answered @kbd{n} to the
6164 final question, @samp{myexp(a + 1)} would have evaluated by plugging
6165 in @samp{a + 1} for @samp{x} in the defining formula.
6167 @cindex Sine integral Si(x)
6172 (@bullet{}) @strong{Exercise 1.} The ``sine integral'' function
6173 @texline @math{{\rm Si}(x)}
6174 @infoline @expr{Si(x)}
6175 is defined as the integral of @samp{sin(t)/t} for
6176 @expr{t = 0} to @expr{x} in radians. (It was invented because this
6177 integral has no solution in terms of basic functions; if you give it
6178 to Calc's @kbd{a i} command, it will ponder it for a long time and then
6179 give up.) We can use the numerical integration command, however,
6180 which in algebraic notation is written like @samp{ninteg(f(t), t, 0, x)}
6181 with any integrand @samp{f(t)}. Define a @kbd{z s} command and
6182 @code{Si} function that implement this. You will need to edit the
6183 default argument list a bit. As a test, @samp{Si(1)} should return
6184 0.946083. (If you don't get this answer, you might want to check that
6185 Calc is in Radians mode. Also, @code{ninteg} will run a lot faster if
6186 you reduce the precision to, say, six digits beforehand.)
6187 @xref{Programming Answer 1, 1}. (@bullet{})
6189 The simplest way to do real ``programming'' of Emacs is to define a
6190 @dfn{keyboard macro}. A keyboard macro is simply a sequence of
6191 keystrokes which Emacs has stored away and can play back on demand.
6192 For example, if you find yourself typing @kbd{H a S x @key{RET}} often,
6193 you may wish to program a keyboard macro to type this for you.
6197 1: y = sqrt(x) 1: x = y^2
6200 ' y=sqrt(x) @key{RET} C-x ( H a S x @key{RET} C-x )
6202 1: y = cos(x) 1: x = s1 arccos(y) + 2 pi n1
6205 ' y=cos(x) @key{RET} X
6210 When you type @kbd{C-x (}, Emacs begins recording. But it is also
6211 still ready to execute your keystrokes, so you're really ``training''
6212 Emacs by walking it through the procedure once. When you type
6213 @w{@kbd{C-x )}}, the macro is recorded. You can now type @kbd{X} to
6214 re-execute the same keystrokes.
6216 You can give a name to your macro by typing @kbd{Z K}.
6220 1: . 1: y = x^4 1: x = s2 sqrt(s1 sqrt(y))
6223 Z K x @key{RET} ' y=x^4 @key{RET} z x
6228 Notice that we use shift-@kbd{Z} to define the command, and lower-case
6229 @kbd{z} to call it up.
6231 Keyboard macros can call other macros.
6235 1: abs(x) 1: x = s1 y 1: 2 / x 1: x = 2 / y
6238 ' abs(x) @key{RET} C-x ( ' y @key{RET} a = z x C-x ) ' 2/x @key{RET} X
6242 (@bullet{}) @strong{Exercise 2.} Define a keyboard macro to negate
6243 the item in level 3 of the stack, without disturbing the rest of
6244 the stack. @xref{Programming Answer 2, 2}. (@bullet{})
6246 (@bullet{}) @strong{Exercise 3.} Define keyboard macros to compute
6247 the following functions:
6252 @texline @math{\displaystyle{\sin x \over x}},
6253 @infoline @expr{sin(x) / x},
6254 where @expr{x} is the number on the top of the stack.
6257 Compute the base-@expr{b} logarithm, just like the @kbd{B} key except
6258 the arguments are taken in the opposite order.
6261 Produce a vector of integers from 1 to the integer on the top of
6265 @xref{Programming Answer 3, 3}. (@bullet{})
6267 (@bullet{}) @strong{Exercise 4.} Define a keyboard macro to compute
6268 the average (mean) value of a list of numbers.
6269 @xref{Programming Answer 4, 4}. (@bullet{})
6271 In many programs, some of the steps must execute several times.
6272 Calc has @dfn{looping} commands that allow this. Loops are useful
6273 inside keyboard macros, but actually work at any time.
6277 1: x^6 2: x^6 1: 360 x^2
6281 ' x^6 @key{RET} 4 Z < a d x @key{RET} Z >
6286 Here we have computed the fourth derivative of @expr{x^6} by
6287 enclosing a derivative command in a ``repeat loop'' structure.
6288 This structure pops a repeat count from the stack, then
6289 executes the body of the loop that many times.
6291 If you make a mistake while entering the body of the loop,
6292 type @w{@kbd{Z C-g}} to cancel the loop command.
6294 @cindex Fibonacci numbers
6295 Here's another example:
6304 1 @key{RET} @key{RET} 20 Z < @key{TAB} C-j + Z >
6309 The numbers in levels 2 and 1 should be the 21st and 22nd Fibonacci
6310 numbers, respectively. (To see what's going on, try a few repetitions
6311 of the loop body by hand; @kbd{C-j}, also on the Line-Feed or @key{LFD}
6312 key if you have one, makes a copy of the number in level 2.)
6314 @cindex Golden ratio
6315 @cindex Phi, golden ratio
6316 A fascinating property of the Fibonacci numbers is that the @expr{n}th
6317 Fibonacci number can be found directly by computing
6318 @texline @math{\phi^n / \sqrt{5}}
6319 @infoline @expr{phi^n / sqrt(5)}
6320 and then rounding to the nearest integer, where
6321 @texline @math{\phi} (``phi''),
6322 @infoline @expr{phi},
6323 the ``golden ratio,'' is
6324 @texline @math{(1 + \sqrt{5}) / 2}.
6325 @infoline @expr{(1 + sqrt(5)) / 2}.
6326 (For convenience, this constant is available from the @code{phi}
6327 variable, or the @kbd{I H P} command.)
6331 1: 1.61803 1: 24476.0000409 1: 10945.9999817 1: 10946
6338 @cindex Continued fractions
6339 (@bullet{}) @strong{Exercise 5.} The @dfn{continued fraction}
6341 @texline @math{\phi}
6342 @infoline @expr{phi}
6344 @texline @math{1 + 1/(1 + 1/(1 + 1/( \ldots )))}.
6345 @infoline @expr{1 + 1/(1 + 1/(1 + 1/( ...@: )))}.
6346 We can compute an approximate value by carrying this however far
6347 and then replacing the innermost
6348 @texline @math{1/( \ldots )}
6349 @infoline @expr{1/( ...@: )}
6351 @texline @math{\phi}
6352 @infoline @expr{phi}
6353 using a twenty-term continued fraction.
6354 @xref{Programming Answer 5, 5}. (@bullet{})
6356 (@bullet{}) @strong{Exercise 6.} Linear recurrences like the one for
6357 Fibonacci numbers can be expressed in terms of matrices. Given a
6358 vector @w{@expr{[a, b]}} determine a matrix which, when multiplied by this
6359 vector, produces the vector @expr{[b, c]}, where @expr{a}, @expr{b} and
6360 @expr{c} are three successive Fibonacci numbers. Now write a program
6361 that, given an integer @expr{n}, computes the @expr{n}th Fibonacci number
6362 using matrix arithmetic. @xref{Programming Answer 6, 6}. (@bullet{})
6364 @cindex Harmonic numbers
6365 A more sophisticated kind of loop is the @dfn{for} loop. Suppose
6366 we wish to compute the 20th ``harmonic'' number, which is equal to
6367 the sum of the reciprocals of the integers from 1 to 20.
6376 0 @key{RET} 1 @key{RET} 20 Z ( & + 1 Z )
6381 The ``for'' loop pops two numbers, the lower and upper limits, then
6382 repeats the body of the loop as an internal counter increases from
6383 the lower limit to the upper one. Just before executing the loop
6384 body, it pushes the current loop counter. When the loop body
6385 finishes, it pops the ``step,'' i.e., the amount by which to
6386 increment the loop counter. As you can see, our loop always
6389 This harmonic number function uses the stack to hold the running
6390 total as well as for the various loop housekeeping functions. If
6391 you find this disorienting, you can sum in a variable instead:
6395 1: 0 2: 1 . 1: 3.597739
6399 0 t 7 1 @key{RET} 20 Z ( & s + 7 1 Z ) r 7
6404 The @kbd{s +} command adds the top-of-stack into the value in a
6405 variable (and removes that value from the stack).
6407 It's worth noting that many jobs that call for a ``for'' loop can
6408 also be done more easily by Calc's high-level operations. Two
6409 other ways to compute harmonic numbers are to use vector mapping
6410 and reduction (@kbd{v x 20}, then @w{@kbd{V M &}}, then @kbd{V R +}),
6411 or to use the summation command @kbd{a +}. Both of these are
6412 probably easier than using loops. However, there are some
6413 situations where loops really are the way to go:
6415 (@bullet{}) @strong{Exercise 7.} Use a ``for'' loop to find the first
6416 harmonic number which is greater than 4.0.
6417 @xref{Programming Answer 7, 7}. (@bullet{})
6419 Of course, if we're going to be using variables in our programs,
6420 we have to worry about the programs clobbering values that the
6421 caller was keeping in those same variables. This is easy to
6426 . 1: 0.6667 1: 0.6667 3: 0.6667
6431 Z ` p 4 @key{RET} 2 @key{RET} 3 / s 7 s s a @key{RET} Z ' r 7 s r a @key{RET}
6436 When we type @kbd{Z `} (that's a back-quote character), Calc saves
6437 its mode settings and the contents of the ten ``quick variables''
6438 for later reference. When we type @kbd{Z '} (that's an apostrophe
6439 now), Calc restores those saved values. Thus the @kbd{p 4} and
6440 @kbd{s 7} commands have no effect outside this sequence. Wrapping
6441 this around the body of a keyboard macro ensures that it doesn't
6442 interfere with what the user of the macro was doing. Notice that
6443 the contents of the stack, and the values of named variables,
6444 survive past the @kbd{Z '} command.
6446 @cindex Bernoulli numbers, approximate
6447 The @dfn{Bernoulli numbers} are a sequence with the interesting
6448 property that all of the odd Bernoulli numbers are zero, and the
6449 even ones, while difficult to compute, can be roughly approximated
6451 @texline @math{\displaystyle{2 n! \over (2 \pi)^n}}.
6452 @infoline @expr{2 n!@: / (2 pi)^n}.
6453 Let's write a keyboard macro to compute (approximate) Bernoulli numbers.
6454 (Calc has a command, @kbd{k b}, to compute exact Bernoulli numbers, but
6455 this command is very slow for large @expr{n} since the higher Bernoulli
6456 numbers are very large fractions.)
6463 10 C-x ( @key{RET} 2 % Z [ @key{DEL} 0 Z : ' 2 $! / (2 pi)^$ @key{RET} = Z ] C-x )
6468 You can read @kbd{Z [} as ``then,'' @kbd{Z :} as ``else,'' and
6469 @kbd{Z ]} as ``end-if.'' There is no need for an explicit ``if''
6470 command. For the purposes of @w{@kbd{Z [}}, the condition is ``true''
6471 if the value it pops from the stack is a nonzero number, or ``false''
6472 if it pops zero or something that is not a number (like a formula).
6473 Here we take our integer argument modulo 2; this will be nonzero
6474 if we're asking for an odd Bernoulli number.
6476 The actual tenth Bernoulli number is @expr{5/66}.
6480 3: 0.0756823 1: 0 1: 0.25305 1: 0 1: 1.16659
6485 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
6489 Just to exercise loops a bit more, let's compute a table of even
6494 3: [] 1: [0.10132, 0.03079, 0.02340, 0.033197, ...]
6499 [ ] 2 @key{RET} 30 Z ( X | 2 Z )
6504 The vertical-bar @kbd{|} is the vector-concatenation command. When
6505 we execute it, the list we are building will be in stack level 2
6506 (initially this is an empty list), and the next Bernoulli number
6507 will be in level 1. The effect is to append the Bernoulli number
6508 onto the end of the list. (To create a table of exact fractional
6509 Bernoulli numbers, just replace @kbd{X} with @kbd{k b} in the above
6510 sequence of keystrokes.)
6512 With loops and conditionals, you can program essentially anything
6513 in Calc. One other command that makes looping easier is @kbd{Z /},
6514 which takes a condition from the stack and breaks out of the enclosing
6515 loop if the condition is true (non-zero). You can use this to make
6516 ``while'' and ``until'' style loops.
6518 If you make a mistake when entering a keyboard macro, you can edit
6519 it using @kbd{Z E}. First, you must attach it to a key with @kbd{Z K}.
6520 One technique is to enter a throwaway dummy definition for the macro,
6521 then enter the real one in the edit command.
6525 1: 3 1: 3 Calc Macro Edit Mode.
6526 . . Original keys: 1 <return> 2 +
6533 C-x ( 1 @key{RET} 2 + C-x ) Z K h @key{RET} Z E h
6538 A keyboard macro is stored as a pure keystroke sequence. The
6539 @file{edmacro} package (invoked by @kbd{Z E}) scans along the
6540 macro and tries to decode it back into human-readable steps.
6541 Descriptions of the keystrokes are given as comments, which begin with
6542 @samp{;;}, and which are ignored when the edited macro is saved.
6543 Spaces and line breaks are also ignored when the edited macro is saved.
6544 To enter a space into the macro, type @code{SPC}. All the special
6545 characters @code{RET}, @code{LFD}, @code{TAB}, @code{SPC}, @code{DEL},
6546 and @code{NUL} must be written in all uppercase, as must the prefixes
6547 @code{C-} and @code{M-}.
6549 Let's edit in a new definition, for computing harmonic numbers.
6550 First, erase the four lines of the old definition. Then, type
6551 in the new definition (or use Emacs @kbd{M-w} and @kbd{C-y} commands
6552 to copy it from this page of the Info file; you can of course skip
6553 typing the comments, which begin with @samp{;;}).
6556 Z` ;; calc-kbd-push (Save local values)
6557 0 ;; calc digits (Push a zero onto the stack)
6558 st ;; calc-store-into (Store it in the following variable)
6559 1 ;; calc quick variable (Quick variable q1)
6560 1 ;; calc digits (Initial value for the loop)
6561 TAB ;; calc-roll-down (Swap initial and final)
6562 Z( ;; calc-kbd-for (Begin the "for" loop)
6563 & ;; calc-inv (Take the reciprocal)
6564 s+ ;; calc-store-plus (Add to the following variable)
6565 1 ;; calc quick variable (Quick variable q1)
6566 1 ;; calc digits (The loop step is 1)
6567 Z) ;; calc-kbd-end-for (End the "for" loop)
6568 sr ;; calc-recall (Recall the final accumulated value)
6569 1 ;; calc quick variable (Quick variable q1)
6570 Z' ;; calc-kbd-pop (Restore values)
6574 Press @kbd{C-c C-c} to finish editing and return to the Calculator.
6585 The @file{edmacro} package defines a handy @code{read-kbd-macro} command
6586 which reads the current region of the current buffer as a sequence of
6587 keystroke names, and defines that sequence on the @kbd{X}
6588 (and @kbd{C-x e}) key. Because this is so useful, Calc puts this
6589 command on the @kbd{M-# m} key. Try reading in this macro in the
6590 following form: Press @kbd{C-@@} (or @kbd{C-@key{SPC}}) at
6591 one end of the text below, then type @kbd{M-# m} at the other.
6603 (@bullet{}) @strong{Exercise 8.} A general algorithm for solving
6604 equations numerically is @dfn{Newton's Method}. Given the equation
6605 @expr{f(x) = 0} for any function @expr{f}, and an initial guess
6606 @expr{x_0} which is reasonably close to the desired solution, apply
6607 this formula over and over:
6611 new_x = x - f(x)/f'(x)
6616 $$ x_{\rm new} = x - {f(x) \over f'(x)} $$
6621 where @expr{f'(x)} is the derivative of @expr{f}. The @expr{x}
6622 values will quickly converge to a solution, i.e., eventually
6623 @texline @math{x_{\rm new}}
6624 @infoline @expr{new_x}
6625 and @expr{x} will be equal to within the limits
6626 of the current precision. Write a program which takes a formula
6627 involving the variable @expr{x}, and an initial guess @expr{x_0},
6628 on the stack, and produces a value of @expr{x} for which the formula
6629 is zero. Use it to find a solution of
6630 @texline @math{\sin(\cos x) = 0.5}
6631 @infoline @expr{sin(cos(x)) = 0.5}
6632 near @expr{x = 4.5}. (Use angles measured in radians.) Note that
6633 the built-in @w{@kbd{a R}} (@code{calc-find-root}) command uses Newton's
6634 method when it is able. @xref{Programming Answer 8, 8}. (@bullet{})
6636 @cindex Digamma function
6637 @cindex Gamma constant, Euler's
6638 @cindex Euler's gamma constant
6639 (@bullet{}) @strong{Exercise 9.} The @dfn{digamma} function
6640 @texline @math{\psi(z) (``psi'')}
6641 @infoline @expr{psi(z)}
6642 is defined as the derivative of
6643 @texline @math{\ln \Gamma(z)}.
6644 @infoline @expr{ln(gamma(z))}.
6645 For large values of @expr{z}, it can be approximated by the infinite sum
6649 psi(z) ~= ln(z) - 1/2z - sum(bern(2 n) / 2 n z^(2 n), n, 1, inf)
6654 $$ \psi(z) \approx \ln z - {1\over2z} -
6655 \sum_{n=1}^\infty {\code{bern}(2 n) \over 2 n z^{2n}}
6662 @texline @math{\sum}
6663 @infoline @expr{sum}
6664 represents the sum over @expr{n} from 1 to infinity
6665 (or to some limit high enough to give the desired accuracy), and
6666 the @code{bern} function produces (exact) Bernoulli numbers.
6667 While this sum is not guaranteed to converge, in practice it is safe.
6668 An interesting mathematical constant is Euler's gamma, which is equal
6669 to about 0.5772. One way to compute it is by the formula,
6670 @texline @math{\gamma = -\psi(1)}.
6671 @infoline @expr{gamma = -psi(1)}.
6672 Unfortunately, 1 isn't a large enough argument
6673 for the above formula to work (5 is a much safer value for @expr{z}).
6674 Fortunately, we can compute
6675 @texline @math{\psi(1)}
6676 @infoline @expr{psi(1)}
6678 @texline @math{\psi(5)}
6679 @infoline @expr{psi(5)}
6680 using the recurrence
6681 @texline @math{\psi(z+1) = \psi(z) + {1 \over z}}.
6682 @infoline @expr{psi(z+1) = psi(z) + 1/z}.
6683 Your task: Develop a program to compute
6684 @texline @math{\psi(z)};
6685 @infoline @expr{psi(z)};
6686 it should ``pump up'' @expr{z}
6687 if necessary to be greater than 5, then use the above summation
6688 formula. Use looping commands to compute the sum. Use your function
6690 @texline @math{\gamma}
6691 @infoline @expr{gamma}
6692 to twelve decimal places. (Calc has a built-in command
6693 for Euler's constant, @kbd{I P}, which you can use to check your answer.)
6694 @xref{Programming Answer 9, 9}. (@bullet{})
6696 @cindex Polynomial, list of coefficients
6697 (@bullet{}) @strong{Exercise 10.} Given a polynomial in @expr{x} and
6698 a number @expr{m} on the stack, where the polynomial is of degree
6699 @expr{m} or less (i.e., does not have any terms higher than @expr{x^m}),
6700 write a program to convert the polynomial into a list-of-coefficients
6701 notation. For example, @expr{5 x^4 + (x + 1)^2} with @expr{m = 6}
6702 should produce the list @expr{[1, 2, 1, 0, 5, 0, 0]}. Also develop
6703 a way to convert from this form back to the standard algebraic form.
6704 @xref{Programming Answer 10, 10}. (@bullet{})
6707 (@bullet{}) @strong{Exercise 11.} The @dfn{Stirling numbers of the
6708 first kind} are defined by the recurrences,
6712 s(n,n) = 1 for n >= 0,
6713 s(n,0) = 0 for n > 0,
6714 s(n+1,m) = s(n,m-1) - n s(n,m) for n >= m >= 1.
6720 $$ \eqalign{ s(n,n) &= 1 \qquad \hbox{for } n \ge 0, \cr
6721 s(n,0) &= 0 \qquad \hbox{for } n > 0, \cr
6722 s(n+1,m) &= s(n,m-1) - n \, s(n,m) \qquad
6723 \hbox{for } n \ge m \ge 1.}
6727 (These numbers are also sometimes written $\displaystyle{n \brack m}$.)
6730 This can be implemented using a @dfn{recursive} program in Calc; the
6731 program must invoke itself in order to calculate the two righthand
6732 terms in the general formula. Since it always invokes itself with
6733 ``simpler'' arguments, it's easy to see that it must eventually finish
6734 the computation. Recursion is a little difficult with Emacs keyboard
6735 macros since the macro is executed before its definition is complete.
6736 So here's the recommended strategy: Create a ``dummy macro'' and assign
6737 it to a key with, e.g., @kbd{Z K s}. Now enter the true definition,
6738 using the @kbd{z s} command to call itself recursively, then assign it
6739 to the same key with @kbd{Z K s}. Now the @kbd{z s} command will run
6740 the complete recursive program. (Another way is to use @w{@kbd{Z E}}
6741 or @kbd{M-# m} (@code{read-kbd-macro}) to read the whole macro at once,
6742 thus avoiding the ``training'' phase.) The task: Write a program
6743 that computes Stirling numbers of the first kind, given @expr{n} and
6744 @expr{m} on the stack. Test it with @emph{small} inputs like
6745 @expr{s(4,2)}. (There is a built-in command for Stirling numbers,
6746 @kbd{k s}, which you can use to check your answers.)
6747 @xref{Programming Answer 11, 11}. (@bullet{})
6749 The programming commands we've seen in this part of the tutorial
6750 are low-level, general-purpose operations. Often you will find
6751 that a higher-level function, such as vector mapping or rewrite
6752 rules, will do the job much more easily than a detailed, step-by-step
6755 (@bullet{}) @strong{Exercise 12.} Write another program for
6756 computing Stirling numbers of the first kind, this time using
6757 rewrite rules. Once again, @expr{n} and @expr{m} should be taken
6758 from the stack. @xref{Programming Answer 12, 12}. (@bullet{})
6763 This ends the tutorial section of the Calc manual. Now you know enough
6764 about Calc to use it effectively for many kinds of calculations. But
6765 Calc has many features that were not even touched upon in this tutorial.
6767 The rest of this manual tells the whole story.
6769 @c Volume II of this manual, the @dfn{Calc Reference}, tells the whole story.
6772 @node Answers to Exercises, , Programming Tutorial, Tutorial
6773 @section Answers to Exercises
6776 This section includes answers to all the exercises in the Calc tutorial.
6779 * RPN Answer 1:: 1 @key{RET} 2 @key{RET} 3 @key{RET} 4 + * -
6780 * RPN Answer 2:: 2*4 + 7*9.5 + 5/4
6781 * RPN Answer 3:: Operating on levels 2 and 3
6782 * RPN Answer 4:: Joe's complex problems
6783 * Algebraic Answer 1:: Simulating Q command
6784 * Algebraic Answer 2:: Joe's algebraic woes
6785 * Algebraic Answer 3:: 1 / 0
6786 * Modes Answer 1:: 3#0.1 = 3#0.0222222?
6787 * Modes Answer 2:: 16#f.e8fe15
6788 * Modes Answer 3:: Joe's rounding bug
6789 * Modes Answer 4:: Why floating point?
6790 * Arithmetic Answer 1:: Why the \ command?
6791 * Arithmetic Answer 2:: Tripping up the B command
6792 * Vector Answer 1:: Normalizing a vector
6793 * Vector Answer 2:: Average position
6794 * Matrix Answer 1:: Row and column sums
6795 * Matrix Answer 2:: Symbolic system of equations
6796 * Matrix Answer 3:: Over-determined system
6797 * List Answer 1:: Powers of two
6798 * List Answer 2:: Least-squares fit with matrices
6799 * List Answer 3:: Geometric mean
6800 * List Answer 4:: Divisor function
6801 * List Answer 5:: Duplicate factors
6802 * List Answer 6:: Triangular list
6803 * List Answer 7:: Another triangular list
6804 * List Answer 8:: Maximum of Bessel function
6805 * List Answer 9:: Integers the hard way
6806 * List Answer 10:: All elements equal
6807 * List Answer 11:: Estimating pi with darts
6808 * List Answer 12:: Estimating pi with matchsticks
6809 * List Answer 13:: Hash codes
6810 * List Answer 14:: Random walk
6811 * Types Answer 1:: Square root of pi times rational
6812 * Types Answer 2:: Infinities
6813 * Types Answer 3:: What can "nan" be?
6814 * Types Answer 4:: Abbey Road
6815 * Types Answer 5:: Friday the 13th
6816 * Types Answer 6:: Leap years
6817 * Types Answer 7:: Erroneous donut
6818 * Types Answer 8:: Dividing intervals
6819 * Types Answer 9:: Squaring intervals
6820 * Types Answer 10:: Fermat's primality test
6821 * Types Answer 11:: pi * 10^7 seconds
6822 * Types Answer 12:: Abbey Road on CD
6823 * Types Answer 13:: Not quite pi * 10^7 seconds
6824 * Types Answer 14:: Supercomputers and c
6825 * Types Answer 15:: Sam the Slug
6826 * Algebra Answer 1:: Squares and square roots
6827 * Algebra Answer 2:: Building polynomial from roots
6828 * Algebra Answer 3:: Integral of x sin(pi x)
6829 * Algebra Answer 4:: Simpson's rule
6830 * Rewrites Answer 1:: Multiplying by conjugate
6831 * Rewrites Answer 2:: Alternative fib rule
6832 * Rewrites Answer 3:: Rewriting opt(a) + opt(b) x
6833 * Rewrites Answer 4:: Sequence of integers
6834 * Rewrites Answer 5:: Number of terms in sum
6835 * Rewrites Answer 6:: Truncated Taylor series
6836 * Programming Answer 1:: Fresnel's C(x)
6837 * Programming Answer 2:: Negate third stack element
6838 * Programming Answer 3:: Compute sin(x) / x, etc.
6839 * Programming Answer 4:: Average value of a list
6840 * Programming Answer 5:: Continued fraction phi
6841 * Programming Answer 6:: Matrix Fibonacci numbers
6842 * Programming Answer 7:: Harmonic number greater than 4
6843 * Programming Answer 8:: Newton's method
6844 * Programming Answer 9:: Digamma function
6845 * Programming Answer 10:: Unpacking a polynomial
6846 * Programming Answer 11:: Recursive Stirling numbers
6847 * Programming Answer 12:: Stirling numbers with rewrites
6850 @c The following kludgery prevents the individual answers from
6851 @c being entered on the table of contents.
6853 \global\let\oldwrite=\write
6854 \gdef\skipwrite#1#2{\let\write=\oldwrite}
6855 \global\let\oldchapternofonts=\chapternofonts
6856 \gdef\chapternofonts{\let\write=\skipwrite\oldchapternofonts}
6859 @node RPN Answer 1, RPN Answer 2, Answers to Exercises, Answers to Exercises
6860 @subsection RPN Tutorial Exercise 1
6863 @kbd{1 @key{RET} 2 @key{RET} 3 @key{RET} 4 + * -}
6866 @texline @math{1 - (2 \times (3 + 4)) = -13}.
6867 @infoline @expr{1 - (2 * (3 + 4)) = -13}.
6869 @node RPN Answer 2, RPN Answer 3, RPN Answer 1, Answers to Exercises
6870 @subsection RPN Tutorial Exercise 2
6873 @texline @math{2\times4 + 7\times9.5 + {5\over4} = 75.75}
6874 @infoline @expr{2*4 + 7*9.5 + 5/4 = 75.75}
6876 After computing the intermediate term
6877 @texline @math{2\times4 = 8},
6878 @infoline @expr{2*4 = 8},
6879 you can leave that result on the stack while you compute the second
6880 term. With both of these results waiting on the stack you can then
6881 compute the final term, then press @kbd{+ +} to add everything up.
6890 2 @key{RET} 4 * 7 @key{RET} 9.5 *
6897 4: 8 3: 8 2: 8 1: 75.75
6898 3: 66.5 2: 66.5 1: 67.75 .
6907 Alternatively, you could add the first two terms before going on
6908 with the third term.
6912 2: 8 1: 74.5 3: 74.5 2: 74.5 1: 75.75
6913 1: 66.5 . 2: 5 1: 1.25 .
6917 ... + 5 @key{RET} 4 / +
6921 On an old-style RPN calculator this second method would have the
6922 advantage of using only three stack levels. But since Calc's stack
6923 can grow arbitrarily large this isn't really an issue. Which method
6924 you choose is purely a matter of taste.
6926 @node RPN Answer 3, RPN Answer 4, RPN Answer 2, Answers to Exercises
6927 @subsection RPN Tutorial Exercise 3
6930 The @key{TAB} key provides a way to operate on the number in level 2.
6934 3: 10 3: 10 4: 10 3: 10 3: 10
6935 2: 20 2: 30 3: 30 2: 30 2: 21
6936 1: 30 1: 20 2: 20 1: 21 1: 30
6940 @key{TAB} 1 + @key{TAB}
6944 Similarly, @kbd{M-@key{TAB}} gives you access to the number in level 3.
6948 3: 10 3: 21 3: 21 3: 30 3: 11
6949 2: 21 2: 30 2: 30 2: 11 2: 21
6950 1: 30 1: 10 1: 11 1: 21 1: 30
6953 M-@key{TAB} 1 + M-@key{TAB} M-@key{TAB}
6957 @node RPN Answer 4, Algebraic Answer 1, RPN Answer 3, Answers to Exercises
6958 @subsection RPN Tutorial Exercise 4
6961 Either @kbd{( 2 , 3 )} or @kbd{( 2 @key{SPC} 3 )} would have worked,
6962 but using both the comma and the space at once yields:
6966 1: ( ... 2: ( ... 1: (2, ... 2: (2, ... 2: (2, ...
6967 . 1: 2 . 1: (2, ... 1: (2, 3)
6974 Joe probably tried to type @kbd{@key{TAB} @key{DEL}} to swap the
6975 extra incomplete object to the top of the stack and delete it.
6976 But a feature of Calc is that @key{DEL} on an incomplete object
6977 deletes just one component out of that object, so he had to press
6978 @key{DEL} twice to finish the job.
6982 2: (2, ... 2: (2, 3) 2: (2, 3) 1: (2, 3)
6983 1: (2, 3) 1: (2, ... 1: ( ... .
6986 @key{TAB} @key{DEL} @key{DEL}
6990 (As it turns out, deleting the second-to-top stack entry happens often
6991 enough that Calc provides a special key, @kbd{M-@key{DEL}}, to do just that.
6992 @kbd{M-@key{DEL}} is just like @kbd{@key{TAB} @key{DEL}}, except that it doesn't exhibit
6993 the ``feature'' that tripped poor Joe.)
6995 @node Algebraic Answer 1, Algebraic Answer 2, RPN Answer 4, Answers to Exercises
6996 @subsection Algebraic Entry Tutorial Exercise 1
6999 Type @kbd{' sqrt($) @key{RET}}.
7001 If the @kbd{Q} key is broken, you could use @kbd{' $^0.5 @key{RET}}.
7002 Or, RPN style, @kbd{0.5 ^}.
7004 (Actually, @samp{$^1:2}, using the fraction one-half as the power, is
7005 a closer equivalent, since @samp{9^0.5} yields @expr{3.0} whereas
7006 @samp{sqrt(9)} and @samp{9^1:2} yield the exact integer @expr{3}.)
7008 @node Algebraic Answer 2, Algebraic Answer 3, Algebraic Answer 1, Answers to Exercises
7009 @subsection Algebraic Entry Tutorial Exercise 2
7012 In the formula @samp{2 x (1+y)}, @samp{x} was interpreted as a function
7013 name with @samp{1+y} as its argument. Assigning a value to a variable
7014 has no relation to a function by the same name. Joe needed to use an
7015 explicit @samp{*} symbol here: @samp{2 x*(1+y)}.
7017 @node Algebraic Answer 3, Modes Answer 1, Algebraic Answer 2, Answers to Exercises
7018 @subsection Algebraic Entry Tutorial Exercise 3
7021 The result from @kbd{1 @key{RET} 0 /} will be the formula @expr{1 / 0}.
7022 The ``function'' @samp{/} cannot be evaluated when its second argument
7023 is zero, so it is left in symbolic form. When you now type @kbd{0 *},
7024 the result will be zero because Calc uses the general rule that ``zero
7025 times anything is zero.''
7027 @c [fix-ref Infinities]
7028 The @kbd{m i} command enables an @dfn{Infinite mode} in which @expr{1 / 0}
7029 results in a special symbol that represents ``infinity.'' If you
7030 multiply infinity by zero, Calc uses another special new symbol to
7031 show that the answer is ``indeterminate.'' @xref{Infinities}, for
7032 further discussion of infinite and indeterminate values.
7034 @node Modes Answer 1, Modes Answer 2, Algebraic Answer 3, Answers to Exercises
7035 @subsection Modes Tutorial Exercise 1
7038 Calc always stores its numbers in decimal, so even though one-third has
7039 an exact base-3 representation (@samp{3#0.1}), it is still stored as
7040 0.3333333 (chopped off after 12 or however many decimal digits) inside
7041 the calculator's memory. When this inexact number is converted back
7042 to base 3 for display, it may still be slightly inexact. When we
7043 multiply this number by 3, we get 0.999999, also an inexact value.
7045 When Calc displays a number in base 3, it has to decide how many digits
7046 to show. If the current precision is 12 (decimal) digits, that corresponds
7047 to @samp{12 / log10(3) = 25.15} base-3 digits. Because 25.15 is not an
7048 exact integer, Calc shows only 25 digits, with the result that stored
7049 numbers carry a little bit of extra information that may not show up on
7050 the screen. When Joe entered @samp{3#0.2}, the stored number 0.666666
7051 happened to round to a pleasing value when it lost that last 0.15 of a
7052 digit, but it was still inexact in Calc's memory. When he divided by 2,
7053 he still got the dreaded inexact value 0.333333. (Actually, he divided
7054 0.666667 by 2 to get 0.333334, which is why he got something a little
7055 higher than @code{3#0.1} instead of a little lower.)
7057 If Joe didn't want to be bothered with all this, he could have typed
7058 @kbd{M-24 d n} to display with one less digit than the default. (If
7059 you give @kbd{d n} a negative argument, it uses default-minus-that,
7060 so @kbd{M-- d n} would be an easier way to get the same effect.) Those
7061 inexact results would still be lurking there, but they would now be
7062 rounded to nice, natural-looking values for display purposes. (Remember,
7063 @samp{0.022222} in base 3 is like @samp{0.099999} in base 10; rounding
7064 off one digit will round the number up to @samp{0.1}.) Depending on the
7065 nature of your work, this hiding of the inexactness may be a benefit or
7066 a danger. With the @kbd{d n} command, Calc gives you the choice.
7068 Incidentally, another consequence of all this is that if you type
7069 @kbd{M-30 d n} to display more digits than are ``really there,''
7070 you'll see garbage digits at the end of the number. (In decimal
7071 display mode, with decimally-stored numbers, these garbage digits are
7072 always zero so they vanish and you don't notice them.) Because Calc
7073 rounds off that 0.15 digit, there is the danger that two numbers could
7074 be slightly different internally but still look the same. If you feel
7075 uneasy about this, set the @kbd{d n} precision to be a little higher
7076 than normal; you'll get ugly garbage digits, but you'll always be able
7077 to tell two distinct numbers apart.
7079 An interesting side note is that most computers store their
7080 floating-point numbers in binary, and convert to decimal for display.
7081 Thus everyday programs have the same problem: Decimal 0.1 cannot be
7082 represented exactly in binary (try it: @kbd{0.1 d 2}), so @samp{0.1 * 10}
7083 comes out as an inexact approximation to 1 on some machines (though
7084 they generally arrange to hide it from you by rounding off one digit as
7085 we did above). Because Calc works in decimal instead of binary, you can
7086 be sure that numbers that look exact @emph{are} exact as long as you stay
7087 in decimal display mode.
7089 It's not hard to show that any number that can be represented exactly
7090 in binary, octal, or hexadecimal is also exact in decimal, so the kinds
7091 of problems we saw in this exercise are likely to be severe only when
7092 you use a relatively unusual radix like 3.
7094 @node Modes Answer 2, Modes Answer 3, Modes Answer 1, Answers to Exercises
7095 @subsection Modes Tutorial Exercise 2
7097 If the radix is 15 or higher, we can't use the letter @samp{e} to mark
7098 the exponent because @samp{e} is interpreted as a digit. When Calc
7099 needs to display scientific notation in a high radix, it writes
7100 @samp{16#F.E8F*16.^15}. You can enter a number like this as an
7101 algebraic entry. Also, pressing @kbd{e} without any digits before it
7102 normally types @kbd{1e}, but in a high radix it types @kbd{16.^} and
7103 puts you in algebraic entry: @kbd{16#f.e8f @key{RET} e 15 @key{RET} *} is another
7104 way to enter this number.
7106 The reason Calc puts a decimal point in the @samp{16.^} is to prevent
7107 huge integers from being generated if the exponent is large (consider
7108 @samp{16#1.23*16^1000}, where we compute @samp{16^1000} as a giant
7109 exact integer and then throw away most of the digits when we multiply
7110 it by the floating-point @samp{16#1.23}). While this wouldn't normally
7111 matter for display purposes, it could give you a nasty surprise if you
7112 copied that number into a file and later moved it back into Calc.
7114 @node Modes Answer 3, Modes Answer 4, Modes Answer 2, Answers to Exercises
7115 @subsection Modes Tutorial Exercise 3
7118 The answer he got was @expr{0.5000000000006399}.
7120 The problem is not that the square operation is inexact, but that the
7121 sine of 45 that was already on the stack was accurate to only 12 places.
7122 Arbitrary-precision calculations still only give answers as good as
7125 The real problem is that there is no 12-digit number which, when
7126 squared, comes out to 0.5 exactly. The @kbd{f [} and @kbd{f ]}
7127 commands decrease or increase a number by one unit in the last
7128 place (according to the current precision). They are useful for
7129 determining facts like this.
7133 1: 0.707106781187 1: 0.500000000001
7143 1: 0.707106781187 1: 0.707106781186 1: 0.499999999999
7150 A high-precision calculation must be carried out in high precision
7151 all the way. The only number in the original problem which was known
7152 exactly was the quantity 45 degrees, so the precision must be raised
7153 before anything is done after the number 45 has been entered in order
7154 for the higher precision to be meaningful.
7156 @node Modes Answer 4, Arithmetic Answer 1, Modes Answer 3, Answers to Exercises
7157 @subsection Modes Tutorial Exercise 4
7160 Many calculations involve real-world quantities, like the width and
7161 height of a piece of wood or the volume of a jar. Such quantities
7162 can't be measured exactly anyway, and if the data that is input to
7163 a calculation is inexact, doing exact arithmetic on it is a waste
7166 Fractions become unwieldy after too many calculations have been
7167 done with them. For example, the sum of the reciprocals of the
7168 integers from 1 to 10 is 7381:2520. The sum from 1 to 30 is
7169 9304682830147:2329089562800. After a point it will take a long
7170 time to add even one more term to this sum, but a floating-point
7171 calculation of the sum will not have this problem.
7173 Also, rational numbers cannot express the results of all calculations.
7174 There is no fractional form for the square root of two, so if you type
7175 @w{@kbd{2 Q}}, Calc has no choice but to give you a floating-point answer.
7177 @node Arithmetic Answer 1, Arithmetic Answer 2, Modes Answer 4, Answers to Exercises
7178 @subsection Arithmetic Tutorial Exercise 1
7181 Dividing two integers that are larger than the current precision may
7182 give a floating-point result that is inaccurate even when rounded
7183 down to an integer. Consider @expr{123456789 / 2} when the current
7184 precision is 6 digits. The true answer is @expr{61728394.5}, but
7185 with a precision of 6 this will be rounded to
7186 @texline @math{12345700.0/2.0 = 61728500.0}.
7187 @infoline @expr{12345700.@: / 2.@: = 61728500.}.
7188 The result, when converted to an integer, will be off by 106.
7190 Here are two solutions: Raise the precision enough that the
7191 floating-point round-off error is strictly to the right of the
7192 decimal point. Or, convert to Fraction mode so that @expr{123456789 / 2}
7193 produces the exact fraction @expr{123456789:2}, which can be rounded
7194 down by the @kbd{F} command without ever switching to floating-point
7197 @node Arithmetic Answer 2, Vector Answer 1, Arithmetic Answer 1, Answers to Exercises
7198 @subsection Arithmetic Tutorial Exercise 2
7201 @kbd{27 @key{RET} 9 B} could give the exact result @expr{3:2}, but it
7202 does a floating-point calculation instead and produces @expr{1.5}.
7204 Calc will find an exact result for a logarithm if the result is an integer
7205 or (when in Fraction mode) the reciprocal of an integer. But there is
7206 no efficient way to search the space of all possible rational numbers
7207 for an exact answer, so Calc doesn't try.
7209 @node Vector Answer 1, Vector Answer 2, Arithmetic Answer 2, Answers to Exercises
7210 @subsection Vector Tutorial Exercise 1
7213 Duplicate the vector, compute its length, then divide the vector
7214 by its length: @kbd{@key{RET} A /}.
7218 1: [1, 2, 3] 2: [1, 2, 3] 1: [0.27, 0.53, 0.80] 1: 1.
7219 . 1: 3.74165738677 . .
7226 The final @kbd{A} command shows that the normalized vector does
7227 indeed have unit length.
7229 @node Vector Answer 2, Matrix Answer 1, Vector Answer 1, Answers to Exercises
7230 @subsection Vector Tutorial Exercise 2
7233 The average position is equal to the sum of the products of the
7234 positions times their corresponding probabilities. This is the
7235 definition of the dot product operation. So all you need to do
7236 is to put the two vectors on the stack and press @kbd{*}.
7238 @node Matrix Answer 1, Matrix Answer 2, Vector Answer 2, Answers to Exercises
7239 @subsection Matrix Tutorial Exercise 1
7242 The trick is to multiply by a vector of ones. Use @kbd{r 4 [1 1 1] *} to
7243 get the row sum. Similarly, use @kbd{[1 1] r 4 *} to get the column sum.
7245 @node Matrix Answer 2, Matrix Answer 3, Matrix Answer 1, Answers to Exercises
7246 @subsection Matrix Tutorial Exercise 2
7259 $$ \eqalign{ x &+ a y = 6 \cr
7265 Just enter the righthand side vector, then divide by the lefthand side
7270 1: [6, 10] 2: [6, 10] 1: [6 - 4 a / (b - a), 4 / (b - a) ]
7275 ' [6 10] @key{RET} ' [1 a; 1 b] @key{RET} /
7279 This can be made more readable using @kbd{d B} to enable Big display
7285 1: [6 - -----, -----]
7290 Type @kbd{d N} to return to Normal display mode afterwards.
7292 @node Matrix Answer 3, List Answer 1, Matrix Answer 2, Answers to Exercises
7293 @subsection Matrix Tutorial Exercise 3
7297 @texline @math{A^T A \, X = A^T B},
7298 @infoline @expr{trn(A) * A * X = trn(A) * B},
7300 @texline @math{A' = A^T A}
7301 @infoline @expr{A2 = trn(A) * A}
7303 @texline @math{B' = A^T B};
7304 @infoline @expr{B2 = trn(A) * B};
7305 now, we have a system
7306 @texline @math{A' X = B'}
7307 @infoline @expr{A2 * X = B2}
7308 which we can solve using Calc's @samp{/} command.
7323 $$ \openup1\jot \tabskip=0pt plus1fil
7324 \halign to\displaywidth{\tabskip=0pt
7325 $\hfil#$&$\hfil{}#{}$&
7326 $\hfil#$&$\hfil{}#{}$&
7327 $\hfil#$&${}#\hfil$\tabskip=0pt plus1fil\cr
7331 2a&+&4b&+&6c&=11 \cr}
7336 The first step is to enter the coefficient matrix. We'll store it in
7337 quick variable number 7 for later reference. Next, we compute the
7344 1: [ [ 1, 2, 3 ] 2: [ [ 1, 4, 7, 2 ] 1: [57, 84, 96]
7345 [ 4, 5, 6 ] [ 2, 5, 6, 4 ] .
7346 [ 7, 6, 0 ] [ 3, 6, 0, 6 ] ]
7347 [ 2, 4, 6 ] ] 1: [6, 2, 3, 11]
7350 ' [1 2 3; 4 5 6; 7 6 0; 2 4 6] @key{RET} s 7 v t [6 2 3 11] *
7355 Now we compute the matrix
7362 2: [57, 84, 96] 1: [-11.64, 14.08, -3.64]
7363 1: [ [ 70, 72, 39 ] .
7373 (The actual computed answer will be slightly inexact due to
7376 Notice that the answers are similar to those for the
7377 @texline @math{3\times3}
7379 system solved in the text. That's because the fourth equation that was
7380 added to the system is almost identical to the first one multiplied
7381 by two. (If it were identical, we would have gotten the exact same
7383 @texline @math{4\times3}
7385 system would be equivalent to the original
7386 @texline @math{3\times3}
7390 Since the first and fourth equations aren't quite equivalent, they
7391 can't both be satisfied at once. Let's plug our answers back into
7392 the original system of equations to see how well they match.
7396 2: [-11.64, 14.08, -3.64] 1: [5.6, 2., 3., 11.2]
7408 This is reasonably close to our original @expr{B} vector,
7409 @expr{[6, 2, 3, 11]}.
7411 @node List Answer 1, List Answer 2, Matrix Answer 3, Answers to Exercises
7412 @subsection List Tutorial Exercise 1
7415 We can use @kbd{v x} to build a vector of integers. This needs to be
7416 adjusted to get the range of integers we desire. Mapping @samp{-}
7417 across the vector will accomplish this, although it turns out the
7418 plain @samp{-} key will work just as well.
7423 1: [1, 2, 3, 4, 5, 6, 7, 8, 9] 1: [-4, -3, -2, -1, 0, 1, 2, 3, 4]
7426 2 v x 9 @key{RET} 5 V M - or 5 -
7431 Now we use @kbd{V M ^} to map the exponentiation operator across the
7436 1: [0.0625, 0.125, 0.25, 0.5, 1, 2, 4, 8, 16]
7443 @node List Answer 2, List Answer 3, List Answer 1, Answers to Exercises
7444 @subsection List Tutorial Exercise 2
7447 Given @expr{x} and @expr{y} vectors in quick variables 1 and 2 as before,
7448 the first job is to form the matrix that describes the problem.
7458 $$ m \times x + b \times 1 = y $$
7463 @texline @math{19\times2}
7465 matrix with our @expr{x} vector as one column and
7466 ones as the other column. So, first we build the column of ones, then
7467 we combine the two columns to form our @expr{A} matrix.
7471 2: [1.34, 1.41, 1.49, ... ] 1: [ [ 1.34, 1 ]
7472 1: [1, 1, 1, ...] [ 1.41, 1 ]
7476 r 1 1 v b 19 @key{RET} M-2 v p v t s 3
7482 @texline @math{A^T y}
7483 @infoline @expr{trn(A) * y}
7485 @texline @math{A^T A}
7486 @infoline @expr{trn(A) * A}
7491 1: [33.36554, 13.613] 2: [33.36554, 13.613]
7492 . 1: [ [ 98.0003, 41.63 ]
7496 v t r 2 * r 3 v t r 3 *
7501 (Hey, those numbers look familiar!)
7505 1: [0.52141679, -0.425978]
7512 Since we were solving equations of the form
7513 @texline @math{m \times x + b \times 1 = y},
7514 @infoline @expr{m*x + b*1 = y},
7515 these numbers should be @expr{m} and @expr{b}, respectively. Sure
7516 enough, they agree exactly with the result computed using @kbd{V M} and
7519 The moral of this story: @kbd{V M} and @kbd{V R} will probably solve
7520 your problem, but there is often an easier way using the higher-level
7521 arithmetic functions!
7523 @c [fix-ref Curve Fitting]
7524 In fact, there is a built-in @kbd{a F} command that does least-squares
7525 fits. @xref{Curve Fitting}.
7527 @node List Answer 3, List Answer 4, List Answer 2, Answers to Exercises
7528 @subsection List Tutorial Exercise 3
7531 Move to one end of the list and press @kbd{C-@@} (or @kbd{C-@key{SPC}} or
7532 whatever) to set the mark, then move to the other end of the list
7533 and type @w{@kbd{M-# g}}.
7537 1: [2.3, 6, 22, 15.1, 7, 15, 14, 7.5, 2.5]
7542 To make things interesting, let's assume we don't know at a glance
7543 how many numbers are in this list. Then we could type:
7547 2: [2.3, 6, 22, ... ] 2: [2.3, 6, 22, ... ]
7548 1: [2.3, 6, 22, ... ] 1: 126356422.5
7558 2: 126356422.5 2: 126356422.5 1: 7.94652913734
7559 1: [2.3, 6, 22, ... ] 1: 9 .
7567 (The @kbd{I ^} command computes the @var{n}th root of a number.
7568 You could also type @kbd{& ^} to take the reciprocal of 9 and
7569 then raise the number to that power.)
7571 @node List Answer 4, List Answer 5, List Answer 3, Answers to Exercises
7572 @subsection List Tutorial Exercise 4
7575 A number @expr{j} is a divisor of @expr{n} if
7576 @texline @math{n \mathbin{\hbox{\code{\%}}} j = 0}.
7577 @infoline @samp{n % j = 0}.
7578 The first step is to get a vector that identifies the divisors.
7582 2: 30 2: [0, 0, 0, 2, ...] 1: [1, 1, 1, 0, ...]
7583 1: [1, 2, 3, 4, ...] 1: 0 .
7586 30 @key{RET} v x 30 @key{RET} s 1 V M % 0 V M a = s 2
7591 This vector has 1's marking divisors of 30 and 0's marking non-divisors.
7593 The zeroth divisor function is just the total number of divisors.
7594 The first divisor function is the sum of the divisors.
7599 2: [1, 2, 3, 4, ...] 1: [1, 2, 3, 0, ...] 1: 72
7600 1: [1, 1, 1, 0, ...] . .
7603 V R + r 1 r 2 V M * V R +
7608 Once again, the last two steps just compute a dot product for which
7609 a simple @kbd{*} would have worked equally well.
7611 @node List Answer 5, List Answer 6, List Answer 4, Answers to Exercises
7612 @subsection List Tutorial Exercise 5
7615 The obvious first step is to obtain the list of factors with @kbd{k f}.
7616 This list will always be in sorted order, so if there are duplicates
7617 they will be right next to each other. A suitable method is to compare
7618 the list with a copy of itself shifted over by one.
7622 1: [3, 7, 7, 7, 19] 2: [3, 7, 7, 7, 19] 2: [3, 7, 7, 7, 19, 0]
7623 . 1: [3, 7, 7, 7, 19, 0] 1: [0, 3, 7, 7, 7, 19]
7626 19551 k f @key{RET} 0 | @key{TAB} 0 @key{TAB} |
7633 1: [0, 0, 1, 1, 0, 0] 1: 2 1: 0
7641 Note that we have to arrange for both vectors to have the same length
7642 so that the mapping operation works; no prime factor will ever be
7643 zero, so adding zeros on the left and right is safe. From then on
7644 the job is pretty straightforward.
7646 Incidentally, Calc provides the
7647 @texline @dfn{M@"obius} @math{\mu}
7648 @infoline @dfn{Moebius mu}
7649 function which is zero if and only if its argument is square-free. It
7650 would be a much more convenient way to do the above test in practice.
7652 @node List Answer 6, List Answer 7, List Answer 5, Answers to Exercises
7653 @subsection List Tutorial Exercise 6
7656 First use @kbd{v x 6 @key{RET}} to get a list of integers, then @kbd{V M v x}
7657 to get a list of lists of integers!
7659 @node List Answer 7, List Answer 8, List Answer 6, Answers to Exercises
7660 @subsection List Tutorial Exercise 7
7663 Here's one solution. First, compute the triangular list from the previous
7664 exercise and type @kbd{1 -} to subtract one from all the elements.
7677 The numbers down the lefthand edge of the list we desire are called
7678 the ``triangular numbers'' (now you know why!). The @expr{n}th
7679 triangular number is the sum of the integers from 1 to @expr{n}, and
7680 can be computed directly by the formula
7681 @texline @math{n (n+1) \over 2}.
7682 @infoline @expr{n * (n+1) / 2}.
7686 2: [ [0], [0, 1], ... ] 2: [ [0], [0, 1], ... ]
7687 1: [0, 1, 2, 3, 4, 5] 1: [0, 1, 3, 6, 10, 15]
7690 v x 6 @key{RET} 1 - V M ' $ ($+1)/2 @key{RET}
7695 Adding this list to the above list of lists produces the desired
7704 [10, 11, 12, 13, 14],
7705 [15, 16, 17, 18, 19, 20] ]
7712 If we did not know the formula for triangular numbers, we could have
7713 computed them using a @kbd{V U +} command. We could also have
7714 gotten them the hard way by mapping a reduction across the original
7719 2: [ [0], [0, 1], ... ] 2: [ [0], [0, 1], ... ]
7720 1: [ [0], [0, 1], ... ] 1: [0, 1, 3, 6, 10, 15]
7728 (This means ``map a @kbd{V R +} command across the vector,'' and
7729 since each element of the main vector is itself a small vector,
7730 @kbd{V R +} computes the sum of its elements.)
7732 @node List Answer 8, List Answer 9, List Answer 7, Answers to Exercises
7733 @subsection List Tutorial Exercise 8
7736 The first step is to build a list of values of @expr{x}.
7740 1: [1, 2, 3, ..., 21] 1: [0, 1, 2, ..., 20] 1: [0, 0.25, 0.5, ..., 5]
7743 v x 21 @key{RET} 1 - 4 / s 1
7747 Next, we compute the Bessel function values.
7751 1: [0., 0.124, 0.242, ..., -0.328]
7754 V M ' besJ(1,$) @key{RET}
7759 (Another way to do this would be @kbd{1 @key{TAB} V M f j}.)
7761 A way to isolate the maximum value is to compute the maximum using
7762 @kbd{V R X}, then compare all the Bessel values with that maximum.
7766 2: [0., 0.124, 0.242, ... ] 1: [0, 0, 0, ... ] 2: [0, 0, 0, ... ]
7770 @key{RET} V R X V M a = @key{RET} V R + @key{DEL}
7775 It's a good idea to verify, as in the last step above, that only
7776 one value is equal to the maximum. (After all, a plot of
7777 @texline @math{\sin x}
7778 @infoline @expr{sin(x)}
7779 might have many points all equal to the maximum value, 1.)
7781 The vector we have now has a single 1 in the position that indicates
7782 the maximum value of @expr{x}. Now it is a simple matter to convert
7783 this back into the corresponding value itself.
7787 2: [0, 0, 0, ... ] 1: [0, 0., 0., ... ] 1: 1.75
7788 1: [0, 0.25, 0.5, ... ] . .
7795 If @kbd{a =} had produced more than one @expr{1} value, this method
7796 would have given the sum of all maximum @expr{x} values; not very
7797 useful! In this case we could have used @kbd{v m} (@code{calc-mask-vector})
7798 instead. This command deletes all elements of a ``data'' vector that
7799 correspond to zeros in a ``mask'' vector, leaving us with, in this
7800 example, a vector of maximum @expr{x} values.
7802 The built-in @kbd{a X} command maximizes a function using more
7803 efficient methods. Just for illustration, let's use @kbd{a X}
7804 to maximize @samp{besJ(1,x)} over this same interval.
7808 2: besJ(1, x) 1: [1.84115, 0.581865]
7812 ' besJ(1,x), [0..5] @key{RET} a X x @key{RET}
7817 The output from @kbd{a X} is a vector containing the value of @expr{x}
7818 that maximizes the function, and the function's value at that maximum.
7819 As you can see, our simple search got quite close to the right answer.
7821 @node List Answer 9, List Answer 10, List Answer 8, Answers to Exercises
7822 @subsection List Tutorial Exercise 9
7825 Step one is to convert our integer into vector notation.
7829 1: 25129925999 3: 25129925999
7831 1: [11, 10, 9, ..., 1, 0]
7834 25129925999 @key{RET} 10 @key{RET} 12 @key{RET} v x 12 @key{RET} -
7841 1: 25129925999 1: [0, 2, 25, 251, 2512, ... ]
7842 2: [100000000000, ... ] .
7850 (Recall, the @kbd{\} command computes an integer quotient.)
7854 1: [0, 2, 5, 1, 2, 9, 9, 2, 5, 9, 9, 9]
7861 Next we must increment this number. This involves adding one to
7862 the last digit, plus handling carries. There is a carry to the
7863 left out of a digit if that digit is a nine and all the digits to
7864 the right of it are nines.
7868 1: [0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1] 1: [1, 1, 1, 0, 0, 1, ... ]
7878 1: [1, 1, 1, 0, 0, 0, ... ] 1: [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1]
7886 Accumulating @kbd{*} across a vector of ones and zeros will preserve
7887 only the initial run of ones. These are the carries into all digits
7888 except the rightmost digit. Concatenating a one on the right takes
7889 care of aligning the carries properly, and also adding one to the
7894 2: [0, 0, 0, 0, ... ] 1: [0, 0, 2, 5, 1, 2, 9, 9, 2, 6, 0, 0, 0]
7895 1: [0, 0, 2, 5, ... ] .
7898 0 r 2 | V M + 10 V M %
7903 Here we have concatenated 0 to the @emph{left} of the original number;
7904 this takes care of shifting the carries by one with respect to the
7905 digits that generated them.
7907 Finally, we must convert this list back into an integer.
7911 3: [0, 0, 2, 5, ... ] 2: [0, 0, 2, 5, ... ]
7912 2: 1000000000000 1: [1000000000000, 100000000000, ... ]
7913 1: [100000000000, ... ] .
7916 10 @key{RET} 12 ^ r 1 |
7923 1: [0, 0, 20000000000, 5000000000, ... ] 1: 25129926000
7931 Another way to do this final step would be to reduce the formula
7932 @w{@samp{10 $$ + $}} across the vector of digits.
7936 1: [0, 0, 2, 5, ... ] 1: 25129926000
7939 V R ' 10 $$ + $ @key{RET}
7943 @node List Answer 10, List Answer 11, List Answer 9, Answers to Exercises
7944 @subsection List Tutorial Exercise 10
7947 For the list @expr{[a, b, c, d]}, the result is @expr{((a = b) = c) = d},
7948 which will compare @expr{a} and @expr{b} to produce a 1 or 0, which is
7949 then compared with @expr{c} to produce another 1 or 0, which is then
7950 compared with @expr{d}. This is not at all what Joe wanted.
7952 Here's a more correct method:
7956 1: [7, 7, 7, 8, 7] 2: [7, 7, 7, 8, 7]
7960 ' [7,7,7,8,7] @key{RET} @key{RET} v r 1 @key{RET}
7967 1: [1, 1, 1, 0, 1] 1: 0
7974 @node List Answer 11, List Answer 12, List Answer 10, Answers to Exercises
7975 @subsection List Tutorial Exercise 11
7978 The circle of unit radius consists of those points @expr{(x,y)} for which
7979 @expr{x^2 + y^2 < 1}. We start by generating a vector of @expr{x^2}
7980 and a vector of @expr{y^2}.
7982 We can make this go a bit faster by using the @kbd{v .} and @kbd{t .}
7987 2: [2., 2., ..., 2.] 2: [2., 2., ..., 2.]
7988 1: [2., 2., ..., 2.] 1: [1.16, 1.98, ..., 0.81]
7991 v . t . 2. v b 100 @key{RET} @key{RET} V M k r
7998 2: [2., 2., ..., 2.] 1: [0.026, 0.96, ..., 0.036]
7999 1: [0.026, 0.96, ..., 0.036] 2: [0.53, 0.81, ..., 0.094]
8002 1 - 2 V M ^ @key{TAB} V M k r 1 - 2 V M ^
8006 Now we sum the @expr{x^2} and @expr{y^2} values, compare with 1 to
8007 get a vector of 1/0 truth values, then sum the truth values.
8011 1: [0.56, 1.78, ..., 0.13] 1: [1, 0, ..., 1] 1: 84
8019 The ratio @expr{84/100} should approximate the ratio @cpiover{4}.
8023 1: 0.84 1: 3.36 2: 3.36 1: 1.0695
8031 Our estimate, 3.36, is off by about 7%. We could get a better estimate
8032 by taking more points (say, 1000), but it's clear that this method is
8035 (Naturally, since this example uses random numbers your own answer
8036 will be slightly different from the one shown here!)
8038 If you typed @kbd{v .} and @kbd{t .} before, type them again to
8039 return to full-sized display of vectors.
8041 @node List Answer 12, List Answer 13, List Answer 11, Answers to Exercises
8042 @subsection List Tutorial Exercise 12
8045 This problem can be made a lot easier by taking advantage of some
8046 symmetries. First of all, after some thought it's clear that the
8047 @expr{y} axis can be ignored altogether. Just pick a random @expr{x}
8048 component for one end of the match, pick a random direction
8049 @texline @math{\theta},
8050 @infoline @expr{theta},
8051 and see if @expr{x} and
8052 @texline @math{x + \cos \theta}
8053 @infoline @expr{x + cos(theta)}
8054 (which is the @expr{x} coordinate of the other endpoint) cross a line.
8055 The lines are at integer coordinates, so this happens when the two
8056 numbers surround an integer.
8058 Since the two endpoints are equivalent, we may as well choose the leftmost
8059 of the two endpoints as @expr{x}. Then @expr{theta} is an angle pointing
8060 to the right, in the range -90 to 90 degrees. (We could use radians, but
8061 it would feel like cheating to refer to @cpiover{2} radians while trying
8062 to estimate @cpi{}!)
8064 In fact, since the field of lines is infinite we can choose the
8065 coordinates 0 and 1 for the lines on either side of the leftmost
8066 endpoint. The rightmost endpoint will be between 0 and 1 if the
8067 match does not cross a line, or between 1 and 2 if it does. So:
8068 Pick random @expr{x} and
8069 @texline @math{\theta},
8070 @infoline @expr{theta},
8072 @texline @math{x + \cos \theta},
8073 @infoline @expr{x + cos(theta)},
8074 and count how many of the results are greater than one. Simple!
8076 We can make this go a bit faster by using the @kbd{v .} and @kbd{t .}
8081 1: [0.52, 0.71, ..., 0.72] 2: [0.52, 0.71, ..., 0.72]
8082 . 1: [78.4, 64.5, ..., -42.9]
8085 v . t . 1. v b 100 @key{RET} V M k r 180. v b 100 @key{RET} V M k r 90 -
8090 (The next step may be slow, depending on the speed of your computer.)
8094 2: [0.52, 0.71, ..., 0.72] 1: [0.72, 1.14, ..., 1.45]
8095 1: [0.20, 0.43, ..., 0.73] .
8105 1: [0, 1, ..., 1] 1: 0.64 1: 3.125
8108 1 V M a > V R + 100 / 2 @key{TAB} /
8112 Let's try the third method, too. We'll use random integers up to
8113 one million. The @kbd{k r} command with an integer argument picks
8118 2: [1000000, 1000000, ..., 1000000] 2: [78489, 527587, ..., 814975]
8119 1: [1000000, 1000000, ..., 1000000] 1: [324014, 358783, ..., 955450]
8122 1000000 v b 100 @key{RET} @key{RET} V M k r @key{TAB} V M k r
8129 1: [1, 1, ..., 25] 1: [1, 1, ..., 0] 1: 0.56
8132 V M k g 1 V M a = V R + 100 /
8146 For a proof of this property of the GCD function, see section 4.5.2,
8147 exercise 10, of Knuth's @emph{Art of Computer Programming}, volume II.
8149 If you typed @kbd{v .} and @kbd{t .} before, type them again to
8150 return to full-sized display of vectors.
8152 @node List Answer 13, List Answer 14, List Answer 12, Answers to Exercises
8153 @subsection List Tutorial Exercise 13
8156 First, we put the string on the stack as a vector of ASCII codes.
8160 1: [84, 101, 115, ..., 51]
8163 "Testing, 1, 2, 3 @key{RET}
8168 Note that the @kbd{"} key, like @kbd{$}, initiates algebraic entry so
8169 there was no need to type an apostrophe. Also, Calc didn't mind that
8170 we omitted the closing @kbd{"}. (The same goes for all closing delimiters
8171 like @kbd{)} and @kbd{]} at the end of a formula.
8173 We'll show two different approaches here. In the first, we note that
8174 if the input vector is @expr{[a, b, c, d]}, then the hash code is
8175 @expr{3 (3 (3a + b) + c) + d = 27a + 9b + 3c + d}. In other words,
8176 it's a sum of descending powers of three times the ASCII codes.
8180 2: [84, 101, 115, ..., 51] 2: [84, 101, 115, ..., 51]
8181 1: 16 1: [15, 14, 13, ..., 0]
8184 @key{RET} v l v x 16 @key{RET} -
8191 2: [84, 101, 115, ..., 51] 1: 1960915098 1: 121
8192 1: [14348907, ..., 1] . .
8195 3 @key{TAB} V M ^ * 511 %
8200 Once again, @kbd{*} elegantly summarizes most of the computation.
8201 But there's an even more elegant approach: Reduce the formula
8202 @kbd{3 $$ + $} across the vector. Recall that this represents a
8203 function of two arguments that computes its first argument times three
8204 plus its second argument.
8208 1: [84, 101, 115, ..., 51] 1: 1960915098
8211 "Testing, 1, 2, 3 @key{RET} V R ' 3$$+$ @key{RET}
8216 If you did the decimal arithmetic exercise, this will be familiar.
8217 Basically, we're turning a base-3 vector of digits into an integer,
8218 except that our ``digits'' are much larger than real digits.
8220 Instead of typing @kbd{511 %} again to reduce the result, we can be
8221 cleverer still and notice that rather than computing a huge integer
8222 and taking the modulo at the end, we can take the modulo at each step
8223 without affecting the result. While this means there are more
8224 arithmetic operations, the numbers we operate on remain small so
8225 the operations are faster.
8229 1: [84, 101, 115, ..., 51] 1: 121
8232 "Testing, 1, 2, 3 @key{RET} V R ' (3$$+$)%511 @key{RET}
8236 Why does this work? Think about a two-step computation:
8237 @w{@expr{3 (3a + b) + c}}. Taking a result modulo 511 basically means
8238 subtracting off enough 511's to put the result in the desired range.
8239 So the result when we take the modulo after every step is,
8243 3 (3 a + b - 511 m) + c - 511 n
8249 $$ 3 (3 a + b - 511 m) + c - 511 n $$
8254 for some suitable integers @expr{m} and @expr{n}. Expanding out by
8255 the distributive law yields
8259 9 a + 3 b + c - 511*3 m - 511 n
8265 $$ 9 a + 3 b + c - 511\times3 m - 511 n $$
8270 The @expr{m} term in the latter formula is redundant because any
8271 contribution it makes could just as easily be made by the @expr{n}
8272 term. So we can take it out to get an equivalent formula with
8277 9 a + 3 b + c - 511 n'
8283 $$ 9 a + 3 b + c - 511 n' $$
8288 which is just the formula for taking the modulo only at the end of
8289 the calculation. Therefore the two methods are essentially the same.
8291 Later in the tutorial we will encounter @dfn{modulo forms}, which
8292 basically automate the idea of reducing every intermediate result
8293 modulo some value @var{m}.
8295 @node List Answer 14, Types Answer 1, List Answer 13, Answers to Exercises
8296 @subsection List Tutorial Exercise 14
8298 We want to use @kbd{H V U} to nest a function which adds a random
8299 step to an @expr{(x,y)} coordinate. The function is a bit long, but
8300 otherwise the problem is quite straightforward.
8304 2: [0, 0] 1: [ [ 0, 0 ]
8305 1: 50 [ 0.4288, -0.1695 ]
8306 . [ -0.4787, -0.9027 ]
8309 [0,0] 50 H V U ' <# + [random(2.0)-1, random(2.0)-1]> @key{RET}
8313 Just as the text recommended, we used @samp{< >} nameless function
8314 notation to keep the two @code{random} calls from being evaluated
8315 before nesting even begins.
8317 We now have a vector of @expr{[x, y]} sub-vectors, which by Calc's
8318 rules acts like a matrix. We can transpose this matrix and unpack
8319 to get a pair of vectors, @expr{x} and @expr{y}, suitable for graphing.
8323 2: [ 0, 0.4288, -0.4787, ... ]
8324 1: [ 0, -0.1696, -0.9027, ... ]
8331 Incidentally, because the @expr{x} and @expr{y} are completely
8332 independent in this case, we could have done two separate commands
8333 to create our @expr{x} and @expr{y} vectors of numbers directly.
8335 To make a random walk of unit steps, we note that @code{sincos} of
8336 a random direction exactly gives us an @expr{[x, y]} step of unit
8337 length; in fact, the new nesting function is even briefer, though
8338 we might want to lower the precision a bit for it.
8342 2: [0, 0] 1: [ [ 0, 0 ]
8343 1: 50 [ 0.1318, 0.9912 ]
8344 . [ -0.5965, 0.3061 ]
8347 [0,0] 50 m d p 6 @key{RET} H V U ' <# + sincos(random(360.0))> @key{RET}
8351 Another @kbd{v t v u g f} sequence will graph this new random walk.
8353 An interesting twist on these random walk functions would be to use
8354 complex numbers instead of 2-vectors to represent points on the plane.
8355 In the first example, we'd use something like @samp{random + random*(0,1)},
8356 and in the second we could use polar complex numbers with random phase
8357 angles. (This exercise was first suggested in this form by Randal
8360 @node Types Answer 1, Types Answer 2, List Answer 14, Answers to Exercises
8361 @subsection Types Tutorial Exercise 1
8364 If the number is the square root of @cpi{} times a rational number,
8365 then its square, divided by @cpi{}, should be a rational number.
8369 1: 1.26508260337 1: 0.509433962268 1: 2486645810:4881193627
8377 Technically speaking this is a rational number, but not one that is
8378 likely to have arisen in the original problem. More likely, it just
8379 happens to be the fraction which most closely represents some
8380 irrational number to within 12 digits.
8382 But perhaps our result was not quite exact. Let's reduce the
8383 precision slightly and try again:
8387 1: 0.509433962268 1: 27:53
8390 U p 10 @key{RET} c F
8395 Aha! It's unlikely that an irrational number would equal a fraction
8396 this simple to within ten digits, so our original number was probably
8397 @texline @math{\sqrt{27 \pi / 53}}.
8398 @infoline @expr{sqrt(27 pi / 53)}.
8400 Notice that we didn't need to re-round the number when we reduced the
8401 precision. Remember, arithmetic operations always round their inputs
8402 to the current precision before they begin.
8404 @node Types Answer 2, Types Answer 3, Types Answer 1, Answers to Exercises
8405 @subsection Types Tutorial Exercise 2
8408 @samp{inf / inf = nan}. Perhaps @samp{1} is the ``obvious'' answer.
8409 But if @w{@samp{17 inf = inf}}, then @samp{17 inf / inf = inf / inf = 17}, too.
8411 @samp{exp(inf) = inf}. It's tempting to say that the exponential
8412 of infinity must be ``bigger'' than ``regular'' infinity, but as
8413 far as Calc is concerned all infinities are as just as big.
8414 In other words, as @expr{x} goes to infinity, @expr{e^x} also goes
8415 to infinity, but the fact the @expr{e^x} grows much faster than
8416 @expr{x} is not relevant here.
8418 @samp{exp(-inf) = 0}. Here we have a finite answer even though
8419 the input is infinite.
8421 @samp{sqrt(-inf) = (0, 1) inf}. Remember that @expr{(0, 1)}
8422 represents the imaginary number @expr{i}. Here's a derivation:
8423 @samp{sqrt(-inf) = @w{sqrt((-1) * inf)} = sqrt(-1) * sqrt(inf)}.
8424 The first part is, by definition, @expr{i}; the second is @code{inf}
8425 because, once again, all infinities are the same size.
8427 @samp{sqrt(uinf) = uinf}. In fact, we do know something about the
8428 direction because @code{sqrt} is defined to return a value in the
8429 right half of the complex plane. But Calc has no notation for this,
8430 so it settles for the conservative answer @code{uinf}.
8432 @samp{abs(uinf) = inf}. No matter which direction @expr{x} points,
8433 @samp{abs(x)} always points along the positive real axis.
8435 @samp{ln(0) = -inf}. Here we have an infinite answer to a finite
8436 input. As in the @expr{1 / 0} case, Calc will only use infinities
8437 here if you have turned on Infinite mode. Otherwise, it will
8438 treat @samp{ln(0)} as an error.
8440 @node Types Answer 3, Types Answer 4, Types Answer 2, Answers to Exercises
8441 @subsection Types Tutorial Exercise 3
8444 We can make @samp{inf - inf} be any real number we like, say,
8445 @expr{a}, just by claiming that we added @expr{a} to the first
8446 infinity but not to the second. This is just as true for complex
8447 values of @expr{a}, so @code{nan} can stand for a complex number.
8448 (And, similarly, @code{uinf} can stand for an infinity that points
8449 in any direction in the complex plane, such as @samp{(0, 1) inf}).
8451 In fact, we can multiply the first @code{inf} by two. Surely
8452 @w{@samp{2 inf - inf = inf}}, but also @samp{2 inf - inf = inf - inf = nan}.
8453 So @code{nan} can even stand for infinity. Obviously it's just
8454 as easy to make it stand for minus infinity as for plus infinity.
8456 The moral of this story is that ``infinity'' is a slippery fish
8457 indeed, and Calc tries to handle it by having a very simple model
8458 for infinities (only the direction counts, not the ``size''); but
8459 Calc is careful to write @code{nan} any time this simple model is
8460 unable to tell what the true answer is.
8462 @node Types Answer 4, Types Answer 5, Types Answer 3, Answers to Exercises
8463 @subsection Types Tutorial Exercise 4
8467 2: 0@@ 47' 26" 1: 0@@ 2' 47.411765"
8471 0@@ 47' 26" @key{RET} 17 /
8476 The average song length is two minutes and 47.4 seconds.
8480 2: 0@@ 2' 47.411765" 1: 0@@ 3' 7.411765" 1: 0@@ 53' 6.000005"
8489 The album would be 53 minutes and 6 seconds long.
8491 @node Types Answer 5, Types Answer 6, Types Answer 4, Answers to Exercises
8492 @subsection Types Tutorial Exercise 5
8495 Let's suppose it's January 14, 1991. The easiest thing to do is
8496 to keep trying 13ths of months until Calc reports a Friday.
8497 We can do this by manually entering dates, or by using @kbd{t I}:
8501 1: <Wed Feb 13, 1991> 1: <Wed Mar 13, 1991> 1: <Sat Apr 13, 1991>
8504 ' <2/13> @key{RET} @key{DEL} ' <3/13> @key{RET} t I
8509 (Calc assumes the current year if you don't say otherwise.)
8511 This is getting tedious---we can keep advancing the date by typing
8512 @kbd{t I} over and over again, but let's automate the job by using
8513 vector mapping. The @kbd{t I} command actually takes a second
8514 ``how-many-months'' argument, which defaults to one. This
8515 argument is exactly what we want to map over:
8519 2: <Sat Apr 13, 1991> 1: [<Mon May 13, 1991>, <Thu Jun 13, 1991>,
8520 1: [1, 2, 3, 4, 5, 6] <Sat Jul 13, 1991>, <Tue Aug 13, 1991>,
8521 . <Fri Sep 13, 1991>, <Sun Oct 13, 1991>]
8524 v x 6 @key{RET} V M t I
8529 Et voil@`a, September 13, 1991 is a Friday.
8536 ' <sep 13> - <jan 14> @key{RET}
8541 And the answer to our original question: 242 days to go.
8543 @node Types Answer 6, Types Answer 7, Types Answer 5, Answers to Exercises
8544 @subsection Types Tutorial Exercise 6
8547 The full rule for leap years is that they occur in every year divisible
8548 by four, except that they don't occur in years divisible by 100, except
8549 that they @emph{do} in years divisible by 400. We could work out the
8550 answer by carefully counting the years divisible by four and the
8551 exceptions, but there is a much simpler way that works even if we
8552 don't know the leap year rule.
8554 Let's assume the present year is 1991. Years have 365 days, except
8555 that leap years (whenever they occur) have 366 days. So let's count
8556 the number of days between now and then, and compare that to the
8557 number of years times 365. The number of extra days we find must be
8558 equal to the number of leap years there were.
8562 1: <Mon Jan 1, 10001> 2: <Mon Jan 1, 10001> 1: 2925593
8563 . 1: <Tue Jan 1, 1991> .
8566 ' <jan 1 10001> @key{RET} ' <jan 1 1991> @key{RET} -
8573 3: 2925593 2: 2925593 2: 2925593 1: 1943
8574 2: 10001 1: 8010 1: 2923650 .
8578 10001 @key{RET} 1991 - 365 * -
8582 @c [fix-ref Date Forms]
8584 There will be 1943 leap years before the year 10001. (Assuming,
8585 of course, that the algorithm for computing leap years remains
8586 unchanged for that long. @xref{Date Forms}, for some interesting
8587 background information in that regard.)
8589 @node Types Answer 7, Types Answer 8, Types Answer 6, Answers to Exercises
8590 @subsection Types Tutorial Exercise 7
8593 The relative errors must be converted to absolute errors so that
8594 @samp{+/-} notation may be used.
8602 20 @key{RET} .05 * 4 @key{RET} .05 *
8606 Now we simply chug through the formula.
8610 1: 19.7392088022 1: 394.78 +/- 19.739 1: 6316.5 +/- 706.21
8613 2 P 2 ^ * 20 p 1 * 4 p .2 @key{RET} 2 ^ *
8617 It turns out the @kbd{v u} command will unpack an error form as
8618 well as a vector. This saves us some retyping of numbers.
8622 3: 6316.5 +/- 706.21 2: 6316.5 +/- 706.21
8627 @key{RET} v u @key{TAB} /
8632 Thus the volume is 6316 cubic centimeters, within about 11 percent.
8634 @node Types Answer 8, Types Answer 9, Types Answer 7, Answers to Exercises
8635 @subsection Types Tutorial Exercise 8
8638 The first answer is pretty simple: @samp{1 / (0 .. 10) = (0.1 .. inf)}.
8639 Since a number in the interval @samp{(0 .. 10)} can get arbitrarily
8640 close to zero, its reciprocal can get arbitrarily large, so the answer
8641 is an interval that effectively means, ``any number greater than 0.1''
8642 but with no upper bound.
8644 The second answer, similarly, is @samp{1 / (-10 .. 0) = (-inf .. -0.1)}.
8646 Calc normally treats division by zero as an error, so that the formula
8647 @w{@samp{1 / 0}} is left unsimplified. Our third problem,
8648 @w{@samp{1 / [0 .. 10]}}, also (potentially) divides by zero because zero
8649 is now a member of the interval. So Calc leaves this one unevaluated, too.
8651 If you turn on Infinite mode by pressing @kbd{m i}, you will
8652 instead get the answer @samp{[0.1 .. inf]}, which includes infinity
8653 as a possible value.
8655 The fourth calculation, @samp{1 / (-10 .. 10)}, has the same problem.
8656 Zero is buried inside the interval, but it's still a possible value.
8657 It's not hard to see that the actual result of @samp{1 / (-10 .. 10)}
8658 will be either greater than @mathit{0.1}, or less than @mathit{-0.1}. Thus
8659 the interval goes from minus infinity to plus infinity, with a ``hole''
8660 in it from @mathit{-0.1} to @mathit{0.1}. Calc doesn't have any way to
8661 represent this, so it just reports @samp{[-inf .. inf]} as the answer.
8662 It may be disappointing to hear ``the answer lies somewhere between
8663 minus infinity and plus infinity, inclusive,'' but that's the best
8664 that interval arithmetic can do in this case.
8666 @node Types Answer 9, Types Answer 10, Types Answer 8, Answers to Exercises
8667 @subsection Types Tutorial Exercise 9
8671 1: [-3 .. 3] 2: [-3 .. 3] 2: [0 .. 9]
8672 . 1: [0 .. 9] 1: [-9 .. 9]
8675 [ 3 n .. 3 ] @key{RET} 2 ^ @key{TAB} @key{RET} *
8680 In the first case the result says, ``if a number is between @mathit{-3} and
8681 3, its square is between 0 and 9.'' The second case says, ``the product
8682 of two numbers each between @mathit{-3} and 3 is between @mathit{-9} and 9.''
8684 An interval form is not a number; it is a symbol that can stand for
8685 many different numbers. Two identical-looking interval forms can stand
8686 for different numbers.
8688 The same issue arises when you try to square an error form.
8690 @node Types Answer 10, Types Answer 11, Types Answer 9, Answers to Exercises
8691 @subsection Types Tutorial Exercise 10
8694 Testing the first number, we might arbitrarily choose 17 for @expr{x}.
8698 1: 17 mod 811749613 2: 17 mod 811749613 1: 533694123 mod 811749613
8702 17 M 811749613 @key{RET} 811749612 ^
8707 Since 533694123 is (considerably) different from 1, the number 811749613
8710 It's awkward to type the number in twice as we did above. There are
8711 various ways to avoid this, and algebraic entry is one. In fact, using
8712 a vector mapping operation we can perform several tests at once. Let's
8713 use this method to test the second number.
8717 2: [17, 42, 100000] 1: [1 mod 15485863, 1 mod ... ]
8721 [17 42 100000] 15485863 @key{RET} V M ' ($$ mod $)^($-1) @key{RET}
8726 The result is three ones (modulo @expr{n}), so it's very probable that
8727 15485863 is prime. (In fact, this number is the millionth prime.)
8729 Note that the functions @samp{($$^($-1)) mod $} or @samp{$$^($-1) % $}
8730 would have been hopelessly inefficient, since they would have calculated
8731 the power using full integer arithmetic.
8733 Calc has a @kbd{k p} command that does primality testing. For small
8734 numbers it does an exact test; for large numbers it uses a variant
8735 of the Fermat test we used here. You can use @kbd{k p} repeatedly
8736 to prove that a large integer is prime with any desired probability.
8738 @node Types Answer 11, Types Answer 12, Types Answer 10, Answers to Exercises
8739 @subsection Types Tutorial Exercise 11
8742 There are several ways to insert a calculated number into an HMS form.
8743 One way to convert a number of seconds to an HMS form is simply to
8744 multiply the number by an HMS form representing one second:
8748 1: 31415926.5359 2: 31415926.5359 1: 8726@@ 38' 46.5359"
8759 2: 8726@@ 38' 46.5359" 1: 6@@ 6' 2.5359" mod 24@@ 0' 0"
8760 1: 15@@ 27' 16" mod 24@@ 0' 0" .
8768 It will be just after six in the morning.
8770 The algebraic @code{hms} function can also be used to build an
8775 1: hms(0, 0, 10000000. pi) 1: 8726@@ 38' 46.5359"
8778 ' hms(0, 0, 1e7 pi) @key{RET} =
8783 The @kbd{=} key is necessary to evaluate the symbol @samp{pi} to
8784 the actual number 3.14159...
8786 @node Types Answer 12, Types Answer 13, Types Answer 11, Answers to Exercises
8787 @subsection Types Tutorial Exercise 12
8790 As we recall, there are 17 songs of about 2 minutes and 47 seconds
8795 2: 0@@ 2' 47" 1: [0@@ 3' 7" .. 0@@ 3' 47"]
8796 1: [0@@ 0' 20" .. 0@@ 1' 0"] .
8799 [ 0@@ 20" .. 0@@ 1' ] +
8806 1: [0@@ 52' 59." .. 1@@ 4' 19."]
8814 No matter how long it is, the album will fit nicely on one CD.
8816 @node Types Answer 13, Types Answer 14, Types Answer 12, Answers to Exercises
8817 @subsection Types Tutorial Exercise 13
8820 Type @kbd{' 1 yr @key{RET} u c s @key{RET}}. The answer is 31557600 seconds.
8822 @node Types Answer 14, Types Answer 15, Types Answer 13, Answers to Exercises
8823 @subsection Types Tutorial Exercise 14
8826 How long will it take for a signal to get from one end of the computer
8831 1: m / c 1: 3.3356 ns
8834 ' 1 m / c @key{RET} u c ns @key{RET}
8839 (Recall, @samp{c} is a ``unit'' corresponding to the speed of light.)
8843 1: 3.3356 ns 1: 0.81356 ns / ns 1: 0.81356
8847 ' 4.1 ns @key{RET} / u s
8852 Thus a signal could take up to 81 percent of a clock cycle just to
8853 go from one place to another inside the computer, assuming the signal
8854 could actually attain the full speed of light. Pretty tight!
8856 @node Types Answer 15, Algebra Answer 1, Types Answer 14, Answers to Exercises
8857 @subsection Types Tutorial Exercise 15
8860 The speed limit is 55 miles per hour on most highways. We want to
8861 find the ratio of Sam's speed to the US speed limit.
8865 1: 55 mph 2: 55 mph 3: 11 hr mph / yd
8869 ' 55 mph @key{RET} ' 5 yd/hr @key{RET} /
8873 The @kbd{u s} command cancels out these units to get a plain
8874 number. Now we take the logarithm base two to find the final
8875 answer, assuming that each successive pill doubles his speed.
8879 1: 19360. 2: 19360. 1: 14.24
8888 Thus Sam can take up to 14 pills without a worry.
8890 @node Algebra Answer 1, Algebra Answer 2, Types Answer 15, Answers to Exercises
8891 @subsection Algebra Tutorial Exercise 1
8894 @c [fix-ref Declarations]
8895 The result @samp{sqrt(x)^2} is simplified back to @expr{x} by the
8896 Calculator, but @samp{sqrt(x^2)} is not. (Consider what happens
8897 if @w{@expr{x = -4}}.) If @expr{x} is real, this formula could be
8898 simplified to @samp{abs(x)}, but for general complex arguments even
8899 that is not safe. (@xref{Declarations}, for a way to tell Calc
8900 that @expr{x} is known to be real.)
8902 @node Algebra Answer 2, Algebra Answer 3, Algebra Answer 1, Answers to Exercises
8903 @subsection Algebra Tutorial Exercise 2
8906 Suppose our roots are @expr{[a, b, c]}. We want a polynomial which
8907 is zero when @expr{x} is any of these values. The trivial polynomial
8908 @expr{x-a} is zero when @expr{x=a}, so the product @expr{(x-a)(x-b)(x-c)}
8909 will do the job. We can use @kbd{a c x} to write this in a more
8914 1: 34 x - 24 x^3 1: [1.19023, -1.19023, 0]
8924 1: [x - 1.19023, x + 1.19023, x] 1: (x - 1.19023) (x + 1.19023) x
8927 V M ' x-$ @key{RET} V R *
8934 1: x^3 - 1.41666 x 1: 34 x - 24 x^3
8937 a c x @key{RET} 24 n * a x
8942 Sure enough, our answer (multiplied by a suitable constant) is the
8943 same as the original polynomial.
8945 @node Algebra Answer 3, Algebra Answer 4, Algebra Answer 2, Answers to Exercises
8946 @subsection Algebra Tutorial Exercise 3
8950 1: x sin(pi x) 1: (sin(pi x) - pi x cos(pi x)) / pi^2
8953 ' x sin(pi x) @key{RET} m r a i x @key{RET}
8961 2: (sin(pi x) - pi x cos(pi x)) / pi^2
8964 ' [y,1] @key{RET} @key{TAB}
8971 1: [(sin(pi y) - pi y cos(pi y)) / pi^2, (sin(pi) - pi cos(pi)) / pi^2]
8981 1: (sin(pi y) - pi y cos(pi y)) / pi^2 + (pi cos(pi) - sin(pi)) / pi^2
8991 1: (sin(3.14159 y) - 3.14159 y cos(3.14159 y)) / 9.8696 - 0.3183
9001 1: [0., -0.95493, 0.63662, -1.5915, 1.2732]
9004 v x 5 @key{RET} @key{TAB} V M $ @key{RET}
9008 @node Algebra Answer 4, Rewrites Answer 1, Algebra Answer 3, Answers to Exercises
9009 @subsection Algebra Tutorial Exercise 4
9012 The hard part is that @kbd{V R +} is no longer sufficient to add up all
9013 the contributions from the slices, since the slices have varying
9014 coefficients. So first we must come up with a vector of these
9015 coefficients. Here's one way:
9019 2: -1 2: 3 1: [4, 2, ..., 4]
9020 1: [1, 2, ..., 9] 1: [-1, 1, ..., -1] .
9023 1 n v x 9 @key{RET} V M ^ 3 @key{TAB} -
9030 1: [4, 2, ..., 4, 1] 1: [1, 4, 2, ..., 4, 1]
9038 Now we compute the function values. Note that for this method we need
9039 eleven values, including both endpoints of the desired interval.
9043 2: [1, 4, 2, ..., 4, 1]
9044 1: [1, 1.1, 1.2, ... , 1.8, 1.9, 2.]
9047 11 @key{RET} 1 @key{RET} .1 @key{RET} C-u v x
9054 2: [1, 4, 2, ..., 4, 1]
9055 1: [0., 0.084941, 0.16993, ... ]
9058 ' sin(x) ln(x) @key{RET} m r p 5 @key{RET} V M $ @key{RET}
9063 Once again this calls for @kbd{V M * V R +}; a simple @kbd{*} does the
9068 1: 11.22 1: 1.122 1: 0.374
9076 Wow! That's even better than the result from the Taylor series method.
9078 @node Rewrites Answer 1, Rewrites Answer 2, Algebra Answer 4, Answers to Exercises
9079 @subsection Rewrites Tutorial Exercise 1
9082 We'll use Big mode to make the formulas more readable.
9088 1: (2 + sqrt(2)) / (1 + sqrt(2)) 1: --------
9094 ' (2+sqrt(2)) / (1+sqrt(2)) @key{RET} d B
9099 Multiplying by the conjugate helps because @expr{(a+b) (a-b) = a^2 - b^2}.
9104 1: (2 + V 2 ) (V 2 - 1)
9107 a r a/(b+c) := a*(b-c) / (b^2-c^2) @key{RET}
9115 1: 2 + V 2 - 2 1: V 2
9118 a r a*(b+c) := a*b + a*c a s
9123 (We could have used @kbd{a x} instead of a rewrite rule for the
9126 The multiply-by-conjugate rule turns out to be useful in many
9127 different circumstances, such as when the denominator involves
9128 sines and cosines or the imaginary constant @code{i}.
9130 @node Rewrites Answer 2, Rewrites Answer 3, Rewrites Answer 1, Answers to Exercises
9131 @subsection Rewrites Tutorial Exercise 2
9134 Here is the rule set:
9138 [ fib(n) := fib(n, 1, 1) :: integer(n) :: n >= 1,
9140 fib(n, x, y) := fib(n-1, y, x+y) ]
9145 The first rule turns a one-argument @code{fib} that people like to write
9146 into a three-argument @code{fib} that makes computation easier. The
9147 second rule converts back from three-argument form once the computation
9148 is done. The third rule does the computation itself. It basically
9149 says that if @expr{x} and @expr{y} are two consecutive Fibonacci numbers,
9150 then @expr{y} and @expr{x+y} are the next (overlapping) pair of Fibonacci
9153 Notice that because the number @expr{n} was ``validated'' by the
9154 conditions on the first rule, there is no need to put conditions on
9155 the other rules because the rule set would never get that far unless
9156 the input were valid. That further speeds computation, since no
9157 extra conditions need to be checked at every step.
9159 Actually, a user with a nasty sense of humor could enter a bad
9160 three-argument @code{fib} call directly, say, @samp{fib(0, 1, 1)},
9161 which would get the rules into an infinite loop. One thing that would
9162 help keep this from happening by accident would be to use something like
9163 @samp{ZzFib} instead of @code{fib} as the name of the three-argument
9166 @node Rewrites Answer 3, Rewrites Answer 4, Rewrites Answer 2, Answers to Exercises
9167 @subsection Rewrites Tutorial Exercise 3
9170 He got an infinite loop. First, Calc did as expected and rewrote
9171 @w{@samp{2 + 3 x}} to @samp{f(2, 3, x)}. Then it looked for ways to
9172 apply the rule again, and found that @samp{f(2, 3, x)} looks like
9173 @samp{a + b x} with @w{@samp{a = 0}} and @samp{b = 1}, so it rewrote to
9174 @samp{f(0, 1, f(2, 3, x))}. It then wrapped another @samp{f(0, 1, ...)}
9175 around that, and so on, ad infinitum. Joe should have used @kbd{M-1 a r}
9176 to make sure the rule applied only once.
9178 (Actually, even the first step didn't work as he expected. What Calc
9179 really gives for @kbd{M-1 a r} in this situation is @samp{f(3 x, 1, 2)},
9180 treating 2 as the ``variable,'' and @samp{3 x} as a constant being added
9181 to it. While this may seem odd, it's just as valid a solution as the
9182 ``obvious'' one. One way to fix this would be to add the condition
9183 @samp{:: variable(x)} to the rule, to make sure the thing that matches
9184 @samp{x} is indeed a variable, or to change @samp{x} to @samp{quote(x)}
9185 on the lefthand side, so that the rule matches the actual variable
9186 @samp{x} rather than letting @samp{x} stand for something else.)
9188 @node Rewrites Answer 4, Rewrites Answer 5, Rewrites Answer 3, Answers to Exercises
9189 @subsection Rewrites Tutorial Exercise 4
9196 Here is a suitable set of rules to solve the first part of the problem:
9200 [ seq(n, c) := seq(n/2, c+1) :: n%2 = 0,
9201 seq(n, c) := seq(3n+1, c+1) :: n%2 = 1 :: n > 1 ]
9205 Given the initial formula @samp{seq(6, 0)}, application of these
9206 rules produces the following sequence of formulas:
9220 whereupon neither of the rules match, and rewriting stops.
9222 We can pretty this up a bit with a couple more rules:
9226 [ seq(n) := seq(n, 0),
9233 Now, given @samp{seq(6)} as the starting configuration, we get 8
9236 The change to return a vector is quite simple:
9240 [ seq(n) := seq(n, []) :: integer(n) :: n > 0,
9242 seq(n, v) := seq(n/2, v | n) :: n%2 = 0,
9243 seq(n, v) := seq(3n+1, v | n) :: n%2 = 1 ]
9248 Given @samp{seq(6)}, the result is @samp{[6, 3, 10, 5, 16, 8, 4, 2, 1]}.
9250 Notice that the @expr{n > 1} guard is no longer necessary on the last
9251 rule since the @expr{n = 1} case is now detected by another rule.
9252 But a guard has been added to the initial rule to make sure the
9253 initial value is suitable before the computation begins.
9255 While still a good idea, this guard is not as vitally important as it
9256 was for the @code{fib} function, since calling, say, @samp{seq(x, [])}
9257 will not get into an infinite loop. Calc will not be able to prove
9258 the symbol @samp{x} is either even or odd, so none of the rules will
9259 apply and the rewrites will stop right away.
9261 @node Rewrites Answer 5, Rewrites Answer 6, Rewrites Answer 4, Answers to Exercises
9262 @subsection Rewrites Tutorial Exercise 5
9269 If @expr{x} is the sum @expr{a + b}, then `@tfn{nterms(}@var{x}@tfn{)}' must
9270 be `@tfn{nterms(}@var{a}@tfn{)}' plus `@tfn{nterms(}@var{b}@tfn{)}'. If @expr{x}
9271 is not a sum, then `@tfn{nterms(}@var{x}@tfn{)}' = 1.
9275 [ nterms(a + b) := nterms(a) + nterms(b),
9281 Here we have taken advantage of the fact that earlier rules always
9282 match before later rules; @samp{nterms(x)} will only be tried if we
9283 already know that @samp{x} is not a sum.
9285 @node Rewrites Answer 6, Programming Answer 1, Rewrites Answer 5, Answers to Exercises
9286 @subsection Rewrites Tutorial Exercise 6
9289 Here is a rule set that will do the job:
9293 [ a*(b + c) := a*b + a*c,
9294 opt(a) O(x^n) + opt(b) O(x^m) := O(x^n) :: n <= m
9295 :: constant(a) :: constant(b),
9296 opt(a) O(x^n) + opt(b) x^m := O(x^n) :: n <= m
9297 :: constant(a) :: constant(b),
9298 a O(x^n) := O(x^n) :: constant(a),
9299 x^opt(m) O(x^n) := O(x^(n+m)),
9300 O(x^n) O(x^m) := O(x^(n+m)) ]
9304 If we really want the @kbd{+} and @kbd{*} keys to operate naturally
9305 on power series, we should put these rules in @code{EvalRules}. For
9306 testing purposes, it is better to put them in a different variable,
9307 say, @code{O}, first.
9309 The first rule just expands products of sums so that the rest of the
9310 rules can assume they have an expanded-out polynomial to work with.
9311 Note that this rule does not mention @samp{O} at all, so it will
9312 apply to any product-of-sum it encounters---this rule may surprise
9313 you if you put it into @code{EvalRules}!
9315 In the second rule, the sum of two O's is changed to the smaller O.
9316 The optional constant coefficients are there mostly so that
9317 @samp{O(x^2) - O(x^3)} and @samp{O(x^3) - O(x^2)} are handled
9318 as well as @samp{O(x^2) + O(x^3)}.
9320 The third rule absorbs higher powers of @samp{x} into O's.
9322 The fourth rule says that a constant times a negligible quantity
9323 is still negligible. (This rule will also match @samp{O(x^3) / 4},
9324 with @samp{a = 1/4}.)
9326 The fifth rule rewrites, for example, @samp{x^2 O(x^3)} to @samp{O(x^5)}.
9327 (It is easy to see that if one of these forms is negligible, the other
9328 is, too.) Notice the @samp{x^opt(m)} to pick up terms like
9329 @w{@samp{x O(x^3)}}. Optional powers will match @samp{x} as @samp{x^1}
9330 but not 1 as @samp{x^0}. This turns out to be exactly what we want here.
9332 The sixth rule is the corresponding rule for products of two O's.
9334 Another way to solve this problem would be to create a new ``data type''
9335 that represents truncated power series. We might represent these as
9336 function calls @samp{series(@var{coefs}, @var{x})} where @var{coefs} is
9337 a vector of coefficients for @expr{x^0}, @expr{x^1}, @expr{x^2}, and so
9338 on. Rules would exist for sums and products of such @code{series}
9339 objects, and as an optional convenience could also know how to combine a
9340 @code{series} object with a normal polynomial. (With this, and with a
9341 rule that rewrites @samp{O(x^n)} to the equivalent @code{series} form,
9342 you could still enter power series in exactly the same notation as
9343 before.) Operations on such objects would probably be more efficient,
9344 although the objects would be a bit harder to read.
9346 @c [fix-ref Compositions]
9347 Some other symbolic math programs provide a power series data type
9348 similar to this. Mathematica, for example, has an object that looks
9349 like @samp{PowerSeries[@var{x}, @var{x0}, @var{coefs}, @var{nmin},
9350 @var{nmax}, @var{den}]}, where @var{x0} is the point about which the
9351 power series is taken (we've been assuming this was always zero),
9352 and @var{nmin}, @var{nmax}, and @var{den} allow pseudo-power-series
9353 with fractional or negative powers. Also, the @code{PowerSeries}
9354 objects have a special display format that makes them look like
9355 @samp{2 x^2 + O(x^4)} when they are printed out. (@xref{Compositions},
9356 for a way to do this in Calc, although for something as involved as
9357 this it would probably be better to write the formatting routine
9360 @node Programming Answer 1, Programming Answer 2, Rewrites Answer 6, Answers to Exercises
9361 @subsection Programming Tutorial Exercise 1
9364 Just enter the formula @samp{ninteg(sin(t)/t, t, 0, x)}, type
9365 @kbd{Z F}, and answer the questions. Since this formula contains two
9366 variables, the default argument list will be @samp{(t x)}. We want to
9367 change this to @samp{(x)} since @expr{t} is really a dummy variable
9368 to be used within @code{ninteg}.
9370 The exact keystrokes are @kbd{Z F s Si @key{RET} @key{RET} C-b C-b @key{DEL} @key{DEL} @key{RET} y}.
9371 (The @kbd{C-b C-b @key{DEL} @key{DEL}} are what fix the argument list.)
9373 @node Programming Answer 2, Programming Answer 3, Programming Answer 1, Answers to Exercises
9374 @subsection Programming Tutorial Exercise 2
9377 One way is to move the number to the top of the stack, operate on
9378 it, then move it back: @kbd{C-x ( M-@key{TAB} n M-@key{TAB} M-@key{TAB} C-x )}.
9380 Another way is to negate the top three stack entries, then negate
9381 again the top two stack entries: @kbd{C-x ( M-3 n M-2 n C-x )}.
9383 Finally, it turns out that a negative prefix argument causes a
9384 command like @kbd{n} to operate on the specified stack entry only,
9385 which is just what we want: @kbd{C-x ( M-- 3 n C-x )}.
9387 Just for kicks, let's also do it algebraically:
9388 @w{@kbd{C-x ( ' -$$$, $$, $ @key{RET} C-x )}}.
9390 @node Programming Answer 3, Programming Answer 4, Programming Answer 2, Answers to Exercises
9391 @subsection Programming Tutorial Exercise 3
9394 Each of these functions can be computed using the stack, or using
9395 algebraic entry, whichever way you prefer:
9399 @texline @math{\displaystyle{\sin x \over x}}:
9400 @infoline @expr{sin(x) / x}:
9402 Using the stack: @kbd{C-x ( @key{RET} S @key{TAB} / C-x )}.
9404 Using algebraic entry: @kbd{C-x ( ' sin($)/$ @key{RET} C-x )}.
9407 Computing the logarithm:
9409 Using the stack: @kbd{C-x ( @key{TAB} B C-x )}
9411 Using algebraic entry: @kbd{C-x ( ' log($,$$) @key{RET} C-x )}.
9414 Computing the vector of integers:
9416 Using the stack: @kbd{C-x ( 1 @key{RET} 1 C-u v x C-x )}. (Recall that
9417 @kbd{C-u v x} takes the vector size, starting value, and increment
9420 Alternatively: @kbd{C-x ( ~ v x C-x )}. (The @kbd{~} key pops a
9421 number from the stack and uses it as the prefix argument for the
9424 Using algebraic entry: @kbd{C-x ( ' index($) @key{RET} C-x )}.
9426 @node Programming Answer 4, Programming Answer 5, Programming Answer 3, Answers to Exercises
9427 @subsection Programming Tutorial Exercise 4
9430 Here's one way: @kbd{C-x ( @key{RET} V R + @key{TAB} v l / C-x )}.
9432 @node Programming Answer 5, Programming Answer 6, Programming Answer 4, Answers to Exercises
9433 @subsection Programming Tutorial Exercise 5
9437 2: 1 1: 1.61803398502 2: 1.61803398502
9438 1: 20 . 1: 1.61803398875
9441 1 @key{RET} 20 Z < & 1 + Z > I H P
9446 This answer is quite accurate.
9448 @node Programming Answer 6, Programming Answer 7, Programming Answer 5, Answers to Exercises
9449 @subsection Programming Tutorial Exercise 6
9455 [ [ 0, 1 ] * [a, b] = [b, a + b]
9460 Thus @samp{[0, 1; 1, 1]^n * [1, 1]} computes Fibonacci numbers @expr{n+1}
9461 and @expr{n+2}. Here's one program that does the job:
9464 C-x ( ' [0, 1; 1, 1] ^ ($-1) * [1, 1] @key{RET} v u @key{DEL} C-x )
9468 This program is quite efficient because Calc knows how to raise a
9469 matrix (or other value) to the power @expr{n} in only
9470 @texline @math{\log_2 n}
9471 @infoline @expr{log(n,2)}
9472 steps. For example, this program can compute the 1000th Fibonacci
9473 number (a 209-digit integer!) in about 10 steps; even though the
9474 @kbd{Z < ... Z >} solution had much simpler steps, it would have
9475 required so many steps that it would not have been practical.
9477 @node Programming Answer 7, Programming Answer 8, Programming Answer 6, Answers to Exercises
9478 @subsection Programming Tutorial Exercise 7
9481 The trick here is to compute the harmonic numbers differently, so that
9482 the loop counter itself accumulates the sum of reciprocals. We use
9483 a separate variable to hold the integer counter.
9491 1 t 1 1 @key{RET} 4 Z ( t 2 r 1 1 + s 1 & Z )
9496 The body of the loop goes as follows: First save the harmonic sum
9497 so far in variable 2. Then delete it from the stack; the for loop
9498 itself will take care of remembering it for us. Next, recall the
9499 count from variable 1, add one to it, and feed its reciprocal to
9500 the for loop to use as the step value. The for loop will increase
9501 the ``loop counter'' by that amount and keep going until the
9502 loop counter exceeds 4.
9507 1: 3.99498713092 2: 3.99498713092
9511 r 1 r 2 @key{RET} 31 & +
9515 Thus we find that the 30th harmonic number is 3.99, and the 31st
9516 harmonic number is 4.02.
9518 @node Programming Answer 8, Programming Answer 9, Programming Answer 7, Answers to Exercises
9519 @subsection Programming Tutorial Exercise 8
9522 The first step is to compute the derivative @expr{f'(x)} and thus
9524 @texline @math{\displaystyle{x - {f(x) \over f'(x)}}}.
9525 @infoline @expr{x - f(x)/f'(x)}.
9527 (Because this definition is long, it will be repeated in concise form
9528 below. You can use @w{@kbd{M-# m}} to load it from there. While you are
9529 entering a @kbd{Z ` Z '} body in a macro, Calc simply collects
9530 keystrokes without executing them. In the following diagrams we'll
9531 pretend Calc actually executed the keystrokes as you typed them,
9532 just for purposes of illustration.)
9536 2: sin(cos(x)) - 0.5 3: 4.5
9537 1: 4.5 2: sin(cos(x)) - 0.5
9538 . 1: -(sin(x) cos(cos(x)))
9541 ' sin(cos(x))-0.5 @key{RET} 4.5 m r C-x ( Z ` @key{TAB} @key{RET} a d x @key{RET}
9549 1: x + (sin(cos(x)) - 0.5) / sin(x) cos(cos(x))
9552 / ' x @key{RET} @key{TAB} - t 1
9556 Now, we enter the loop. We'll use a repeat loop with a 20-repetition
9557 limit just in case the method fails to converge for some reason.
9558 (Normally, the @w{@kbd{Z /}} command will stop the loop before all 20
9559 repetitions are done.)
9563 1: 4.5 3: 4.5 2: 4.5
9564 . 2: x + (sin(cos(x)) ... 1: 5.24196456928
9568 20 Z < @key{RET} r 1 @key{TAB} s l x @key{RET}
9572 This is the new guess for @expr{x}. Now we compare it with the
9573 old one to see if we've converged.
9577 3: 5.24196 2: 5.24196 1: 5.24196 1: 5.26345856348
9582 @key{RET} M-@key{TAB} a = Z / Z > Z ' C-x )
9586 The loop converges in just a few steps to this value. To check
9587 the result, we can simply substitute it back into the equation.
9595 @key{RET} ' sin(cos($)) @key{RET}
9599 Let's test the new definition again:
9607 ' x^2-9 @key{RET} 1 X
9611 Once again, here's the full Newton's Method definition:
9615 C-x ( Z ` @key{TAB} @key{RET} a d x @key{RET} / ' x @key{RET} @key{TAB} - t 1
9616 20 Z < @key{RET} r 1 @key{TAB} s l x @key{RET}
9617 @key{RET} M-@key{TAB} a = Z /
9624 @c [fix-ref Nesting and Fixed Points]
9625 It turns out that Calc has a built-in command for applying a formula
9626 repeatedly until it converges to a number. @xref{Nesting and Fixed Points},
9627 to see how to use it.
9629 @c [fix-ref Root Finding]
9630 Also, of course, @kbd{a R} is a built-in command that uses Newton's
9631 method (among others) to look for numerical solutions to any equation.
9632 @xref{Root Finding}.
9634 @node Programming Answer 9, Programming Answer 10, Programming Answer 8, Answers to Exercises
9635 @subsection Programming Tutorial Exercise 9
9638 The first step is to adjust @expr{z} to be greater than 5. A simple
9639 ``for'' loop will do the job here. If @expr{z} is less than 5, we
9640 reduce the problem using
9641 @texline @math{\psi(z) = \psi(z+1) - 1/z}.
9642 @infoline @expr{psi(z) = psi(z+1) - 1/z}. We go
9644 @texline @math{\psi(z+1)},
9645 @infoline @expr{psi(z+1)},
9646 and remember to add back a factor of @expr{-1/z} when we're done. This
9647 step is repeated until @expr{z > 5}.
9649 (Because this definition is long, it will be repeated in concise form
9650 below. You can use @w{@kbd{M-# m}} to load it from there. While you are
9651 entering a @kbd{Z ` Z '} body in a macro, Calc simply collects
9652 keystrokes without executing them. In the following diagrams we'll
9653 pretend Calc actually executed the keystrokes as you typed them,
9654 just for purposes of illustration.)
9661 1.0 @key{RET} C-x ( Z ` s 1 0 t 2
9665 Here, variable 1 holds @expr{z} and variable 2 holds the adjustment
9666 factor. If @expr{z < 5}, we use a loop to increase it.
9668 (By the way, we started with @samp{1.0} instead of the integer 1 because
9669 otherwise the calculation below will try to do exact fractional arithmetic,
9670 and will never converge because fractions compare equal only if they
9671 are exactly equal, not just equal to within the current precision.)
9680 @key{RET} 5 a < Z [ 5 Z ( & s + 2 1 s + 1 1 Z ) r 1 Z ]
9684 Now we compute the initial part of the sum:
9685 @texline @math{\ln z - {1 \over 2z}}
9686 @infoline @expr{ln(z) - 1/2z}
9687 minus the adjustment factor.
9691 2: 1.79175946923 2: 1.7084261359 1: -0.57490719743
9692 1: 0.0833333333333 1: 2.28333333333 .
9699 Now we evaluate the series. We'll use another ``for'' loop counting
9700 up the value of @expr{2 n}. (Calc does have a summation command,
9701 @kbd{a +}, but we'll use loops just to get more practice with them.)
9705 3: -0.5749 3: -0.5749 4: -0.5749 2: -0.5749
9706 2: 2 2: 1:6 3: 1:6 1: 2.3148e-3
9711 2 @key{RET} 40 Z ( @key{RET} k b @key{TAB} @key{RET} r 1 @key{TAB} ^ * /
9718 3: -0.5749 3: -0.5772 2: -0.5772 1: -0.577215664892
9719 2: -0.5749 2: -0.5772 1: 0 .
9720 1: 2.3148e-3 1: -0.5749 .
9723 @key{TAB} @key{RET} M-@key{TAB} - @key{RET} M-@key{TAB} a = Z / 2 Z ) Z ' C-x )
9727 This is the value of
9728 @texline @math{-\gamma},
9729 @infoline @expr{- gamma},
9730 with a slight bit of roundoff error. To get a full 12 digits, let's use
9735 2: -0.577215664892 2: -0.577215664892
9736 1: 1. 1: -0.577215664901532
9738 1. @key{RET} p 16 @key{RET} X
9742 Here's the complete sequence of keystrokes:
9747 @key{RET} 5 a < Z [ 5 Z ( & s + 2 1 s + 1 1 Z ) r 1 Z ]
9749 2 @key{RET} 40 Z ( @key{RET} k b @key{TAB} @key{RET} r 1 @key{TAB} ^ * /
9750 @key{TAB} @key{RET} M-@key{TAB} - @key{RET} M-@key{TAB} a = Z /
9757 @node Programming Answer 10, Programming Answer 11, Programming Answer 9, Answers to Exercises
9758 @subsection Programming Tutorial Exercise 10
9761 Taking the derivative of a term of the form @expr{x^n} will produce
9763 @texline @math{n x^{n-1}}.
9764 @infoline @expr{n x^(n-1)}.
9765 Taking the derivative of a constant
9766 produces zero. From this it is easy to see that the @expr{n}th
9767 derivative of a polynomial, evaluated at @expr{x = 0}, will equal the
9768 coefficient on the @expr{x^n} term times @expr{n!}.
9770 (Because this definition is long, it will be repeated in concise form
9771 below. You can use @w{@kbd{M-# m}} to load it from there. While you are
9772 entering a @kbd{Z ` Z '} body in a macro, Calc simply collects
9773 keystrokes without executing them. In the following diagrams we'll
9774 pretend Calc actually executed the keystrokes as you typed them,
9775 just for purposes of illustration.)
9779 2: 5 x^4 + (x + 1)^2 3: 5 x^4 + (x + 1)^2
9784 ' 5 x^4 + (x+1)^2 @key{RET} 6 C-x ( Z ` [ ] t 1 0 @key{TAB}
9789 Variable 1 will accumulate the vector of coefficients.
9793 2: 0 3: 0 2: 5 x^4 + ...
9794 1: 5 x^4 + ... 2: 5 x^4 + ... 1: 1
9798 Z ( @key{TAB} @key{RET} 0 s l x @key{RET} M-@key{TAB} ! / s | 1
9803 Note that @kbd{s | 1} appends the top-of-stack value to the vector
9804 in a variable; it is completely analogous to @kbd{s + 1}. We could
9805 have written instead, @kbd{r 1 @key{TAB} | t 1}.
9809 1: 20 x^3 + 2 x + 2 1: 0 1: [1, 2, 1, 0, 5, 0, 0]
9812 a d x @key{RET} 1 Z ) @key{DEL} r 1 Z ' C-x )
9816 To convert back, a simple method is just to map the coefficients
9817 against a table of powers of @expr{x}.
9821 2: [1, 2, 1, 0, 5, 0, 0] 2: [1, 2, 1, 0, 5, 0, 0]
9822 1: 6 1: [0, 1, 2, 3, 4, 5, 6]
9825 6 @key{RET} 1 + 0 @key{RET} 1 C-u v x
9832 2: [1, 2, 1, 0, 5, 0, 0] 2: 1 + 2 x + x^2 + 5 x^4
9833 1: [1, x, x^2, x^3, ... ] .
9836 ' x @key{RET} @key{TAB} V M ^ *
9840 Once again, here are the whole polynomial to/from vector programs:
9844 C-x ( Z ` [ ] t 1 0 @key{TAB}
9845 Z ( @key{TAB} @key{RET} 0 s l x @key{RET} M-@key{TAB} ! / s | 1
9851 C-x ( 1 + 0 @key{RET} 1 C-u v x ' x @key{RET} @key{TAB} V M ^ * C-x )
9855 @node Programming Answer 11, Programming Answer 12, Programming Answer 10, Answers to Exercises
9856 @subsection Programming Tutorial Exercise 11
9859 First we define a dummy program to go on the @kbd{z s} key. The true
9860 @w{@kbd{z s}} key is supposed to take two numbers from the stack and
9861 return one number, so @key{DEL} as a dummy definition will make
9862 sure the stack comes out right.
9870 4 @key{RET} 2 C-x ( @key{DEL} C-x ) Z K s @key{RET} 2
9874 The last step replaces the 2 that was eaten during the creation
9875 of the dummy @kbd{z s} command. Now we move on to the real
9876 definition. The recurrence needs to be rewritten slightly,
9877 to the form @expr{s(n,m) = s(n-1,m-1) - (n-1) s(n-1,m)}.
9879 (Because this definition is long, it will be repeated in concise form
9880 below. You can use @kbd{M-# m} to load it from there.)
9890 C-x ( M-2 @key{RET} a = Z [ @key{DEL} @key{DEL} 1 Z :
9897 4: 4 2: 4 2: 3 4: 3 4: 3 3: 3
9898 3: 2 1: 2 1: 2 3: 2 3: 2 2: 2
9899 2: 2 . . 2: 3 2: 3 1: 3
9903 @key{RET} 0 a = Z [ @key{DEL} @key{DEL} 0 Z : @key{TAB} 1 - @key{TAB} M-2 @key{RET} 1 - z s
9908 (Note that the value 3 that our dummy @kbd{z s} produces is not correct;
9909 it is merely a placeholder that will do just as well for now.)
9913 3: 3 4: 3 3: 3 2: 3 1: -6
9914 2: 3 3: 3 2: 3 1: 9 .
9919 M-@key{TAB} M-@key{TAB} @key{TAB} @key{RET} M-@key{TAB} z s * -
9926 1: -6 2: 4 1: 11 2: 11
9930 Z ] Z ] C-x ) Z K s @key{RET} @key{DEL} 4 @key{RET} 2 z s M-@key{RET} k s
9934 Even though the result that we got during the definition was highly
9935 bogus, once the definition is complete the @kbd{z s} command gets
9938 Here's the full program once again:
9942 C-x ( M-2 @key{RET} a =
9943 Z [ @key{DEL} @key{DEL} 1
9945 Z [ @key{DEL} @key{DEL} 0
9946 Z : @key{TAB} 1 - @key{TAB} M-2 @key{RET} 1 - z s
9947 M-@key{TAB} M-@key{TAB} @key{TAB} @key{RET} M-@key{TAB} z s * -
9954 You can read this definition using @kbd{M-# m} (@code{read-kbd-macro})
9955 followed by @kbd{Z K s}, without having to make a dummy definition
9956 first, because @code{read-kbd-macro} doesn't need to execute the
9957 definition as it reads it in. For this reason, @code{M-# m} is often
9958 the easiest way to create recursive programs in Calc.
9960 @node Programming Answer 12, , Programming Answer 11, Answers to Exercises
9961 @subsection Programming Tutorial Exercise 12
9964 This turns out to be a much easier way to solve the problem. Let's
9965 denote Stirling numbers as calls of the function @samp{s}.
9967 First, we store the rewrite rules corresponding to the definition of
9968 Stirling numbers in a convenient variable:
9971 s e StirlingRules @key{RET}
9972 [ s(n,n) := 1 :: n >= 0,
9973 s(n,0) := 0 :: n > 0,
9974 s(n,m) := s(n-1,m-1) - (n-1) s(n-1,m) :: n >= m :: m >= 1 ]
9978 Now, it's just a matter of applying the rules:
9982 2: 4 1: s(4, 2) 1: 11
9986 4 @key{RET} 2 C-x ( ' s($$,$) @key{RET} a r StirlingRules @key{RET} C-x )
9990 As in the case of the @code{fib} rules, it would be useful to put these
9991 rules in @code{EvalRules} and to add a @samp{:: remember} condition to
9994 @c This ends the table-of-contents kludge from above:
9996 \global\let\chapternofonts=\oldchapternofonts
10001 @node Introduction, Data Types, Tutorial, Top
10002 @chapter Introduction
10005 This chapter is the beginning of the Calc reference manual.
10006 It covers basic concepts such as the stack, algebraic and
10007 numeric entry, undo, numeric prefix arguments, etc.
10010 @c (Chapter 2, the Tutorial, has been printed in a separate volume.)
10017 * Algebraic Entry::
10018 * Quick Calculator::
10019 * Prefix Arguments::
10022 * Multiple Calculators::
10023 * Troubleshooting Commands::
10026 @node Basic Commands, Help Commands, Introduction, Introduction
10027 @section Basic Commands
10032 @cindex Starting the Calculator
10033 @cindex Running the Calculator
10034 To start the Calculator in its standard interface, type @kbd{M-x calc}.
10035 By default this creates a pair of small windows, @samp{*Calculator*}
10036 and @samp{*Calc Trail*}. The former displays the contents of the
10037 Calculator stack and is manipulated exclusively through Calc commands.
10038 It is possible (though not usually necessary) to create several Calc
10039 mode buffers each of which has an independent stack, undo list, and
10040 mode settings. There is exactly one Calc Trail buffer; it records a
10041 list of the results of all calculations that have been done. The
10042 Calc Trail buffer uses a variant of Calc mode, so Calculator commands
10043 still work when the trail buffer's window is selected. It is possible
10044 to turn the trail window off, but the @samp{*Calc Trail*} buffer itself
10045 still exists and is updated silently. @xref{Trail Commands}.
10053 In most installations, the @kbd{M-# c} key sequence is a more
10054 convenient way to start the Calculator. Also, @kbd{M-# M-#} and
10055 @kbd{M-# #} are synonyms for @kbd{M-# c} unless you last used Calc
10056 in its Keypad mode.
10060 @pindex calc-execute-extended-command
10061 Most Calc commands use one or two keystrokes. Lower- and upper-case
10062 letters are distinct. Commands may also be entered in full @kbd{M-x} form;
10063 for some commands this is the only form. As a convenience, the @kbd{x}
10064 key (@code{calc-execute-extended-command})
10065 is like @kbd{M-x} except that it enters the initial string @samp{calc-}
10066 for you. For example, the following key sequences are equivalent:
10067 @kbd{S}, @kbd{M-x calc-sin @key{RET}}, @kbd{x sin @key{RET}}.
10069 @cindex Extensions module
10070 @cindex @file{calc-ext} module
10071 The Calculator exists in many parts. When you type @kbd{M-# c}, the
10072 Emacs ``auto-load'' mechanism will bring in only the first part, which
10073 contains the basic arithmetic functions. The other parts will be
10074 auto-loaded the first time you use the more advanced commands like trig
10075 functions or matrix operations. This is done to improve the response time
10076 of the Calculator in the common case when all you need to do is a
10077 little arithmetic. If for some reason the Calculator fails to load an
10078 extension module automatically, you can force it to load all the
10079 extensions by using the @kbd{M-# L} (@code{calc-load-everything})
10080 command. @xref{Mode Settings}.
10082 If you type @kbd{M-x calc} or @kbd{M-# c} with any numeric prefix argument,
10083 the Calculator is loaded if necessary, but it is not actually started.
10084 If the argument is positive, the @file{calc-ext} extensions are also
10085 loaded if necessary. User-written Lisp code that wishes to make use
10086 of Calc's arithmetic routines can use @samp{(calc 0)} or @samp{(calc 1)}
10087 to auto-load the Calculator.
10091 If you type @kbd{M-# b}, then next time you use @kbd{M-# c} you
10092 will get a Calculator that uses the full height of the Emacs screen.
10093 When full-screen mode is on, @kbd{M-# c} runs the @code{full-calc}
10094 command instead of @code{calc}. From the Unix shell you can type
10095 @samp{emacs -f full-calc} to start a new Emacs specifically for use
10096 as a calculator. When Calc is started from the Emacs command line
10097 like this, Calc's normal ``quit'' commands actually quit Emacs itself.
10100 @pindex calc-other-window
10101 The @kbd{M-# o} command is like @kbd{M-# c} except that the Calc
10102 window is not actually selected. If you are already in the Calc
10103 window, @kbd{M-# o} switches you out of it. (The regular Emacs
10104 @kbd{C-x o} command would also work for this, but it has a
10105 tendency to drop you into the Calc Trail window instead, which
10106 @kbd{M-# o} takes care not to do.)
10111 For one quick calculation, you can type @kbd{M-# q} (@code{quick-calc})
10112 which prompts you for a formula (like @samp{2+3/4}). The result is
10113 displayed at the bottom of the Emacs screen without ever creating
10114 any special Calculator windows. @xref{Quick Calculator}.
10119 Finally, if you are using the X window system you may want to try
10120 @kbd{M-# k} (@code{calc-keypad}) which runs Calc with a
10121 ``calculator keypad'' picture as well as a stack display. Click on
10122 the keys with the mouse to operate the calculator. @xref{Keypad Mode}.
10126 @cindex Quitting the Calculator
10127 @cindex Exiting the Calculator
10128 The @kbd{q} key (@code{calc-quit}) exits Calc mode and closes the
10129 Calculator's window(s). It does not delete the Calculator buffers.
10130 If you type @kbd{M-x calc} again, the Calculator will reappear with the
10131 contents of the stack intact. Typing @kbd{M-# c} or @kbd{M-# M-#}
10132 again from inside the Calculator buffer is equivalent to executing
10133 @code{calc-quit}; you can think of @kbd{M-# M-#} as toggling the
10134 Calculator on and off.
10137 The @kbd{M-# x} command also turns the Calculator off, no matter which
10138 user interface (standard, Keypad, or Embedded) is currently active.
10139 It also cancels @code{calc-edit} mode if used from there.
10141 @kindex d @key{SPC}
10142 @pindex calc-refresh
10143 @cindex Refreshing a garbled display
10144 @cindex Garbled displays, refreshing
10145 The @kbd{d @key{SPC}} key sequence (@code{calc-refresh}) redraws the contents
10146 of the Calculator buffer from memory. Use this if the contents of the
10147 buffer have been damaged somehow.
10152 The @kbd{o} key (@code{calc-realign}) moves the cursor back to its
10153 ``home'' position at the bottom of the Calculator buffer.
10157 @pindex calc-scroll-left
10158 @pindex calc-scroll-right
10159 @cindex Horizontal scrolling
10161 @cindex Wide text, scrolling
10162 The @kbd{<} and @kbd{>} keys are bound to @code{calc-scroll-left} and
10163 @code{calc-scroll-right}. These are just like the normal horizontal
10164 scrolling commands except that they scroll one half-screen at a time by
10165 default. (Calc formats its output to fit within the bounds of the
10166 window whenever it can.)
10170 @pindex calc-scroll-down
10171 @pindex calc-scroll-up
10172 @cindex Vertical scrolling
10173 The @kbd{@{} and @kbd{@}} keys are bound to @code{calc-scroll-down}
10174 and @code{calc-scroll-up}. They scroll up or down by one-half the
10175 height of the Calc window.
10179 The @kbd{M-# 0} command (@code{calc-reset}; that's @kbd{M-#} followed
10180 by a zero) resets the Calculator to its initial state. This clears
10181 the stack, resets all the modes to their initial values (the values
10182 that were saved with @kbd{m m} (@code{calc-save-modes})), clears the
10183 caches (@pxref{Caches}), and so on. (It does @emph{not} erase the
10184 values of any variables.) With an argument of 0, Calc will be reset to
10185 its default state; namely, the modes will be given their default values.
10186 With a positive prefix argument, @kbd{M-# 0} preserves the contents of
10187 the stack but resets everything else to its initial state; with a
10188 negative prefix argument, @kbd{M-# 0} preserves the contents of the
10189 stack but resets everything else to its default state.
10191 @pindex calc-version
10192 The @kbd{M-x calc-version} command displays the current version number
10193 of Calc and the name of the person who installed it on your system.
10194 (This information is also present in the @samp{*Calc Trail*} buffer,
10195 and in the output of the @kbd{h h} command.)
10197 @node Help Commands, Stack Basics, Basic Commands, Introduction
10198 @section Help Commands
10201 @cindex Help commands
10204 The @kbd{?} key (@code{calc-help}) displays a series of brief help messages.
10205 Some keys (such as @kbd{b} and @kbd{d}) are prefix keys, like Emacs'
10206 @key{ESC} and @kbd{C-x} prefixes. You can type
10207 @kbd{?} after a prefix to see a list of commands beginning with that
10208 prefix. (If the message includes @samp{[MORE]}, press @kbd{?} again
10209 to see additional commands for that prefix.)
10212 @pindex calc-full-help
10213 The @kbd{h h} (@code{calc-full-help}) command displays all the @kbd{?}
10214 responses at once. When printed, this makes a nice, compact (three pages)
10215 summary of Calc keystrokes.
10217 In general, the @kbd{h} key prefix introduces various commands that
10218 provide help within Calc. Many of the @kbd{h} key functions are
10219 Calc-specific analogues to the @kbd{C-h} functions for Emacs help.
10225 The @kbd{h i} (@code{calc-info}) command runs the Emacs Info system
10226 to read this manual on-line. This is basically the same as typing
10227 @kbd{C-h i} (the regular way to run the Info system), then, if Info
10228 is not already in the Calc manual, selecting the beginning of the
10229 manual. The @kbd{M-# i} command is another way to read the Calc
10230 manual; it is different from @kbd{h i} in that it works any time,
10231 not just inside Calc. The plain @kbd{i} key is also equivalent to
10232 @kbd{h i}, though this key is obsolete and may be replaced with a
10233 different command in a future version of Calc.
10237 @pindex calc-tutorial
10238 The @kbd{h t} (@code{calc-tutorial}) command runs the Info system on
10239 the Tutorial section of the Calc manual. It is like @kbd{h i},
10240 except that it selects the starting node of the tutorial rather
10241 than the beginning of the whole manual. (It actually selects the
10242 node ``Interactive Tutorial'' which tells a few things about
10243 using the Info system before going on to the actual tutorial.)
10244 The @kbd{M-# t} key is equivalent to @kbd{h t} (but it works at
10249 @pindex calc-info-summary
10250 The @kbd{h s} (@code{calc-info-summary}) command runs the Info system
10251 on the Summary node of the Calc manual. @xref{Summary}. The @kbd{M-# s}
10252 key is equivalent to @kbd{h s}.
10255 @pindex calc-describe-key
10256 The @kbd{h k} (@code{calc-describe-key}) command looks up a key
10257 sequence in the Calc manual. For example, @kbd{h k H a S} looks
10258 up the documentation on the @kbd{H a S} (@code{calc-solve-for})
10259 command. This works by looking up the textual description of
10260 the key(s) in the Key Index of the manual, then jumping to the
10261 node indicated by the index.
10263 Most Calc commands do not have traditional Emacs documentation
10264 strings, since the @kbd{h k} command is both more convenient and
10265 more instructive. This means the regular Emacs @kbd{C-h k}
10266 (@code{describe-key}) command will not be useful for Calc keystrokes.
10269 @pindex calc-describe-key-briefly
10270 The @kbd{h c} (@code{calc-describe-key-briefly}) command reads a
10271 key sequence and displays a brief one-line description of it at
10272 the bottom of the screen. It looks for the key sequence in the
10273 Summary node of the Calc manual; if it doesn't find the sequence
10274 there, it acts just like its regular Emacs counterpart @kbd{C-h c}
10275 (@code{describe-key-briefly}). For example, @kbd{h c H a S}
10276 gives the description:
10279 H a S runs calc-solve-for: a `H a S' v => fsolve(a,v) (?=notes)
10283 which means the command @kbd{H a S} or @kbd{H M-x calc-solve-for}
10284 takes a value @expr{a} from the stack, prompts for a value @expr{v},
10285 then applies the algebraic function @code{fsolve} to these values.
10286 The @samp{?=notes} message means you can now type @kbd{?} to see
10287 additional notes from the summary that apply to this command.
10290 @pindex calc-describe-function
10291 The @kbd{h f} (@code{calc-describe-function}) command looks up an
10292 algebraic function or a command name in the Calc manual. Enter an
10293 algebraic function name to look up that function in the Function
10294 Index or enter a command name beginning with @samp{calc-} to look it
10295 up in the Command Index. This command will also look up operator
10296 symbols that can appear in algebraic formulas, like @samp{%} and
10300 @pindex calc-describe-variable
10301 The @kbd{h v} (@code{calc-describe-variable}) command looks up a
10302 variable in the Calc manual. Enter a variable name like @code{pi} or
10303 @code{PlotRejects}.
10306 @pindex describe-bindings
10307 The @kbd{h b} (@code{calc-describe-bindings}) command is just like
10308 @kbd{C-h b}, except that only local (Calc-related) key bindings are
10312 The @kbd{h n} or @kbd{h C-n} (@code{calc-view-news}) command displays
10313 the ``news'' or change history of Calc. This is kept in the file
10314 @file{README}, which Calc looks for in the same directory as the Calc
10320 The @kbd{h C-c}, @kbd{h C-d}, and @kbd{h C-w} keys display copying,
10321 distribution, and warranty information about Calc. These work by
10322 pulling up the appropriate parts of the ``Copying'' or ``Reporting
10323 Bugs'' sections of the manual.
10325 @node Stack Basics, Numeric Entry, Help Commands, Introduction
10326 @section Stack Basics
10329 @cindex Stack basics
10330 @c [fix-tut RPN Calculations and the Stack]
10331 Calc uses RPN notation. If you are not familiar with RPN, @pxref{RPN
10334 To add the numbers 1 and 2 in Calc you would type the keys:
10335 @kbd{1 @key{RET} 2 +}.
10336 (@key{RET} corresponds to the @key{ENTER} key on most calculators.)
10337 The first three keystrokes ``push'' the numbers 1 and 2 onto the stack. The
10338 @kbd{+} key always ``pops'' the top two numbers from the stack, adds them,
10339 and pushes the result (3) back onto the stack. This number is ready for
10340 further calculations: @kbd{5 -} pushes 5 onto the stack, then pops the
10341 3 and 5, subtracts them, and pushes the result (@mathit{-2}).
10343 Note that the ``top'' of the stack actually appears at the @emph{bottom}
10344 of the buffer. A line containing a single @samp{.} character signifies
10345 the end of the buffer; Calculator commands operate on the number(s)
10346 directly above this line. The @kbd{d t} (@code{calc-truncate-stack})
10347 command allows you to move the @samp{.} marker up and down in the stack;
10348 @pxref{Truncating the Stack}.
10351 @pindex calc-line-numbering
10352 Stack elements are numbered consecutively, with number 1 being the top of
10353 the stack. These line numbers are ordinarily displayed on the lefthand side
10354 of the window. The @kbd{d l} (@code{calc-line-numbering}) command controls
10355 whether these numbers appear. (Line numbers may be turned off since they
10356 slow the Calculator down a bit and also clutter the display.)
10359 @pindex calc-realign
10360 The unshifted letter @kbd{o} (@code{calc-realign}) command repositions
10361 the cursor to its top-of-stack ``home'' position. It also undoes any
10362 horizontal scrolling in the window. If you give it a numeric prefix
10363 argument, it instead moves the cursor to the specified stack element.
10365 The @key{RET} (or equivalent @key{SPC}) key is only required to separate
10366 two consecutive numbers.
10367 (After all, if you typed @kbd{1 2} by themselves the Calculator
10368 would enter the number 12.) If you press @key{RET} or @key{SPC} @emph{not}
10369 right after typing a number, the key duplicates the number on the top of
10370 the stack. @kbd{@key{RET} *} is thus a handy way to square a number.
10372 The @key{DEL} key pops and throws away the top number on the stack.
10373 The @key{TAB} key swaps the top two objects on the stack.
10374 @xref{Stack and Trail}, for descriptions of these and other stack-related
10377 @node Numeric Entry, Algebraic Entry, Stack Basics, Introduction
10378 @section Numeric Entry
10384 @cindex Numeric entry
10385 @cindex Entering numbers
10386 Pressing a digit or other numeric key begins numeric entry using the
10387 minibuffer. The number is pushed on the stack when you press the @key{RET}
10388 or @key{SPC} keys. If you press any other non-numeric key, the number is
10389 pushed onto the stack and the appropriate operation is performed. If
10390 you press a numeric key which is not valid, the key is ignored.
10392 @cindex Minus signs
10393 @cindex Negative numbers, entering
10395 There are three different concepts corresponding to the word ``minus,''
10396 typified by @expr{a-b} (subtraction), @expr{-x}
10397 (change-sign), and @expr{-5} (negative number). Calc uses three
10398 different keys for these operations, respectively:
10399 @kbd{-}, @kbd{n}, and @kbd{_} (the underscore). The @kbd{-} key subtracts
10400 the two numbers on the top of the stack. The @kbd{n} key changes the sign
10401 of the number on the top of the stack or the number currently being entered.
10402 The @kbd{_} key begins entry of a negative number or changes the sign of
10403 the number currently being entered. The following sequences all enter the
10404 number @mathit{-5} onto the stack: @kbd{0 @key{RET} 5 -}, @kbd{5 n @key{RET}},
10405 @kbd{5 @key{RET} n}, @kbd{_ 5 @key{RET}}, @kbd{5 _ @key{RET}}.
10407 Some other keys are active during numeric entry, such as @kbd{#} for
10408 non-decimal numbers, @kbd{:} for fractions, and @kbd{@@} for HMS forms.
10409 These notations are described later in this manual with the corresponding
10410 data types. @xref{Data Types}.
10412 During numeric entry, the only editing key available is @key{DEL}.
10414 @node Algebraic Entry, Quick Calculator, Numeric Entry, Introduction
10415 @section Algebraic Entry
10419 @pindex calc-algebraic-entry
10420 @cindex Algebraic notation
10421 @cindex Formulas, entering
10422 Calculations can also be entered in algebraic form. This is accomplished
10423 by typing the apostrophe key, @kbd{'}, followed by the expression in
10424 standard format: @kbd{@key{'} 2+3*4 @key{RET}} computes
10425 @texline @math{2+(3\times4) = 14}
10426 @infoline @expr{2+(3*4) = 14}
10427 and pushes that on the stack. If you wish you can
10428 ignore the RPN aspect of Calc altogether and simply enter algebraic
10429 expressions in this way. You may want to use @key{DEL} every so often to
10430 clear previous results off the stack.
10432 You can press the apostrophe key during normal numeric entry to switch
10433 the half-entered number into Algebraic entry mode. One reason to do this
10434 would be to use the full Emacs cursor motion and editing keys, which are
10435 available during algebraic entry but not during numeric entry.
10437 In the same vein, during either numeric or algebraic entry you can
10438 press @kbd{`} (backquote) to switch to @code{calc-edit} mode, where
10439 you complete your half-finished entry in a separate buffer.
10440 @xref{Editing Stack Entries}.
10443 @pindex calc-algebraic-mode
10444 @cindex Algebraic Mode
10445 If you prefer algebraic entry, you can use the command @kbd{m a}
10446 (@code{calc-algebraic-mode}) to set Algebraic mode. In this mode,
10447 digits and other keys that would normally start numeric entry instead
10448 start full algebraic entry; as long as your formula begins with a digit
10449 you can omit the apostrophe. Open parentheses and square brackets also
10450 begin algebraic entry. You can still do RPN calculations in this mode,
10451 but you will have to press @key{RET} to terminate every number:
10452 @kbd{2 @key{RET} 3 @key{RET} * 4 @key{RET} +} would accomplish the same
10453 thing as @kbd{2*3+4 @key{RET}}.
10455 @cindex Incomplete Algebraic Mode
10456 If you give a numeric prefix argument like @kbd{C-u} to the @kbd{m a}
10457 command, it enables Incomplete Algebraic mode; this is like regular
10458 Algebraic mode except that it applies to the @kbd{(} and @kbd{[} keys
10459 only. Numeric keys still begin a numeric entry in this mode.
10462 @pindex calc-total-algebraic-mode
10463 @cindex Total Algebraic Mode
10464 The @kbd{m t} (@code{calc-total-algebraic-mode}) gives you an even
10465 stronger algebraic-entry mode, in which @emph{all} regular letter and
10466 punctuation keys begin algebraic entry. Use this if you prefer typing
10467 @w{@kbd{sqrt( )}} instead of @kbd{Q}, @w{@kbd{factor( )}} instead of
10468 @kbd{a f}, and so on. To type regular Calc commands when you are in
10469 Total Algebraic mode, hold down the @key{META} key. Thus @kbd{M-q}
10470 is the command to quit Calc, @kbd{M-p} sets the precision, and
10471 @kbd{M-m t} (or @kbd{M-m M-t}, if you prefer) turns Total Algebraic
10472 mode back off again. Meta keys also terminate algebraic entry, so
10473 that @kbd{2+3 M-S} is equivalent to @kbd{2+3 @key{RET} M-S}. The symbol
10474 @samp{Alg*} will appear in the mode line whenever you are in this mode.
10476 Pressing @kbd{'} (the apostrophe) a second time re-enters the previous
10477 algebraic formula. You can then use the normal Emacs editing keys to
10478 modify this formula to your liking before pressing @key{RET}.
10481 @cindex Formulas, referring to stack
10482 Within a formula entered from the keyboard, the symbol @kbd{$}
10483 represents the number on the top of the stack. If an entered formula
10484 contains any @kbd{$} characters, the Calculator replaces the top of
10485 stack with that formula rather than simply pushing the formula onto the
10486 stack. Thus, @kbd{' 1+2 @key{RET}} pushes 3 on the stack, and @kbd{$*2
10487 @key{RET}} replaces it with 6. Note that the @kbd{$} key always
10488 initiates algebraic entry; the @kbd{'} is unnecessary if @kbd{$} is the
10489 first character in the new formula.
10491 Higher stack elements can be accessed from an entered formula with the
10492 symbols @kbd{$$}, @kbd{$$$}, and so on. The number of stack elements
10493 removed (to be replaced by the entered values) equals the number of dollar
10494 signs in the longest such symbol in the formula. For example, @samp{$$+$$$}
10495 adds the second and third stack elements, replacing the top three elements
10496 with the answer. (All information about the top stack element is thus lost
10497 since no single @samp{$} appears in this formula.)
10499 A slightly different way to refer to stack elements is with a dollar
10500 sign followed by a number: @samp{$1}, @samp{$2}, and so on are much
10501 like @samp{$}, @samp{$$}, etc., except that stack entries referred
10502 to numerically are not replaced by the algebraic entry. That is, while
10503 @samp{$+1} replaces 5 on the stack with 6, @samp{$1+1} leaves the 5
10504 on the stack and pushes an additional 6.
10506 If a sequence of formulas are entered separated by commas, each formula
10507 is pushed onto the stack in turn. For example, @samp{1,2,3} pushes
10508 those three numbers onto the stack (leaving the 3 at the top), and
10509 @samp{$+1,$-1} replaces a 5 on the stack with 4 followed by 6. Also,
10510 @samp{$,$$} exchanges the top two elements of the stack, just like the
10513 You can finish an algebraic entry with @kbd{M-=} or @kbd{M-@key{RET}} instead
10514 of @key{RET}. This uses @kbd{=} to evaluate the variables in each
10515 formula that goes onto the stack. (Thus @kbd{' pi @key{RET}} pushes
10516 the variable @samp{pi}, but @kbd{' pi M-@key{RET}} pushes 3.1415.)
10518 If you finish your algebraic entry by pressing @key{LFD} (or @kbd{C-j})
10519 instead of @key{RET}, Calc disables the default simplifications
10520 (as if by @kbd{m O}; @pxref{Simplification Modes}) while the entry
10521 is being pushed on the stack. Thus @kbd{' 1+2 @key{RET}} pushes 3
10522 on the stack, but @kbd{' 1+2 @key{LFD}} pushes the formula @expr{1+2};
10523 you might then press @kbd{=} when it is time to evaluate this formula.
10525 @node Quick Calculator, Prefix Arguments, Algebraic Entry, Introduction
10526 @section ``Quick Calculator'' Mode
10531 @cindex Quick Calculator
10532 There is another way to invoke the Calculator if all you need to do
10533 is make one or two quick calculations. Type @kbd{M-# q} (or
10534 @kbd{M-x quick-calc}), then type any formula as an algebraic entry.
10535 The Calculator will compute the result and display it in the echo
10536 area, without ever actually putting up a Calc window.
10538 You can use the @kbd{$} character in a Quick Calculator formula to
10539 refer to the previous Quick Calculator result. Older results are
10540 not retained; the Quick Calculator has no effect on the full
10541 Calculator's stack or trail. If you compute a result and then
10542 forget what it was, just run @code{M-# q} again and enter
10543 @samp{$} as the formula.
10545 If this is the first time you have used the Calculator in this Emacs
10546 session, the @kbd{M-# q} command will create the @code{*Calculator*}
10547 buffer and perform all the usual initializations; it simply will
10548 refrain from putting that buffer up in a new window. The Quick
10549 Calculator refers to the @code{*Calculator*} buffer for all mode
10550 settings. Thus, for example, to set the precision that the Quick
10551 Calculator uses, simply run the full Calculator momentarily and use
10552 the regular @kbd{p} command.
10554 If you use @code{M-# q} from inside the Calculator buffer, the
10555 effect is the same as pressing the apostrophe key (algebraic entry).
10557 The result of a Quick calculation is placed in the Emacs ``kill ring''
10558 as well as being displayed. A subsequent @kbd{C-y} command will
10559 yank the result into the editing buffer. You can also use this
10560 to yank the result into the next @kbd{M-# q} input line as a more
10561 explicit alternative to @kbd{$} notation, or to yank the result
10562 into the Calculator stack after typing @kbd{M-# c}.
10564 If you finish your formula by typing @key{LFD} (or @kbd{C-j}) instead
10565 of @key{RET}, the result is inserted immediately into the current
10566 buffer rather than going into the kill ring.
10568 Quick Calculator results are actually evaluated as if by the @kbd{=}
10569 key (which replaces variable names by their stored values, if any).
10570 If the formula you enter is an assignment to a variable using the
10571 @samp{:=} operator, say, @samp{foo := 2 + 3} or @samp{foo := foo + 1},
10572 then the result of the evaluation is stored in that Calc variable.
10573 @xref{Store and Recall}.
10575 If the result is an integer and the current display radix is decimal,
10576 the number will also be displayed in hex and octal formats. If the
10577 integer is in the range from 1 to 126, it will also be displayed as
10578 an ASCII character.
10580 For example, the quoted character @samp{"x"} produces the vector
10581 result @samp{[120]} (because 120 is the ASCII code of the lower-case
10582 `x'; @pxref{Strings}). Since this is a vector, not an integer, it
10583 is displayed only according to the current mode settings. But
10584 running Quick Calc again and entering @samp{120} will produce the
10585 result @samp{120 (16#78, 8#170, x)} which shows the number in its
10586 decimal, hexadecimal, octal, and ASCII forms.
10588 Please note that the Quick Calculator is not any faster at loading
10589 or computing the answer than the full Calculator; the name ``quick''
10590 merely refers to the fact that it's much less hassle to use for
10591 small calculations.
10593 @node Prefix Arguments, Undo, Quick Calculator, Introduction
10594 @section Numeric Prefix Arguments
10597 Many Calculator commands use numeric prefix arguments. Some, such as
10598 @kbd{d s} (@code{calc-sci-notation}), set a parameter to the value of
10599 the prefix argument or use a default if you don't use a prefix.
10600 Others (like @kbd{d f} (@code{calc-fix-notation})) require an argument
10601 and prompt for a number if you don't give one as a prefix.
10603 As a rule, stack-manipulation commands accept a numeric prefix argument
10604 which is interpreted as an index into the stack. A positive argument
10605 operates on the top @var{n} stack entries; a negative argument operates
10606 on the @var{n}th stack entry in isolation; and a zero argument operates
10607 on the entire stack.
10609 Most commands that perform computations (such as the arithmetic and
10610 scientific functions) accept a numeric prefix argument that allows the
10611 operation to be applied across many stack elements. For unary operations
10612 (that is, functions of one argument like absolute value or complex
10613 conjugate), a positive prefix argument applies that function to the top
10614 @var{n} stack entries simultaneously, and a negative argument applies it
10615 to the @var{n}th stack entry only. For binary operations (functions of
10616 two arguments like addition, GCD, and vector concatenation), a positive
10617 prefix argument ``reduces'' the function across the top @var{n}
10618 stack elements (for example, @kbd{C-u 5 +} sums the top 5 stack entries;
10619 @pxref{Reducing and Mapping}), and a negative argument maps the next-to-top
10620 @var{n} stack elements with the top stack element as a second argument
10621 (for example, @kbd{7 c-u -5 +} adds 7 to the top 5 stack elements).
10622 This feature is not available for operations which use the numeric prefix
10623 argument for some other purpose.
10625 Numeric prefixes are specified the same way as always in Emacs: Press
10626 a sequence of @key{META}-digits, or press @key{ESC} followed by digits,
10627 or press @kbd{C-u} followed by digits. Some commands treat plain
10628 @kbd{C-u} (without any actual digits) specially.
10631 @pindex calc-num-prefix
10632 You can type @kbd{~} (@code{calc-num-prefix}) to pop an integer from the
10633 top of the stack and enter it as the numeric prefix for the next command.
10634 For example, @kbd{C-u 16 p} sets the precision to 16 digits; an alternate
10635 (silly) way to do this would be @kbd{2 @key{RET} 4 ^ ~ p}, i.e., compute 2
10636 to the fourth power and set the precision to that value.
10638 Conversely, if you have typed a numeric prefix argument the @kbd{~} key
10639 pushes it onto the stack in the form of an integer.
10641 @node Undo, Error Messages, Prefix Arguments, Introduction
10642 @section Undoing Mistakes
10648 @cindex Mistakes, undoing
10649 @cindex Undoing mistakes
10650 @cindex Errors, undoing
10651 The shift-@kbd{U} key (@code{calc-undo}) undoes the most recent operation.
10652 If that operation added or dropped objects from the stack, those objects
10653 are removed or restored. If it was a ``store'' operation, you are
10654 queried whether or not to restore the variable to its original value.
10655 The @kbd{U} key may be pressed any number of times to undo successively
10656 farther back in time; with a numeric prefix argument it undoes a
10657 specified number of operations. The undo history is cleared only by the
10658 @kbd{q} (@code{calc-quit}) command. (Recall that @kbd{M-# c} is
10659 synonymous with @code{calc-quit} while inside the Calculator; this
10660 also clears the undo history.)
10662 Currently the mode-setting commands (like @code{calc-precision}) are not
10663 undoable. You can undo past a point where you changed a mode, but you
10664 will need to reset the mode yourself.
10668 @cindex Redoing after an Undo
10669 The shift-@kbd{D} key (@code{calc-redo}) redoes an operation that was
10670 mistakenly undone. Pressing @kbd{U} with a negative prefix argument is
10671 equivalent to executing @code{calc-redo}. You can redo any number of
10672 times, up to the number of recent consecutive undo commands. Redo
10673 information is cleared whenever you give any command that adds new undo
10674 information, i.e., if you undo, then enter a number on the stack or make
10675 any other change, then it will be too late to redo.
10677 @kindex M-@key{RET}
10678 @pindex calc-last-args
10679 @cindex Last-arguments feature
10680 @cindex Arguments, restoring
10681 The @kbd{M-@key{RET}} key (@code{calc-last-args}) is like undo in that
10682 it restores the arguments of the most recent command onto the stack;
10683 however, it does not remove the result of that command. Given a numeric
10684 prefix argument, this command applies to the @expr{n}th most recent
10685 command which removed items from the stack; it pushes those items back
10688 The @kbd{K} (@code{calc-keep-args}) command provides a related function
10689 to @kbd{M-@key{RET}}. @xref{Stack and Trail}.
10691 It is also possible to recall previous results or inputs using the trail.
10692 @xref{Trail Commands}.
10694 The standard Emacs @kbd{C-_} undo key is recognized as a synonym for @kbd{U}.
10696 @node Error Messages, Multiple Calculators, Undo, Introduction
10697 @section Error Messages
10702 @cindex Errors, messages
10703 @cindex Why did an error occur?
10704 Many situations that would produce an error message in other calculators
10705 simply create unsimplified formulas in the Emacs Calculator. For example,
10706 @kbd{1 @key{RET} 0 /} pushes the formula @expr{1 / 0}; @w{@kbd{0 L}} pushes
10707 the formula @samp{ln(0)}. Floating-point overflow and underflow are also
10708 reasons for this to happen.
10710 When a function call must be left in symbolic form, Calc usually
10711 produces a message explaining why. Messages that are probably
10712 surprising or indicative of user errors are displayed automatically.
10713 Other messages are simply kept in Calc's memory and are displayed only
10714 if you type @kbd{w} (@code{calc-why}). You can also press @kbd{w} if
10715 the same computation results in several messages. (The first message
10716 will end with @samp{[w=more]} in this case.)
10719 @pindex calc-auto-why
10720 The @kbd{d w} (@code{calc-auto-why}) command controls when error messages
10721 are displayed automatically. (Calc effectively presses @kbd{w} for you
10722 after your computation finishes.) By default, this occurs only for
10723 ``important'' messages. The other possible modes are to report
10724 @emph{all} messages automatically, or to report none automatically (so
10725 that you must always press @kbd{w} yourself to see the messages).
10727 @node Multiple Calculators, Troubleshooting Commands, Error Messages, Introduction
10728 @section Multiple Calculators
10731 @pindex another-calc
10732 It is possible to have any number of Calc mode buffers at once.
10733 Usually this is done by executing @kbd{M-x another-calc}, which
10734 is similar to @kbd{M-# c} except that if a @samp{*Calculator*}
10735 buffer already exists, a new, independent one with a name of the
10736 form @samp{*Calculator*<@var{n}>} is created. You can also use the
10737 command @code{calc-mode} to put any buffer into Calculator mode, but
10738 this would ordinarily never be done.
10740 The @kbd{q} (@code{calc-quit}) command does not destroy a Calculator buffer;
10741 it only closes its window. Use @kbd{M-x kill-buffer} to destroy a
10744 Each Calculator buffer keeps its own stack, undo list, and mode settings
10745 such as precision, angular mode, and display formats. In Emacs terms,
10746 variables such as @code{calc-stack} are buffer-local variables. The
10747 global default values of these variables are used only when a new
10748 Calculator buffer is created. The @code{calc-quit} command saves
10749 the stack and mode settings of the buffer being quit as the new defaults.
10751 There is only one trail buffer, @samp{*Calc Trail*}, used by all
10752 Calculator buffers.
10754 @node Troubleshooting Commands, , Multiple Calculators, Introduction
10755 @section Troubleshooting Commands
10758 This section describes commands you can use in case a computation
10759 incorrectly fails or gives the wrong answer.
10761 @xref{Reporting Bugs}, if you find a problem that appears to be due
10762 to a bug or deficiency in Calc.
10765 * Autoloading Problems::
10766 * Recursion Depth::
10771 @node Autoloading Problems, Recursion Depth, Troubleshooting Commands, Troubleshooting Commands
10772 @subsection Autoloading Problems
10775 The Calc program is split into many component files; components are
10776 loaded automatically as you use various commands that require them.
10777 Occasionally Calc may lose track of when a certain component is
10778 necessary; typically this means you will type a command and it won't
10779 work because some function you've never heard of was undefined.
10782 @pindex calc-load-everything
10783 If this happens, the easiest workaround is to type @kbd{M-# L}
10784 (@code{calc-load-everything}) to force all the parts of Calc to be
10785 loaded right away. This will cause Emacs to take up a lot more
10786 memory than it would otherwise, but it's guaranteed to fix the problem.
10788 @node Recursion Depth, Caches, Autoloading Problems, Troubleshooting Commands
10789 @subsection Recursion Depth
10794 @pindex calc-more-recursion-depth
10795 @pindex calc-less-recursion-depth
10796 @cindex Recursion depth
10797 @cindex ``Computation got stuck'' message
10798 @cindex @code{max-lisp-eval-depth}
10799 @cindex @code{max-specpdl-size}
10800 Calc uses recursion in many of its calculations. Emacs Lisp keeps a
10801 variable @code{max-lisp-eval-depth} which limits the amount of recursion
10802 possible in an attempt to recover from program bugs. If a calculation
10803 ever halts incorrectly with the message ``Computation got stuck or
10804 ran too long,'' use the @kbd{M} command (@code{calc-more-recursion-depth})
10805 to increase this limit. (Of course, this will not help if the
10806 calculation really did get stuck due to some problem inside Calc.)
10808 The limit is always increased (multiplied) by a factor of two. There
10809 is also an @kbd{I M} (@code{calc-less-recursion-depth}) command which
10810 decreases this limit by a factor of two, down to a minimum value of 200.
10811 The default value is 1000.
10813 These commands also double or halve @code{max-specpdl-size}, another
10814 internal Lisp recursion limit. The minimum value for this limit is 600.
10816 @node Caches, Debugging Calc, Recursion Depth, Troubleshooting Commands
10821 @cindex Flushing caches
10822 Calc saves certain values after they have been computed once. For
10823 example, the @kbd{P} (@code{calc-pi}) command initially ``knows'' the
10824 constant @cpi{} to about 20 decimal places; if the current precision
10825 is greater than this, it will recompute @cpi{} using a series
10826 approximation. This value will not need to be recomputed ever again
10827 unless you raise the precision still further. Many operations such as
10828 logarithms and sines make use of similarly cached values such as
10830 @texline @math{\ln 2}.
10831 @infoline @expr{ln(2)}.
10832 The visible effect of caching is that
10833 high-precision computations may seem to do extra work the first time.
10834 Other things cached include powers of two (for the binary arithmetic
10835 functions), matrix inverses and determinants, symbolic integrals, and
10836 data points computed by the graphing commands.
10838 @pindex calc-flush-caches
10839 If you suspect a Calculator cache has become corrupt, you can use the
10840 @code{calc-flush-caches} command to reset all caches to the empty state.
10841 (This should only be necessary in the event of bugs in the Calculator.)
10842 The @kbd{M-# 0} (with the zero key) command also resets caches along
10843 with all other aspects of the Calculator's state.
10845 @node Debugging Calc, , Caches, Troubleshooting Commands
10846 @subsection Debugging Calc
10849 A few commands exist to help in the debugging of Calc commands.
10850 @xref{Programming}, to see the various ways that you can write
10851 your own Calc commands.
10854 @pindex calc-timing
10855 The @kbd{Z T} (@code{calc-timing}) command turns on and off a mode
10856 in which the timing of slow commands is reported in the Trail.
10857 Any Calc command that takes two seconds or longer writes a line
10858 to the Trail showing how many seconds it took. This value is
10859 accurate only to within one second.
10861 All steps of executing a command are included; in particular, time
10862 taken to format the result for display in the stack and trail is
10863 counted. Some prompts also count time taken waiting for them to
10864 be answered, while others do not; this depends on the exact
10865 implementation of the command. For best results, if you are timing
10866 a sequence that includes prompts or multiple commands, define a
10867 keyboard macro to run the whole sequence at once. Calc's @kbd{X}
10868 command (@pxref{Keyboard Macros}) will then report the time taken
10869 to execute the whole macro.
10871 Another advantage of the @kbd{X} command is that while it is
10872 executing, the stack and trail are not updated from step to step.
10873 So if you expect the output of your test sequence to leave a result
10874 that may take a long time to format and you don't wish to count
10875 this formatting time, end your sequence with a @key{DEL} keystroke
10876 to clear the result from the stack. When you run the sequence with
10877 @kbd{X}, Calc will never bother to format the large result.
10879 Another thing @kbd{Z T} does is to increase the Emacs variable
10880 @code{gc-cons-threshold} to a much higher value (two million; the
10881 usual default in Calc is 250,000) for the duration of each command.
10882 This generally prevents garbage collection during the timing of
10883 the command, though it may cause your Emacs process to grow
10884 abnormally large. (Garbage collection time is a major unpredictable
10885 factor in the timing of Emacs operations.)
10887 Another command that is useful when debugging your own Lisp
10888 extensions to Calc is @kbd{M-x calc-pass-errors}, which disables
10889 the error handler that changes the ``@code{max-lisp-eval-depth}
10890 exceeded'' message to the much more friendly ``Computation got
10891 stuck or ran too long.'' This handler interferes with the Emacs
10892 Lisp debugger's @code{debug-on-error} mode. Errors are reported
10893 in the handler itself rather than at the true location of the
10894 error. After you have executed @code{calc-pass-errors}, Lisp
10895 errors will be reported correctly but the user-friendly message
10898 @node Data Types, Stack and Trail, Introduction, Top
10899 @chapter Data Types
10902 This chapter discusses the various types of objects that can be placed
10903 on the Calculator stack, how they are displayed, and how they are
10904 entered. (@xref{Data Type Formats}, for information on how these data
10905 types are represented as underlying Lisp objects.)
10907 Integers, fractions, and floats are various ways of describing real
10908 numbers. HMS forms also for many purposes act as real numbers. These
10909 types can be combined to form complex numbers, modulo forms, error forms,
10910 or interval forms. (But these last four types cannot be combined
10911 arbitrarily:@: error forms may not contain modulo forms, for example.)
10912 Finally, all these types of numbers may be combined into vectors,
10913 matrices, or algebraic formulas.
10916 * Integers:: The most basic data type.
10917 * Fractions:: This and above are called @dfn{rationals}.
10918 * Floats:: This and above are called @dfn{reals}.
10919 * Complex Numbers:: This and above are called @dfn{numbers}.
10921 * Vectors and Matrices::
10928 * Incomplete Objects::
10933 @node Integers, Fractions, Data Types, Data Types
10938 The Calculator stores integers to arbitrary precision. Addition,
10939 subtraction, and multiplication of integers always yields an exact
10940 integer result. (If the result of a division or exponentiation of
10941 integers is not an integer, it is expressed in fractional or
10942 floating-point form according to the current Fraction mode.
10943 @xref{Fraction Mode}.)
10945 A decimal integer is represented as an optional sign followed by a
10946 sequence of digits. Grouping (@pxref{Grouping Digits}) can be used to
10947 insert a comma at every third digit for display purposes, but you
10948 must not type commas during the entry of numbers.
10951 A non-decimal integer is represented as an optional sign, a radix
10952 between 2 and 36, a @samp{#} symbol, and one or more digits. For radix 11
10953 and above, the letters A through Z (upper- or lower-case) count as
10954 digits and do not terminate numeric entry mode. @xref{Radix Modes}, for how
10955 to set the default radix for display of integers. Numbers of any radix
10956 may be entered at any time. If you press @kbd{#} at the beginning of a
10957 number, the current display radix is used.
10959 @node Fractions, Floats, Integers, Data Types
10964 A @dfn{fraction} is a ratio of two integers. Fractions are traditionally
10965 written ``2/3'' but Calc uses the notation @samp{2:3}. (The @kbd{/} key
10966 performs RPN division; the following two sequences push the number
10967 @samp{2:3} on the stack: @kbd{2 :@: 3 @key{RET}}, or @kbd{2 @key{RET} 3 /}
10968 assuming Fraction mode has been enabled.)
10969 When the Calculator produces a fractional result it always reduces it to
10970 simplest form, which may in fact be an integer.
10972 Fractions may also be entered in a three-part form, where @samp{2:3:4}
10973 represents two-and-three-quarters. @xref{Fraction Formats}, for fraction
10976 Non-decimal fractions are entered and displayed as
10977 @samp{@var{radix}#@var{num}:@var{denom}} (or in the analogous three-part
10978 form). The numerator and denominator always use the same radix.
10980 @node Floats, Complex Numbers, Fractions, Data Types
10984 @cindex Floating-point numbers
10985 A floating-point number or @dfn{float} is a number stored in scientific
10986 notation. The number of significant digits in the fractional part is
10987 governed by the current floating precision (@pxref{Precision}). The
10988 range of acceptable values is from
10989 @texline @math{10^{-3999999}}
10990 @infoline @expr{10^-3999999}
10992 @texline @math{10^{4000000}}
10993 @infoline @expr{10^4000000}
10994 (exclusive), plus the corresponding negative values and zero.
10996 Calculations that would exceed the allowable range of values (such
10997 as @samp{exp(exp(20))}) are left in symbolic form by Calc. The
10998 messages ``floating-point overflow'' or ``floating-point underflow''
10999 indicate that during the calculation a number would have been produced
11000 that was too large or too close to zero, respectively, to be represented
11001 by Calc. This does not necessarily mean the final result would have
11002 overflowed, just that an overflow occurred while computing the result.
11003 (In fact, it could report an underflow even though the final result
11004 would have overflowed!)
11006 If a rational number and a float are mixed in a calculation, the result
11007 will in general be expressed as a float. Commands that require an integer
11008 value (such as @kbd{k g} [@code{gcd}]) will also accept integer-valued
11009 floats, i.e., floating-point numbers with nothing after the decimal point.
11011 Floats are identified by the presence of a decimal point and/or an
11012 exponent. In general a float consists of an optional sign, digits
11013 including an optional decimal point, and an optional exponent consisting
11014 of an @samp{e}, an optional sign, and up to seven exponent digits.
11015 For example, @samp{23.5e-2} is 23.5 times ten to the minus-second power,
11018 Floating-point numbers are normally displayed in decimal notation with
11019 all significant figures shown. Exceedingly large or small numbers are
11020 displayed in scientific notation. Various other display options are
11021 available. @xref{Float Formats}.
11023 @cindex Accuracy of calculations
11024 Floating-point numbers are stored in decimal, not binary. The result
11025 of each operation is rounded to the nearest value representable in the
11026 number of significant digits specified by the current precision,
11027 rounding away from zero in the case of a tie. Thus (in the default
11028 display mode) what you see is exactly what you get. Some operations such
11029 as square roots and transcendental functions are performed with several
11030 digits of extra precision and then rounded down, in an effort to make the
11031 final result accurate to the full requested precision. However,
11032 accuracy is not rigorously guaranteed. If you suspect the validity of a
11033 result, try doing the same calculation in a higher precision. The
11034 Calculator's arithmetic is not intended to be IEEE-conformant in any
11037 While floats are always @emph{stored} in decimal, they can be entered
11038 and displayed in any radix just like integers and fractions. The
11039 notation @samp{@var{radix}#@var{ddd}.@var{ddd}} is a floating-point
11040 number whose digits are in the specified radix. Note that the @samp{.}
11041 is more aptly referred to as a ``radix point'' than as a decimal
11042 point in this case. The number @samp{8#123.4567} is defined as
11043 @samp{8#1234567 * 8^-4}. If the radix is 14 or less, you can use
11044 @samp{e} notation to write a non-decimal number in scientific notation.
11045 The exponent is written in decimal, and is considered to be a power
11046 of the radix: @samp{8#1234567e-4}. If the radix is 15 or above, the
11047 letter @samp{e} is a digit, so scientific notation must be written
11048 out, e.g., @samp{16#123.4567*16^2}. The first two exercises of the
11049 Modes Tutorial explore some of the properties of non-decimal floats.
11051 @node Complex Numbers, Infinities, Floats, Data Types
11052 @section Complex Numbers
11055 @cindex Complex numbers
11056 There are two supported formats for complex numbers: rectangular and
11057 polar. The default format is rectangular, displayed in the form
11058 @samp{(@var{real},@var{imag})} where @var{real} is the real part and
11059 @var{imag} is the imaginary part, each of which may be any real number.
11060 Rectangular complex numbers can also be displayed in @samp{@var{a}+@var{b}i}
11061 notation; @pxref{Complex Formats}.
11063 Polar complex numbers are displayed in the form
11064 @texline `@tfn{(}@var{r}@tfn{;}@math{\theta}@tfn{)}'
11065 @infoline `@tfn{(}@var{r}@tfn{;}@var{theta}@tfn{)}'
11066 where @var{r} is the nonnegative magnitude and
11067 @texline @math{\theta}
11068 @infoline @var{theta}
11069 is the argument or phase angle. The range of
11070 @texline @math{\theta}
11071 @infoline @var{theta}
11072 depends on the current angular mode (@pxref{Angular Modes}); it is
11073 generally between @mathit{-180} and @mathit{+180} degrees or the equivalent range
11076 Complex numbers are entered in stages using incomplete objects.
11077 @xref{Incomplete Objects}.
11079 Operations on rectangular complex numbers yield rectangular complex
11080 results, and similarly for polar complex numbers. Where the two types
11081 are mixed, or where new complex numbers arise (as for the square root of
11082 a negative real), the current @dfn{Polar mode} is used to determine the
11083 type. @xref{Polar Mode}.
11085 A complex result in which the imaginary part is zero (or the phase angle
11086 is 0 or 180 degrees or @cpi{} radians) is automatically converted to a real
11089 @node Infinities, Vectors and Matrices, Complex Numbers, Data Types
11090 @section Infinities
11094 @cindex @code{inf} variable
11095 @cindex @code{uinf} variable
11096 @cindex @code{nan} variable
11100 The word @code{inf} represents the mathematical concept of @dfn{infinity}.
11101 Calc actually has three slightly different infinity-like values:
11102 @code{inf}, @code{uinf}, and @code{nan}. These are just regular
11103 variable names (@pxref{Variables}); you should avoid using these
11104 names for your own variables because Calc gives them special
11105 treatment. Infinities, like all variable names, are normally
11106 entered using algebraic entry.
11108 Mathematically speaking, it is not rigorously correct to treat
11109 ``infinity'' as if it were a number, but mathematicians often do
11110 so informally. When they say that @samp{1 / inf = 0}, what they
11111 really mean is that @expr{1 / x}, as @expr{x} becomes larger and
11112 larger, becomes arbitrarily close to zero. So you can imagine
11113 that if @expr{x} got ``all the way to infinity,'' then @expr{1 / x}
11114 would go all the way to zero. Similarly, when they say that
11115 @samp{exp(inf) = inf}, they mean that
11116 @texline @math{e^x}
11117 @infoline @expr{exp(x)}
11118 grows without bound as @expr{x} grows. The symbol @samp{-inf} likewise
11119 stands for an infinitely negative real value; for example, we say that
11120 @samp{exp(-inf) = 0}. You can have an infinity pointing in any
11121 direction on the complex plane: @samp{sqrt(-inf) = i inf}.
11123 The same concept of limits can be used to define @expr{1 / 0}. We
11124 really want the value that @expr{1 / x} approaches as @expr{x}
11125 approaches zero. But if all we have is @expr{1 / 0}, we can't
11126 tell which direction @expr{x} was coming from. If @expr{x} was
11127 positive and decreasing toward zero, then we should say that
11128 @samp{1 / 0 = inf}. But if @expr{x} was negative and increasing
11129 toward zero, the answer is @samp{1 / 0 = -inf}. In fact, @expr{x}
11130 could be an imaginary number, giving the answer @samp{i inf} or
11131 @samp{-i inf}. Calc uses the special symbol @samp{uinf} to mean
11132 @dfn{undirected infinity}, i.e., a value which is infinitely
11133 large but with an unknown sign (or direction on the complex plane).
11135 Calc actually has three modes that say how infinities are handled.
11136 Normally, infinities never arise from calculations that didn't
11137 already have them. Thus, @expr{1 / 0} is treated simply as an
11138 error and left unevaluated. The @kbd{m i} (@code{calc-infinite-mode})
11139 command (@pxref{Infinite Mode}) enables a mode in which
11140 @expr{1 / 0} evaluates to @code{uinf} instead. There is also
11141 an alternative type of infinite mode which says to treat zeros
11142 as if they were positive, so that @samp{1 / 0 = inf}. While this
11143 is less mathematically correct, it may be the answer you want in
11146 Since all infinities are ``as large'' as all others, Calc simplifies,
11147 e.g., @samp{5 inf} to @samp{inf}. Another example is
11148 @samp{5 - inf = -inf}, where the @samp{-inf} is so large that
11149 adding a finite number like five to it does not affect it.
11150 Note that @samp{a - inf} also results in @samp{-inf}; Calc assumes
11151 that variables like @code{a} always stand for finite quantities.
11152 Just to show that infinities really are all the same size,
11153 note that @samp{sqrt(inf) = inf^2 = exp(inf) = inf} in Calc's
11156 It's not so easy to define certain formulas like @samp{0 * inf} and
11157 @samp{inf / inf}. Depending on where these zeros and infinities
11158 came from, the answer could be literally anything. The latter
11159 formula could be the limit of @expr{x / x} (giving a result of one),
11160 or @expr{2 x / x} (giving two), or @expr{x^2 / x} (giving @code{inf}),
11161 or @expr{x / x^2} (giving zero). Calc uses the symbol @code{nan}
11162 to represent such an @dfn{indeterminate} value. (The name ``nan''
11163 comes from analogy with the ``NAN'' concept of IEEE standard
11164 arithmetic; it stands for ``Not A Number.'' This is somewhat of a
11165 misnomer, since @code{nan} @emph{does} stand for some number or
11166 infinity, it's just that @emph{which} number it stands for
11167 cannot be determined.) In Calc's notation, @samp{0 * inf = nan}
11168 and @samp{inf / inf = nan}. A few other common indeterminate
11169 expressions are @samp{inf - inf} and @samp{inf ^ 0}. Also,
11170 @samp{0 / 0 = nan} if you have turned on Infinite mode
11171 (as described above).
11173 Infinities are especially useful as parts of @dfn{intervals}.
11174 @xref{Interval Forms}.
11176 @node Vectors and Matrices, Strings, Infinities, Data Types
11177 @section Vectors and Matrices
11181 @cindex Plain vectors
11183 The @dfn{vector} data type is flexible and general. A vector is simply a
11184 list of zero or more data objects. When these objects are numbers, the
11185 whole is a vector in the mathematical sense. When these objects are
11186 themselves vectors of equal (nonzero) length, the whole is a @dfn{matrix}.
11187 A vector which is not a matrix is referred to here as a @dfn{plain vector}.
11189 A vector is displayed as a list of values separated by commas and enclosed
11190 in square brackets: @samp{[1, 2, 3]}. Thus the following is a 2 row by
11191 3 column matrix: @samp{[[1, 2, 3], [4, 5, 6]]}. Vectors, like complex
11192 numbers, are entered as incomplete objects. @xref{Incomplete Objects}.
11193 During algebraic entry, vectors are entered all at once in the usual
11194 brackets-and-commas form. Matrices may be entered algebraically as nested
11195 vectors, or using the shortcut notation @w{@samp{[1, 2, 3; 4, 5, 6]}},
11196 with rows separated by semicolons. The commas may usually be omitted
11197 when entering vectors: @samp{[1 2 3]}. Curly braces may be used in
11198 place of brackets: @samp{@{1, 2, 3@}}, but the commas are required in
11201 Traditional vector and matrix arithmetic is also supported;
11202 @pxref{Basic Arithmetic} and @pxref{Matrix Functions}.
11203 Many other operations are applied to vectors element-wise. For example,
11204 the complex conjugate of a vector is a vector of the complex conjugates
11211 Algebraic functions for building vectors include @samp{vec(a, b, c)}
11212 to build @samp{[a, b, c]}, @samp{cvec(a, n, m)} to build an
11213 @texline @math{n\times m}
11214 @infoline @var{n}x@var{m}
11215 matrix of @samp{a}s, and @samp{index(n)} to build a vector of integers
11216 from 1 to @samp{n}.
11218 @node Strings, HMS Forms, Vectors and Matrices, Data Types
11224 @cindex Character strings
11225 Character strings are not a special data type in the Calculator.
11226 Rather, a string is represented simply as a vector all of whose
11227 elements are integers in the range 0 to 255 (ASCII codes). You can
11228 enter a string at any time by pressing the @kbd{"} key. Quotation
11229 marks and backslashes are written @samp{\"} and @samp{\\}, respectively,
11230 inside strings. Other notations introduced by backslashes are:
11246 Finally, a backslash followed by three octal digits produces any
11247 character from its ASCII code.
11250 @pindex calc-display-strings
11251 Strings are normally displayed in vector-of-integers form. The
11252 @w{@kbd{d "}} (@code{calc-display-strings}) command toggles a mode in
11253 which any vectors of small integers are displayed as quoted strings
11256 The backslash notations shown above are also used for displaying
11257 strings. Characters 128 and above are not translated by Calc; unless
11258 you have an Emacs modified for 8-bit fonts, these will show up in
11259 backslash-octal-digits notation. For characters below 32, and
11260 for character 127, Calc uses the backslash-letter combination if
11261 there is one, or otherwise uses a @samp{\^} sequence.
11263 The only Calc feature that uses strings is @dfn{compositions};
11264 @pxref{Compositions}. Strings also provide a convenient
11265 way to do conversions between ASCII characters and integers.
11271 There is a @code{string} function which provides a different display
11272 format for strings. Basically, @samp{string(@var{s})}, where @var{s}
11273 is a vector of integers in the proper range, is displayed as the
11274 corresponding string of characters with no surrounding quotation
11275 marks or other modifications. Thus @samp{string("ABC")} (or
11276 @samp{string([65 66 67])}) will look like @samp{ABC} on the stack.
11277 This happens regardless of whether @w{@kbd{d "}} has been used. The
11278 only way to turn it off is to use @kbd{d U} (unformatted language
11279 mode) which will display @samp{string("ABC")} instead.
11281 Control characters are displayed somewhat differently by @code{string}.
11282 Characters below 32, and character 127, are shown using @samp{^} notation
11283 (same as shown above, but without the backslash). The quote and
11284 backslash characters are left alone, as are characters 128 and above.
11290 The @code{bstring} function is just like @code{string} except that
11291 the resulting string is breakable across multiple lines if it doesn't
11292 fit all on one line. Potential break points occur at every space
11293 character in the string.
11295 @node HMS Forms, Date Forms, Strings, Data Types
11299 @cindex Hours-minutes-seconds forms
11300 @cindex Degrees-minutes-seconds forms
11301 @dfn{HMS} stands for Hours-Minutes-Seconds; when used as an angular
11302 argument, the interpretation is Degrees-Minutes-Seconds. All functions
11303 that operate on angles accept HMS forms. These are interpreted as
11304 degrees regardless of the current angular mode. It is also possible to
11305 use HMS as the angular mode so that calculated angles are expressed in
11306 degrees, minutes, and seconds.
11312 @kindex ' (HMS forms)
11316 @kindex " (HMS forms)
11320 @kindex h (HMS forms)
11324 @kindex o (HMS forms)
11328 @kindex m (HMS forms)
11332 @kindex s (HMS forms)
11333 The default format for HMS values is
11334 @samp{@var{hours}@@ @var{mins}' @var{secs}"}. During entry, the letters
11335 @samp{h} (for ``hours'') or
11336 @samp{o} (approximating the ``degrees'' symbol) are accepted as well as
11337 @samp{@@}, @samp{m} is accepted in place of @samp{'}, and @samp{s} is
11338 accepted in place of @samp{"}.
11339 The @var{hours} value is an integer (or integer-valued float).
11340 The @var{mins} value is an integer or integer-valued float between 0 and 59.
11341 The @var{secs} value is a real number between 0 (inclusive) and 60
11342 (exclusive). A positive HMS form is interpreted as @var{hours} +
11343 @var{mins}/60 + @var{secs}/3600. A negative HMS form is interpreted
11344 as @mathit{- @var{hours}} @mathit{-} @var{mins}/60 @mathit{-} @var{secs}/3600.
11345 Display format for HMS forms is quite flexible. @xref{HMS Formats}.
11347 HMS forms can be added and subtracted. When they are added to numbers,
11348 the numbers are interpreted according to the current angular mode. HMS
11349 forms can also be multiplied and divided by real numbers. Dividing
11350 two HMS forms produces a real-valued ratio of the two angles.
11353 @cindex Time of day
11354 Just for kicks, @kbd{M-x calc-time} pushes the current time of day on
11355 the stack as an HMS form.
11357 @node Date Forms, Modulo Forms, HMS Forms, Data Types
11358 @section Date Forms
11362 A @dfn{date form} represents a date and possibly an associated time.
11363 Simple date arithmetic is supported: Adding a number to a date
11364 produces a new date shifted by that many days; adding an HMS form to
11365 a date shifts it by that many hours. Subtracting two date forms
11366 computes the number of days between them (represented as a simple
11367 number). Many other operations, such as multiplying two date forms,
11368 are nonsensical and are not allowed by Calc.
11370 Date forms are entered and displayed enclosed in @samp{< >} brackets.
11371 The default format is, e.g., @samp{<Wed Jan 9, 1991>} for dates,
11372 or @samp{<3:32:20pm Wed Jan 9, 1991>} for dates with times.
11373 Input is flexible; date forms can be entered in any of the usual
11374 notations for dates and times. @xref{Date Formats}.
11376 Date forms are stored internally as numbers, specifically the number
11377 of days since midnight on the morning of January 1 of the year 1 AD.
11378 If the internal number is an integer, the form represents a date only;
11379 if the internal number is a fraction or float, the form represents
11380 a date and time. For example, @samp{<6:00am Wed Jan 9, 1991>}
11381 is represented by the number 726842.25. The standard precision of
11382 12 decimal digits is enough to ensure that a (reasonable) date and
11383 time can be stored without roundoff error.
11385 If the current precision is greater than 12, date forms will keep
11386 additional digits in the seconds position. For example, if the
11387 precision is 15, the seconds will keep three digits after the
11388 decimal point. Decreasing the precision below 12 may cause the
11389 time part of a date form to become inaccurate. This can also happen
11390 if astronomically high years are used, though this will not be an
11391 issue in everyday (or even everymillennium) use. Note that date
11392 forms without times are stored as exact integers, so roundoff is
11393 never an issue for them.
11395 You can use the @kbd{v p} (@code{calc-pack}) and @kbd{v u}
11396 (@code{calc-unpack}) commands to get at the numerical representation
11397 of a date form. @xref{Packing and Unpacking}.
11399 Date forms can go arbitrarily far into the future or past. Negative
11400 year numbers represent years BC. Calc uses a combination of the
11401 Gregorian and Julian calendars, following the history of Great
11402 Britain and the British colonies. This is the same calendar that
11403 is used by the @code{cal} program in most Unix implementations.
11405 @cindex Julian calendar
11406 @cindex Gregorian calendar
11407 Some historical background: The Julian calendar was created by
11408 Julius Caesar in the year 46 BC as an attempt to fix the gradual
11409 drift caused by the lack of leap years in the calendar used
11410 until that time. The Julian calendar introduced an extra day in
11411 all years divisible by four. After some initial confusion, the
11412 calendar was adopted around the year we call 8 AD. Some centuries
11413 later it became apparent that the Julian year of 365.25 days was
11414 itself not quite right. In 1582 Pope Gregory XIII introduced the
11415 Gregorian calendar, which added the new rule that years divisible
11416 by 100, but not by 400, were not to be considered leap years
11417 despite being divisible by four. Many countries delayed adoption
11418 of the Gregorian calendar because of religious differences;
11419 in Britain it was put off until the year 1752, by which time
11420 the Julian calendar had fallen eleven days behind the true
11421 seasons. So the switch to the Gregorian calendar in early
11422 September 1752 introduced a discontinuity: The day after
11423 Sep 2, 1752 is Sep 14, 1752. Calc follows this convention.
11424 To take another example, Russia waited until 1918 before
11425 adopting the new calendar, and thus needed to remove thirteen
11426 days (between Feb 1, 1918 and Feb 14, 1918). This means that
11427 Calc's reckoning will be inconsistent with Russian history between
11428 1752 and 1918, and similarly for various other countries.
11430 Today's timekeepers introduce an occasional ``leap second'' as
11431 well, but Calc does not take these minor effects into account.
11432 (If it did, it would have to report a non-integer number of days
11433 between, say, @samp{<12:00am Mon Jan 1, 1900>} and
11434 @samp{<12:00am Sat Jan 1, 2000>}.)
11436 Calc uses the Julian calendar for all dates before the year 1752,
11437 including dates BC when the Julian calendar technically had not
11438 yet been invented. Thus the claim that day number @mathit{-10000} is
11439 called ``August 16, 28 BC'' should be taken with a grain of salt.
11441 Please note that there is no ``year 0''; the day before
11442 @samp{<Sat Jan 1, +1>} is @samp{<Fri Dec 31, -1>}. These are
11443 days 0 and @mathit{-1} respectively in Calc's internal numbering scheme.
11445 @cindex Julian day counting
11446 Another day counting system in common use is, confusingly, also
11447 called ``Julian.'' It was invented in 1583 by Joseph Justus
11448 Scaliger, who named it in honor of his father Julius Caesar
11449 Scaliger. For obscure reasons he chose to start his day
11450 numbering on Jan 1, 4713 BC at noon, which in Calc's scheme
11451 is @mathit{-1721423.5} (recall that Calc starts at midnight instead
11452 of noon). Thus to convert a Calc date code obtained by
11453 unpacking a date form into a Julian day number, simply add
11454 1721423.5. The Julian code for @samp{6:00am Jan 9, 1991}
11455 is 2448265.75. The built-in @kbd{t J} command performs
11456 this conversion for you.
11458 @cindex Unix time format
11459 The Unix operating system measures time as an integer number of
11460 seconds since midnight, Jan 1, 1970. To convert a Calc date
11461 value into a Unix time stamp, first subtract 719164 (the code
11462 for @samp{<Jan 1, 1970>}), then multiply by 86400 (the number of
11463 seconds in a day) and press @kbd{R} to round to the nearest
11464 integer. If you have a date form, you can simply subtract the
11465 day @samp{<Jan 1, 1970>} instead of unpacking and subtracting
11466 719164. Likewise, divide by 86400 and add @samp{<Jan 1, 1970>}
11467 to convert from Unix time to a Calc date form. (Note that
11468 Unix normally maintains the time in the GMT time zone; you may
11469 need to subtract five hours to get New York time, or eight hours
11470 for California time. The same is usually true of Julian day
11471 counts.) The built-in @kbd{t U} command performs these
11474 @node Modulo Forms, Error Forms, Date Forms, Data Types
11475 @section Modulo Forms
11478 @cindex Modulo forms
11479 A @dfn{modulo form} is a real number which is taken modulo (i.e., within
11480 an integer multiple of) some value @var{M}. Arithmetic modulo @var{M}
11481 often arises in number theory. Modulo forms are written
11482 `@var{a} @tfn{mod} @var{M}',
11483 where @var{a} and @var{M} are real numbers or HMS forms, and
11484 @texline @math{0 \le a < M}.
11485 @infoline @expr{0 <= a < @var{M}}.
11486 In many applications @expr{a} and @expr{M} will be
11487 integers but this is not required.
11492 @kindex M (modulo forms)
11496 @tindex mod (operator)
11497 To create a modulo form during numeric entry, press the shift-@kbd{M}
11498 key to enter the word @samp{mod}. As a special convenience, pressing
11499 shift-@kbd{M} a second time automatically enters the value of @expr{M}
11500 that was most recently used before. During algebraic entry, either
11501 type @samp{mod} by hand or press @kbd{M-m} (that's @kbd{@key{META}-m}).
11502 Once again, pressing this a second time enters the current modulo.
11504 Modulo forms are not to be confused with the modulo operator @samp{%}.
11505 The expression @samp{27 % 10} means to compute 27 modulo 10 to produce
11506 the result 7. Further computations treat this 7 as just a regular integer.
11507 The expression @samp{27 mod 10} produces the result @samp{7 mod 10};
11508 further computations with this value are again reduced modulo 10 so that
11509 the result always lies in the desired range.
11511 When two modulo forms with identical @expr{M}'s are added or multiplied,
11512 the Calculator simply adds or multiplies the values, then reduces modulo
11513 @expr{M}. If one argument is a modulo form and the other a plain number,
11514 the plain number is treated like a compatible modulo form. It is also
11515 possible to raise modulo forms to powers; the result is the value raised
11516 to the power, then reduced modulo @expr{M}. (When all values involved
11517 are integers, this calculation is done much more efficiently than
11518 actually computing the power and then reducing.)
11520 @cindex Modulo division
11521 Two modulo forms `@var{a} @tfn{mod} @var{M}' and `@var{b} @tfn{mod} @var{M}'
11522 can be divided if @expr{a}, @expr{b}, and @expr{M} are all
11523 integers. The result is the modulo form which, when multiplied by
11524 `@var{b} @tfn{mod} @var{M}', produces `@var{a} @tfn{mod} @var{M}'. If
11525 there is no solution to this equation (which can happen only when
11526 @expr{M} is non-prime), or if any of the arguments are non-integers, the
11527 division is left in symbolic form. Other operations, such as square
11528 roots, are not yet supported for modulo forms. (Note that, although
11529 @w{`@tfn{(}@var{a} @tfn{mod} @var{M}@tfn{)^.5}'} will compute a ``modulo square root''
11530 in the sense of reducing
11531 @texline @math{\sqrt a}
11532 @infoline @expr{sqrt(a)}
11533 modulo @expr{M}, this is not a useful definition from the
11534 number-theoretical point of view.)
11536 It is possible to mix HMS forms and modulo forms. For example, an
11537 HMS form modulo 24 could be used to manipulate clock times; an HMS
11538 form modulo 360 would be suitable for angles. Making the modulo @expr{M}
11539 also be an HMS form eliminates troubles that would arise if the angular
11540 mode were inadvertently set to Radians, in which case
11541 @w{@samp{2@@ 0' 0" mod 24}} would be interpreted as two degrees modulo
11544 Modulo forms cannot have variables or formulas for components. If you
11545 enter the formula @samp{(x + 2) mod 5}, Calc propagates the modulus
11546 to each of the coefficients: @samp{(1 mod 5) x + (2 mod 5)}.
11548 You can use @kbd{v p} and @kbd{%} to modify modulo forms.
11549 @xref{Packing and Unpacking}. @xref{Basic Arithmetic}.
11555 The algebraic function @samp{makemod(a, m)} builds the modulo form
11556 @w{@samp{a mod m}}.
11558 @node Error Forms, Interval Forms, Modulo Forms, Data Types
11559 @section Error Forms
11562 @cindex Error forms
11563 @cindex Standard deviations
11564 An @dfn{error form} is a number with an associated standard
11565 deviation, as in @samp{2.3 +/- 0.12}. The notation
11566 @texline `@var{x} @tfn{+/-} @math{\sigma}'
11567 @infoline `@var{x} @tfn{+/-} sigma'
11568 stands for an uncertain value which follows
11569 a normal or Gaussian distribution of mean @expr{x} and standard
11570 deviation or ``error''
11571 @texline @math{\sigma}.
11572 @infoline @expr{sigma}.
11573 Both the mean and the error can be either numbers or
11574 formulas. Generally these are real numbers but the mean may also be
11575 complex. If the error is negative or complex, it is changed to its
11576 absolute value. An error form with zero error is converted to a
11577 regular number by the Calculator.
11579 All arithmetic and transcendental functions accept error forms as input.
11580 Operations on the mean-value part work just like operations on regular
11581 numbers. The error part for any function @expr{f(x)} (such as
11582 @texline @math{\sin x}
11583 @infoline @expr{sin(x)})
11584 is defined by the error of @expr{x} times the derivative of @expr{f}
11585 evaluated at the mean value of @expr{x}. For a two-argument function
11586 @expr{f(x,y)} (such as addition) the error is the square root of the sum
11587 of the squares of the errors due to @expr{x} and @expr{y}.
11590 f(x \hbox{\code{ +/- }} \sigma)
11591 &= f(x) \hbox{\code{ +/- }} \sigma \left| {df(x) \over dx} \right| \cr
11592 f(x \hbox{\code{ +/- }} \sigma_x, y \hbox{\code{ +/- }} \sigma_y)
11593 &= f(x,y) \hbox{\code{ +/- }}
11594 \sqrt{\left(\sigma_x \left| {\partial f(x,y) \over \partial x}
11596 +\left(\sigma_y \left| {\partial f(x,y) \over \partial y}
11597 \right| \right)^2 } \cr
11601 definition assumes the errors in @expr{x} and @expr{y} are uncorrelated.
11602 A side effect of this definition is that @samp{(2 +/- 1) * (2 +/- 1)}
11603 is not the same as @samp{(2 +/- 1)^2}; the former represents the product
11604 of two independent values which happen to have the same probability
11605 distributions, and the latter is the product of one random value with itself.
11606 The former will produce an answer with less error, since on the average
11607 the two independent errors can be expected to cancel out.
11609 Consult a good text on error analysis for a discussion of the proper use
11610 of standard deviations. Actual errors often are neither Gaussian-distributed
11611 nor uncorrelated, and the above formulas are valid only when errors
11612 are small. As an example, the error arising from
11613 @texline `@tfn{sin(}@var{x} @tfn{+/-} @math{\sigma}@tfn{)}'
11614 @infoline `@tfn{sin(}@var{x} @tfn{+/-} @var{sigma}@tfn{)}'
11616 @texline `@math{\sigma} @tfn{abs(cos(}@var{x}@tfn{))}'.
11617 @infoline `@var{sigma} @tfn{abs(cos(}@var{x}@tfn{))}'.
11618 When @expr{x} is close to zero,
11619 @texline @math{\cos x}
11620 @infoline @expr{cos(x)}
11621 is close to one so the error in the sine is close to
11622 @texline @math{\sigma};
11623 @infoline @expr{sigma};
11624 this makes sense, since
11625 @texline @math{\sin x}
11626 @infoline @expr{sin(x)}
11627 is approximately @expr{x} near zero, so a given error in @expr{x} will
11628 produce about the same error in the sine. Likewise, near 90 degrees
11629 @texline @math{\cos x}
11630 @infoline @expr{cos(x)}
11631 is nearly zero and so the computed error is
11632 small: The sine curve is nearly flat in that region, so an error in @expr{x}
11633 has relatively little effect on the value of
11634 @texline @math{\sin x}.
11635 @infoline @expr{sin(x)}.
11636 However, consider @samp{sin(90 +/- 1000)}. The cosine of 90 is zero, so
11637 Calc will report zero error! We get an obviously wrong result because
11638 we have violated the small-error approximation underlying the error
11639 analysis. If the error in @expr{x} had been small, the error in
11640 @texline @math{\sin x}
11641 @infoline @expr{sin(x)}
11642 would indeed have been negligible.
11647 @kindex p (error forms)
11649 To enter an error form during regular numeric entry, use the @kbd{p}
11650 (``plus-or-minus'') key to type the @samp{+/-} symbol. (If you try actually
11651 typing @samp{+/-} the @kbd{+} key will be interpreted as the Calculator's
11652 @kbd{+} command!) Within an algebraic formula, you can press @kbd{M-p} to
11653 type the @samp{+/-} symbol, or type it out by hand.
11655 Error forms and complex numbers can be mixed; the formulas shown above
11656 are used for complex numbers, too; note that if the error part evaluates
11657 to a complex number its absolute value (or the square root of the sum of
11658 the squares of the absolute values of the two error contributions) is
11659 used. Mathematically, this corresponds to a radially symmetric Gaussian
11660 distribution of numbers on the complex plane. However, note that Calc
11661 considers an error form with real components to represent a real number,
11662 not a complex distribution around a real mean.
11664 Error forms may also be composed of HMS forms. For best results, both
11665 the mean and the error should be HMS forms if either one is.
11671 The algebraic function @samp{sdev(a, b)} builds the error form @samp{a +/- b}.
11673 @node Interval Forms, Incomplete Objects, Error Forms, Data Types
11674 @section Interval Forms
11677 @cindex Interval forms
11678 An @dfn{interval} is a subset of consecutive real numbers. For example,
11679 the interval @samp{[2 ..@: 4]} represents all the numbers from 2 to 4,
11680 inclusive. If you multiply it by the interval @samp{[0.5 ..@: 2]} you
11681 obtain @samp{[1 ..@: 8]}. This calculation represents the fact that if
11682 you multiply some number in the range @samp{[2 ..@: 4]} by some other
11683 number in the range @samp{[0.5 ..@: 2]}, your result will lie in the range
11684 from 1 to 8. Interval arithmetic is used to get a worst-case estimate
11685 of the possible range of values a computation will produce, given the
11686 set of possible values of the input.
11689 Calc supports several varieties of intervals, including @dfn{closed}
11690 intervals of the type shown above, @dfn{open} intervals such as
11691 @samp{(2 ..@: 4)}, which represents the range of numbers from 2 to 4
11692 @emph{exclusive}, and @dfn{semi-open} intervals in which one end
11693 uses a round parenthesis and the other a square bracket. In mathematical
11695 @samp{[2 ..@: 4]} means @expr{2 <= x <= 4}, whereas
11696 @samp{[2 ..@: 4)} represents @expr{2 <= x < 4},
11697 @samp{(2 ..@: 4]} represents @expr{2 < x <= 4}, and
11698 @samp{(2 ..@: 4)} represents @expr{2 < x < 4}.
11701 Calc supports several varieties of intervals, including \dfn{closed}
11702 intervals of the type shown above, \dfn{open} intervals such as
11703 \samp{(2 ..\: 4)}, which represents the range of numbers from 2 to 4
11704 \emph{exclusive}, and \dfn{semi-open} intervals in which one end
11705 uses a round parenthesis and the other a square bracket. In mathematical
11708 [2 \hbox{\cite{..}} 4] &\quad\hbox{means}\quad 2 \le x \le 4 \cr
11709 [2 \hbox{\cite{..}} 4) &\quad\hbox{means}\quad 2 \le x < 4 \cr
11710 (2 \hbox{\cite{..}} 4] &\quad\hbox{means}\quad 2 < x \le 4 \cr
11711 (2 \hbox{\cite{..}} 4) &\quad\hbox{means}\quad 2 < x < 4 \cr
11715 The lower and upper limits of an interval must be either real numbers
11716 (or HMS or date forms), or symbolic expressions which are assumed to be
11717 real-valued, or @samp{-inf} and @samp{inf}. In general the lower limit
11718 must be less than the upper limit. A closed interval containing only
11719 one value, @samp{[3 ..@: 3]}, is converted to a plain number (3)
11720 automatically. An interval containing no values at all (such as
11721 @samp{[3 ..@: 2]} or @samp{[2 ..@: 2)}) can be represented but is not
11722 guaranteed to behave well when used in arithmetic. Note that the
11723 interval @samp{[3 .. inf)} represents all real numbers greater than
11724 or equal to 3, and @samp{(-inf .. inf)} represents all real numbers.
11725 In fact, @samp{[-inf .. inf]} represents all real numbers including
11726 the real infinities.
11728 Intervals are entered in the notation shown here, either as algebraic
11729 formulas, or using incomplete forms. (@xref{Incomplete Objects}.)
11730 In algebraic formulas, multiple periods in a row are collected from
11731 left to right, so that @samp{1...1e2} is interpreted as @samp{1.0 ..@: 1e2}
11732 rather than @samp{1 ..@: 0.1e2}. Add spaces or zeros if you want to
11733 get the other interpretation. If you omit the lower or upper limit,
11734 a default of @samp{-inf} or @samp{inf} (respectively) is furnished.
11736 Infinite mode also affects operations on intervals
11737 (@pxref{Infinities}). Calc will always introduce an open infinity,
11738 as in @samp{1 / (0 .. 2] = [0.5 .. inf)}. But closed infinities,
11739 @w{@samp{1 / [0 .. 2] = [0.5 .. inf]}}, arise only in Infinite mode;
11740 otherwise they are left unevaluated. Note that the ``direction'' of
11741 a zero is not an issue in this case since the zero is always assumed
11742 to be continuous with the rest of the interval. For intervals that
11743 contain zero inside them Calc is forced to give the result,
11744 @samp{1 / (-2 .. 2) = [-inf .. inf]}.
11746 While it may seem that intervals and error forms are similar, they are
11747 based on entirely different concepts of inexact quantities. An error
11749 @texline `@var{x} @tfn{+/-} @math{\sigma}'
11750 @infoline `@var{x} @tfn{+/-} @var{sigma}'
11751 means a variable is random, and its value could
11752 be anything but is ``probably'' within one
11753 @texline @math{\sigma}
11754 @infoline @var{sigma}
11755 of the mean value @expr{x}. An interval
11756 `@tfn{[}@var{a} @tfn{..@:} @var{b}@tfn{]}' means a
11757 variable's value is unknown, but guaranteed to lie in the specified
11758 range. Error forms are statistical or ``average case'' approximations;
11759 interval arithmetic tends to produce ``worst case'' bounds on an
11762 Intervals may not contain complex numbers, but they may contain
11763 HMS forms or date forms.
11765 @xref{Set Operations}, for commands that interpret interval forms
11766 as subsets of the set of real numbers.
11772 The algebraic function @samp{intv(n, a, b)} builds an interval form
11773 from @samp{a} to @samp{b}; @samp{n} is an integer code which must
11774 be 0 for @samp{(..)}, 1 for @samp{(..]}, 2 for @samp{[..)}, or
11777 Please note that in fully rigorous interval arithmetic, care would be
11778 taken to make sure that the computation of the lower bound rounds toward
11779 minus infinity, while upper bound computations round toward plus
11780 infinity. Calc's arithmetic always uses a round-to-nearest mode,
11781 which means that roundoff errors could creep into an interval
11782 calculation to produce intervals slightly smaller than they ought to
11783 be. For example, entering @samp{[1..2]} and pressing @kbd{Q 2 ^}
11784 should yield the interval @samp{[1..2]} again, but in fact it yields the
11785 (slightly too small) interval @samp{[1..1.9999999]} due to roundoff
11788 @node Incomplete Objects, Variables, Interval Forms, Data Types
11789 @section Incomplete Objects
11809 @cindex Incomplete vectors
11810 @cindex Incomplete complex numbers
11811 @cindex Incomplete interval forms
11812 When @kbd{(} or @kbd{[} is typed to begin entering a complex number or
11813 vector, respectively, the effect is to push an @dfn{incomplete} complex
11814 number or vector onto the stack. The @kbd{,} key adds the value(s) at
11815 the top of the stack onto the current incomplete object. The @kbd{)}
11816 and @kbd{]} keys ``close'' the incomplete object after adding any values
11817 on the top of the stack in front of the incomplete object.
11819 As a result, the sequence of keystrokes @kbd{[ 2 , 3 @key{RET} 2 * , 9 ]}
11820 pushes the vector @samp{[2, 6, 9]} onto the stack. Likewise, @kbd{( 1 , 2 Q )}
11821 pushes the complex number @samp{(1, 1.414)} (approximately).
11823 If several values lie on the stack in front of the incomplete object,
11824 all are collected and appended to the object. Thus the @kbd{,} key
11825 is redundant: @kbd{[ 2 @key{RET} 3 @key{RET} 2 * 9 ]}. Some people
11826 prefer the equivalent @key{SPC} key to @key{RET}.
11828 As a special case, typing @kbd{,} immediately after @kbd{(}, @kbd{[}, or
11829 @kbd{,} adds a zero or duplicates the preceding value in the list being
11830 formed. Typing @key{DEL} during incomplete entry removes the last item
11834 The @kbd{;} key is used in the same way as @kbd{,} to create polar complex
11835 numbers: @kbd{( 1 ; 2 )}. When entering a vector, @kbd{;} is useful for
11836 creating a matrix. In particular, @kbd{[ [ 1 , 2 ; 3 , 4 ; 5 , 6 ] ]} is
11837 equivalent to @kbd{[ [ 1 , 2 ] , [ 3 , 4 ] , [ 5 , 6 ] ]}.
11841 Incomplete entry is also used to enter intervals. For example,
11842 @kbd{[ 2 ..@: 4 )} enters a semi-open interval. Note that when you type
11843 the first period, it will be interpreted as a decimal point, but when
11844 you type a second period immediately afterward, it is re-interpreted as
11845 part of the interval symbol. Typing @kbd{..} corresponds to executing
11846 the @code{calc-dots} command.
11848 If you find incomplete entry distracting, you may wish to enter vectors
11849 and complex numbers as algebraic formulas by pressing the apostrophe key.
11851 @node Variables, Formulas, Incomplete Objects, Data Types
11855 @cindex Variables, in formulas
11856 A @dfn{variable} is somewhere between a storage register on a conventional
11857 calculator, and a variable in a programming language. (In fact, a Calc
11858 variable is really just an Emacs Lisp variable that contains a Calc number
11859 or formula.) A variable's name is normally composed of letters and digits.
11860 Calc also allows apostrophes and @code{#} signs in variable names.
11861 (The Calc variable @code{foo} corresponds to the Emacs Lisp variable
11862 @code{var-foo}, but unless you access the variable from within Emacs
11863 Lisp, you don't need to worry about it. Variable names in algebraic
11864 formulas implicitly have @samp{var-} prefixed to their names. The
11865 @samp{#} character in variable names used in algebraic formulas
11866 corresponds to a dash @samp{-} in the Lisp variable name. If the name
11867 contains any dashes, the prefix @samp{var-} is @emph{not} automatically
11868 added. Thus the two formulas @samp{foo + 1} and @samp{var#foo + 1} both
11869 refer to the same variable.)
11871 In a command that takes a variable name, you can either type the full
11872 name of a variable, or type a single digit to use one of the special
11873 convenience variables @code{q0} through @code{q9}. For example,
11874 @kbd{3 s s 2} stores the number 3 in variable @code{q2}, and
11875 @w{@kbd{3 s s foo @key{RET}}} stores that number in variable
11878 To push a variable itself (as opposed to the variable's value) on the
11879 stack, enter its name as an algebraic expression using the apostrophe
11883 @pindex calc-evaluate
11884 @cindex Evaluation of variables in a formula
11885 @cindex Variables, evaluation
11886 @cindex Formulas, evaluation
11887 The @kbd{=} (@code{calc-evaluate}) key ``evaluates'' a formula by
11888 replacing all variables in the formula which have been given values by a
11889 @code{calc-store} or @code{calc-let} command by their stored values.
11890 Other variables are left alone. Thus a variable that has not been
11891 stored acts like an abstract variable in algebra; a variable that has
11892 been stored acts more like a register in a traditional calculator.
11893 With a positive numeric prefix argument, @kbd{=} evaluates the top
11894 @var{n} stack entries; with a negative argument, @kbd{=} evaluates
11895 the @var{n}th stack entry.
11897 @cindex @code{e} variable
11898 @cindex @code{pi} variable
11899 @cindex @code{i} variable
11900 @cindex @code{phi} variable
11901 @cindex @code{gamma} variable
11907 A few variables are called @dfn{special constants}. Their names are
11908 @samp{e}, @samp{pi}, @samp{i}, @samp{phi}, and @samp{gamma}.
11909 (@xref{Scientific Functions}.) When they are evaluated with @kbd{=},
11910 their values are calculated if necessary according to the current precision
11911 or complex polar mode. If you wish to use these symbols for other purposes,
11912 simply undefine or redefine them using @code{calc-store}.
11914 The variables @samp{inf}, @samp{uinf}, and @samp{nan} stand for
11915 infinite or indeterminate values. It's best not to use them as
11916 regular variables, since Calc uses special algebraic rules when
11917 it manipulates them. Calc displays a warning message if you store
11918 a value into any of these special variables.
11920 @xref{Store and Recall}, for a discussion of commands dealing with variables.
11922 @node Formulas, , Variables, Data Types
11927 @cindex Expressions
11928 @cindex Operators in formulas
11929 @cindex Precedence of operators
11930 When you press the apostrophe key you may enter any expression or formula
11931 in algebraic form. (Calc uses the terms ``expression'' and ``formula''
11932 interchangeably.) An expression is built up of numbers, variable names,
11933 and function calls, combined with various arithmetic operators.
11935 be used to indicate grouping. Spaces are ignored within formulas, except
11936 that spaces are not permitted within variable names or numbers.
11937 Arithmetic operators, in order from highest to lowest precedence, and
11938 with their equivalent function names, are:
11940 @samp{_} [@code{subscr}] (subscripts);
11942 postfix @samp{%} [@code{percent}] (as in @samp{25% = 0.25});
11944 prefix @samp{+} and @samp{-} [@code{neg}] (as in @samp{-x})
11945 and prefix @samp{!} [@code{lnot}] (logical ``not,'' as in @samp{!x});
11947 @samp{+/-} [@code{sdev}] (the standard deviation symbol) and
11948 @samp{mod} [@code{makemod}] (the symbol for modulo forms);
11950 postfix @samp{!} [@code{fact}] (factorial, as in @samp{n!})
11951 and postfix @samp{!!} [@code{dfact}] (double factorial);
11953 @samp{^} [@code{pow}] (raised-to-the-power-of);
11955 @samp{*} [@code{mul}];
11957 @samp{/} [@code{div}], @samp{%} [@code{mod}] (modulo), and
11958 @samp{\} [@code{idiv}] (integer division);
11960 infix @samp{+} [@code{add}] and @samp{-} [@code{sub}] (as in @samp{x-y});
11962 @samp{|} [@code{vconcat}] (vector concatenation);
11964 relations @samp{=} [@code{eq}], @samp{!=} [@code{neq}], @samp{<} [@code{lt}],
11965 @samp{>} [@code{gt}], @samp{<=} [@code{leq}], and @samp{>=} [@code{geq}];
11967 @samp{&&} [@code{land}] (logical ``and'');
11969 @samp{||} [@code{lor}] (logical ``or'');
11971 the C-style ``if'' operator @samp{a?b:c} [@code{if}];
11973 @samp{!!!} [@code{pnot}] (rewrite pattern ``not'');
11975 @samp{&&&} [@code{pand}] (rewrite pattern ``and'');
11977 @samp{|||} [@code{por}] (rewrite pattern ``or'');
11979 @samp{:=} [@code{assign}] (for assignments and rewrite rules);
11981 @samp{::} [@code{condition}] (rewrite pattern condition);
11983 @samp{=>} [@code{evalto}].
11985 Note that, unlike in usual computer notation, multiplication binds more
11986 strongly than division: @samp{a*b/c*d} is equivalent to
11987 @texline @math{a b \over c d}.
11988 @infoline @expr{(a*b)/(c*d)}.
11990 @cindex Multiplication, implicit
11991 @cindex Implicit multiplication
11992 The multiplication sign @samp{*} may be omitted in many cases. In particular,
11993 if the righthand side is a number, variable name, or parenthesized
11994 expression, the @samp{*} may be omitted. Implicit multiplication has the
11995 same precedence as the explicit @samp{*} operator. The one exception to
11996 the rule is that a variable name followed by a parenthesized expression,
11998 is interpreted as a function call, not an implicit @samp{*}. In many
11999 cases you must use a space if you omit the @samp{*}: @samp{2a} is the
12000 same as @samp{2*a}, and @samp{a b} is the same as @samp{a*b}, but @samp{ab}
12001 is a variable called @code{ab}, @emph{not} the product of @samp{a} and
12002 @samp{b}! Also note that @samp{f (x)} is still a function call.
12004 @cindex Implicit comma in vectors
12005 The rules are slightly different for vectors written with square brackets.
12006 In vectors, the space character is interpreted (like the comma) as a
12007 separator of elements of the vector. Thus @w{@samp{[ 2a b+c d ]}} is
12008 equivalent to @samp{[2*a, b+c, d]}, whereas @samp{2a b+c d} is equivalent
12009 to @samp{2*a*b + c*d}.
12010 Note that spaces around the brackets, and around explicit commas, are
12011 ignored. To force spaces to be interpreted as multiplication you can
12012 enclose a formula in parentheses as in @samp{[(a b) 2(c d)]}, which is
12013 interpreted as @samp{[a*b, 2*c*d]}. An implicit comma is also inserted
12014 between @samp{][}, as in the matrix @samp{[[1 2][3 4]]}.
12016 Vectors that contain commas (not embedded within nested parentheses or
12017 brackets) do not treat spaces specially: @samp{[a b, 2 c d]} is a vector
12018 of two elements. Also, if it would be an error to treat spaces as
12019 separators, but not otherwise, then Calc will ignore spaces:
12020 @w{@samp{[a - b]}} is a vector of one element, but @w{@samp{[a -b]}} is
12021 a vector of two elements. Finally, vectors entered with curly braces
12022 instead of square brackets do not give spaces any special treatment.
12023 When Calc displays a vector that does not contain any commas, it will
12024 insert parentheses if necessary to make the meaning clear:
12025 @w{@samp{[(a b)]}}.
12027 The expression @samp{5%-2} is ambiguous; is this five-percent minus two,
12028 or five modulo minus-two? Calc always interprets the leftmost symbol as
12029 an infix operator preferentially (modulo, in this case), so you would
12030 need to write @samp{(5%)-2} to get the former interpretation.
12032 @cindex Function call notation
12033 A function call is, e.g., @samp{sin(1+x)}. (The Calc algebraic function
12034 @code{foo} corresponds to the Emacs Lisp function @code{calcFunc-foo},
12035 but unless you access the function from within Emacs Lisp, you don't
12036 need to worry about it.) Most mathematical Calculator commands like
12037 @code{calc-sin} have function equivalents like @code{sin}.
12038 If no Lisp function is defined for a function called by a formula, the
12039 call is left as it is during algebraic manipulation: @samp{f(x+y)} is
12040 left alone. Beware that many innocent-looking short names like @code{in}
12041 and @code{re} have predefined meanings which could surprise you; however,
12042 single letters or single letters followed by digits are always safe to
12043 use for your own function names. @xref{Function Index}.
12045 In the documentation for particular commands, the notation @kbd{H S}
12046 (@code{calc-sinh}) [@code{sinh}] means that the key sequence @kbd{H S}, the
12047 command @kbd{M-x calc-sinh}, and the algebraic function @code{sinh(x)} all
12048 represent the same operation.
12050 Commands that interpret (``parse'') text as algebraic formulas include
12051 algebraic entry (@kbd{'}), editing commands like @kbd{`} which parse
12052 the contents of the editing buffer when you finish, the @kbd{M-# g}
12053 and @w{@kbd{M-# r}} commands, the @kbd{C-y} command, the X window system
12054 ``paste'' mouse operation, and Embedded mode. All of these operations
12055 use the same rules for parsing formulas; in particular, language modes
12056 (@pxref{Language Modes}) affect them all in the same way.
12058 When you read a large amount of text into the Calculator (say a vector
12059 which represents a big set of rewrite rules; @pxref{Rewrite Rules}),
12060 you may wish to include comments in the text. Calc's formula parser
12061 ignores the symbol @samp{%%} and anything following it on a line:
12064 [ a + b, %% the sum of "a" and "b"
12066 %% last line is coming up:
12071 This is parsed exactly the same as @samp{[ a + b, c + d, e + f ]}.
12073 @xref{Syntax Tables}, for a way to create your own operators and other
12074 input notations. @xref{Compositions}, for a way to create new display
12077 @xref{Algebra}, for commands for manipulating formulas symbolically.
12079 @node Stack and Trail, Mode Settings, Data Types, Top
12080 @chapter Stack and Trail Commands
12083 This chapter describes the Calc commands for manipulating objects on the
12084 stack and in the trail buffer. (These commands operate on objects of any
12085 type, such as numbers, vectors, formulas, and incomplete objects.)
12088 * Stack Manipulation::
12089 * Editing Stack Entries::
12094 @node Stack Manipulation, Editing Stack Entries, Stack and Trail, Stack and Trail
12095 @section Stack Manipulation Commands
12101 @cindex Duplicating stack entries
12102 To duplicate the top object on the stack, press @key{RET} or @key{SPC}
12103 (two equivalent keys for the @code{calc-enter} command).
12104 Given a positive numeric prefix argument, these commands duplicate
12105 several elements at the top of the stack.
12106 Given a negative argument,
12107 these commands duplicate the specified element of the stack.
12108 Given an argument of zero, they duplicate the entire stack.
12109 For example, with @samp{10 20 30} on the stack,
12110 @key{RET} creates @samp{10 20 30 30},
12111 @kbd{C-u 2 @key{RET}} creates @samp{10 20 30 20 30},
12112 @kbd{C-u - 2 @key{RET}} creates @samp{10 20 30 20}, and
12113 @kbd{C-u 0 @key{RET}} creates @samp{10 20 30 10 20 30}.
12117 The @key{LFD} (@code{calc-over}) command (on a key marked Line-Feed if you
12118 have it, else on @kbd{C-j}) is like @code{calc-enter}
12119 except that the sign of the numeric prefix argument is interpreted
12120 oppositely. Also, with no prefix argument the default argument is 2.
12121 Thus with @samp{10 20 30} on the stack, @key{LFD} and @kbd{C-u 2 @key{LFD}}
12122 are both equivalent to @kbd{C-u - 2 @key{RET}}, producing
12123 @samp{10 20 30 20}.
12128 @cindex Removing stack entries
12129 @cindex Deleting stack entries
12130 To remove the top element from the stack, press @key{DEL} (@code{calc-pop}).
12131 The @kbd{C-d} key is a synonym for @key{DEL}.
12132 (If the top element is an incomplete object with at least one element, the
12133 last element is removed from it.) Given a positive numeric prefix argument,
12134 several elements are removed. Given a negative argument, the specified
12135 element of the stack is deleted. Given an argument of zero, the entire
12137 For example, with @samp{10 20 30} on the stack,
12138 @key{DEL} leaves @samp{10 20},
12139 @kbd{C-u 2 @key{DEL}} leaves @samp{10},
12140 @kbd{C-u - 2 @key{DEL}} leaves @samp{10 30}, and
12141 @kbd{C-u 0 @key{DEL}} leaves an empty stack.
12143 @kindex M-@key{DEL}
12144 @pindex calc-pop-above
12145 The @kbd{M-@key{DEL}} (@code{calc-pop-above}) command is to @key{DEL} what
12146 @key{LFD} is to @key{RET}: It interprets the sign of the numeric
12147 prefix argument in the opposite way, and the default argument is 2.
12148 Thus @kbd{M-@key{DEL}} by itself removes the second-from-top stack element,
12149 leaving the first, third, fourth, and so on; @kbd{M-3 M-@key{DEL}} deletes
12150 the third stack element.
12153 @pindex calc-roll-down
12154 To exchange the top two elements of the stack, press @key{TAB}
12155 (@code{calc-roll-down}). Given a positive numeric prefix argument, the
12156 specified number of elements at the top of the stack are rotated downward.
12157 Given a negative argument, the entire stack is rotated downward the specified
12158 number of times. Given an argument of zero, the entire stack is reversed
12160 For example, with @samp{10 20 30 40 50} on the stack,
12161 @key{TAB} creates @samp{10 20 30 50 40},
12162 @kbd{C-u 3 @key{TAB}} creates @samp{10 20 50 30 40},
12163 @kbd{C-u - 2 @key{TAB}} creates @samp{40 50 10 20 30}, and
12164 @kbd{C-u 0 @key{TAB}} creates @samp{50 40 30 20 10}.
12166 @kindex M-@key{TAB}
12167 @pindex calc-roll-up
12168 The command @kbd{M-@key{TAB}} (@code{calc-roll-up}) is analogous to @key{TAB}
12169 except that it rotates upward instead of downward. Also, the default
12170 with no prefix argument is to rotate the top 3 elements.
12171 For example, with @samp{10 20 30 40 50} on the stack,
12172 @kbd{M-@key{TAB}} creates @samp{10 20 40 50 30},
12173 @kbd{C-u 4 M-@key{TAB}} creates @samp{10 30 40 50 20},
12174 @kbd{C-u - 2 M-@key{TAB}} creates @samp{30 40 50 10 20}, and
12175 @kbd{C-u 0 M-@key{TAB}} creates @samp{50 40 30 20 10}.
12177 A good way to view the operation of @key{TAB} and @kbd{M-@key{TAB}} is in
12178 terms of moving a particular element to a new position in the stack.
12179 With a positive argument @var{n}, @key{TAB} moves the top stack
12180 element down to level @var{n}, making room for it by pulling all the
12181 intervening stack elements toward the top. @kbd{M-@key{TAB}} moves the
12182 element at level @var{n} up to the top. (Compare with @key{LFD},
12183 which copies instead of moving the element in level @var{n}.)
12185 With a negative argument @mathit{-@var{n}}, @key{TAB} rotates the stack
12186 to move the object in level @var{n} to the deepest place in the
12187 stack, and the object in level @mathit{@var{n}+1} to the top. @kbd{M-@key{TAB}}
12188 rotates the deepest stack element to be in level @mathit{n}, also
12189 putting the top stack element in level @mathit{@var{n}+1}.
12191 @xref{Selecting Subformulas}, for a way to apply these commands to
12192 any portion of a vector or formula on the stack.
12194 @node Editing Stack Entries, Trail Commands, Stack Manipulation, Stack and Trail
12195 @section Editing Stack Entries
12200 @pindex calc-edit-finish
12201 @cindex Editing the stack with Emacs
12202 The backquote, @kbd{`} (@code{calc-edit}) command creates a temporary
12203 buffer (@samp{*Calc Edit*}) for editing the top-of-stack value using
12204 regular Emacs commands. With a numeric prefix argument, it edits the
12205 specified number of stack entries at once. (An argument of zero edits
12206 the entire stack; a negative argument edits one specific stack entry.)
12208 When you are done editing, press @kbd{C-c C-c} to finish and return
12209 to Calc. The @key{RET} and @key{LFD} keys also work to finish most
12210 sorts of editing, though in some cases Calc leaves @key{RET} with its
12211 usual meaning (``insert a newline'') if it's a situation where you
12212 might want to insert new lines into the editing buffer.
12214 When you finish editing, the Calculator parses the lines of text in
12215 the @samp{*Calc Edit*} buffer as numbers or formulas, replaces the
12216 original stack elements in the original buffer with these new values,
12217 then kills the @samp{*Calc Edit*} buffer. The original Calculator buffer
12218 continues to exist during editing, but for best results you should be
12219 careful not to change it until you have finished the edit. You can
12220 also cancel the edit by killing the buffer with @kbd{C-x k}.
12222 The formula is normally reevaluated as it is put onto the stack.
12223 For example, editing @samp{a + 2} to @samp{3 + 2} and pressing
12224 @kbd{C-c C-c} will push 5 on the stack. If you use @key{LFD} to
12225 finish, Calc will put the result on the stack without evaluating it.
12227 If you give a prefix argument to @kbd{C-c C-c},
12228 Calc will not kill the @samp{*Calc Edit*} buffer. You can switch
12229 back to that buffer and continue editing if you wish. However, you
12230 should understand that if you initiated the edit with @kbd{`}, the
12231 @kbd{C-c C-c} operation will be programmed to replace the top of the
12232 stack with the new edited value, and it will do this even if you have
12233 rearranged the stack in the meanwhile. This is not so much of a problem
12234 with other editing commands, though, such as @kbd{s e}
12235 (@code{calc-edit-variable}; @pxref{Operations on Variables}).
12237 If the @code{calc-edit} command involves more than one stack entry,
12238 each line of the @samp{*Calc Edit*} buffer is interpreted as a
12239 separate formula. Otherwise, the entire buffer is interpreted as
12240 one formula, with line breaks ignored. (You can use @kbd{C-o} or
12241 @kbd{C-q C-j} to insert a newline in the buffer without pressing @key{RET}.)
12243 The @kbd{`} key also works during numeric or algebraic entry. The
12244 text entered so far is moved to the @code{*Calc Edit*} buffer for
12245 more extensive editing than is convenient in the minibuffer.
12247 @node Trail Commands, Keep Arguments, Editing Stack Entries, Stack and Trail
12248 @section Trail Commands
12251 @cindex Trail buffer
12252 The commands for manipulating the Calc Trail buffer are two-key sequences
12253 beginning with the @kbd{t} prefix.
12256 @pindex calc-trail-display
12257 The @kbd{t d} (@code{calc-trail-display}) command turns display of the
12258 trail on and off. Normally the trail display is toggled on if it was off,
12259 off if it was on. With a numeric prefix of zero, this command always
12260 turns the trail off; with a prefix of one, it always turns the trail on.
12261 The other trail-manipulation commands described here automatically turn
12262 the trail on. Note that when the trail is off values are still recorded
12263 there; they are simply not displayed. To set Emacs to turn the trail
12264 off by default, type @kbd{t d} and then save the mode settings with
12265 @kbd{m m} (@code{calc-save-modes}).
12268 @pindex calc-trail-in
12270 @pindex calc-trail-out
12271 The @kbd{t i} (@code{calc-trail-in}) and @kbd{t o}
12272 (@code{calc-trail-out}) commands switch the cursor into and out of the
12273 Calc Trail window. In practice they are rarely used, since the commands
12274 shown below are a more convenient way to move around in the
12275 trail, and they work ``by remote control'' when the cursor is still
12276 in the Calculator window.
12278 @cindex Trail pointer
12279 There is a @dfn{trail pointer} which selects some entry of the trail at
12280 any given time. The trail pointer looks like a @samp{>} symbol right
12281 before the selected number. The following commands operate on the
12282 trail pointer in various ways.
12285 @pindex calc-trail-yank
12286 @cindex Retrieving previous results
12287 The @kbd{t y} (@code{calc-trail-yank}) command reads the selected value in
12288 the trail and pushes it onto the Calculator stack. It allows you to
12289 re-use any previously computed value without retyping. With a numeric
12290 prefix argument @var{n}, it yanks the value @var{n} lines above the current
12294 @pindex calc-trail-scroll-left
12296 @pindex calc-trail-scroll-right
12297 The @kbd{t <} (@code{calc-trail-scroll-left}) and @kbd{t >}
12298 (@code{calc-trail-scroll-right}) commands horizontally scroll the trail
12299 window left or right by one half of its width.
12302 @pindex calc-trail-next
12304 @pindex calc-trail-previous
12306 @pindex calc-trail-forward
12308 @pindex calc-trail-backward
12309 The @kbd{t n} (@code{calc-trail-next}) and @kbd{t p}
12310 (@code{calc-trail-previous)} commands move the trail pointer down or up
12311 one line. The @kbd{t f} (@code{calc-trail-forward}) and @kbd{t b}
12312 (@code{calc-trail-backward}) commands move the trail pointer down or up
12313 one screenful at a time. All of these commands accept numeric prefix
12314 arguments to move several lines or screenfuls at a time.
12317 @pindex calc-trail-first
12319 @pindex calc-trail-last
12321 @pindex calc-trail-here
12322 The @kbd{t [} (@code{calc-trail-first}) and @kbd{t ]}
12323 (@code{calc-trail-last}) commands move the trail pointer to the first or
12324 last line of the trail. The @kbd{t h} (@code{calc-trail-here}) command
12325 moves the trail pointer to the cursor position; unlike the other trail
12326 commands, @kbd{t h} works only when Calc Trail is the selected window.
12329 @pindex calc-trail-isearch-forward
12331 @pindex calc-trail-isearch-backward
12333 The @kbd{t s} (@code{calc-trail-isearch-forward}) and @kbd{t r}
12334 (@code{calc-trail-isearch-backward}) commands perform an incremental
12335 search forward or backward through the trail. You can press @key{RET}
12336 to terminate the search; the trail pointer moves to the current line.
12337 If you cancel the search with @kbd{C-g}, the trail pointer stays where
12338 it was when the search began.
12341 The @kbd{t s} (@code{calc-trail-isearch-forward}) and @kbd{t r}
12342 (@code{calc-trail-isearch-backward}) com\-mands perform an incremental
12343 search forward or backward through the trail. You can press @key{RET}
12344 to terminate the search; the trail pointer moves to the current line.
12345 If you cancel the search with @kbd{C-g}, the trail pointer stays where
12346 it was when the search began.
12350 @pindex calc-trail-marker
12351 The @kbd{t m} (@code{calc-trail-marker}) command allows you to enter a
12352 line of text of your own choosing into the trail. The text is inserted
12353 after the line containing the trail pointer; this usually means it is
12354 added to the end of the trail. Trail markers are useful mainly as the
12355 targets for later incremental searches in the trail.
12358 @pindex calc-trail-kill
12359 The @kbd{t k} (@code{calc-trail-kill}) command removes the selected line
12360 from the trail. The line is saved in the Emacs kill ring suitable for
12361 yanking into another buffer, but it is not easy to yank the text back
12362 into the trail buffer. With a numeric prefix argument, this command
12363 kills the @var{n} lines below or above the selected one.
12365 The @kbd{t .} (@code{calc-full-trail-vectors}) command is described
12366 elsewhere; @pxref{Vector and Matrix Formats}.
12368 @node Keep Arguments, , Trail Commands, Stack and Trail
12369 @section Keep Arguments
12373 @pindex calc-keep-args
12374 The @kbd{K} (@code{calc-keep-args}) command acts like a prefix for
12375 the following command. It prevents that command from removing its
12376 arguments from the stack. For example, after @kbd{2 @key{RET} 3 +},
12377 the stack contains the sole number 5, but after @kbd{2 @key{RET} 3 K +},
12378 the stack contains the arguments and the result: @samp{2 3 5}.
12380 With the exception of keyboard macros, this works for all commands that
12381 take arguments off the stack. (To avoid potentially unpleasant behavior,
12382 a @kbd{K} prefix before a keyboard macro will be ignored. A @kbd{K}
12383 prefix called @emph{within} the keyboard macro will still take effect.)
12384 As another example, @kbd{K a s} simplifies a formula, pushing the
12385 simplified version of the formula onto the stack after the original
12386 formula (rather than replacing the original formula). Note that you
12387 could get the same effect by typing @kbd{@key{RET} a s}, copying the
12388 formula and then simplifying the copy. One difference is that for a very
12389 large formula the time taken to format the intermediate copy in
12390 @kbd{@key{RET} a s} could be noticeable; @kbd{K a s} would avoid this
12393 Even stack manipulation commands are affected. @key{TAB} works by
12394 popping two values and pushing them back in the opposite order,
12395 so @kbd{2 @key{RET} 3 K @key{TAB}} produces @samp{2 3 3 2}.
12397 A few Calc commands provide other ways of doing the same thing.
12398 For example, @kbd{' sin($)} replaces the number on the stack with
12399 its sine using algebraic entry; to push the sine and keep the
12400 original argument you could use either @kbd{' sin($1)} or
12401 @kbd{K ' sin($)}. @xref{Algebraic Entry}. Also, the @kbd{s s}
12402 command is effectively the same as @kbd{K s t}. @xref{Storing Variables}.
12404 If you execute a command and then decide you really wanted to keep
12405 the argument, you can press @kbd{M-@key{RET}} (@code{calc-last-args}).
12406 This command pushes the last arguments that were popped by any command
12407 onto the stack. Note that the order of things on the stack will be
12408 different than with @kbd{K}: @kbd{2 @key{RET} 3 + M-@key{RET}} leaves
12409 @samp{5 2 3} on the stack instead of @samp{2 3 5}. @xref{Undo}.
12411 @node Mode Settings, Arithmetic, Stack and Trail, Top
12412 @chapter Mode Settings
12415 This chapter describes commands that set modes in the Calculator.
12416 They do not affect the contents of the stack, although they may change
12417 the @emph{appearance} or @emph{interpretation} of the stack's contents.
12420 * General Mode Commands::
12422 * Inverse and Hyperbolic::
12423 * Calculation Modes::
12424 * Simplification Modes::
12432 @node General Mode Commands, Precision, Mode Settings, Mode Settings
12433 @section General Mode Commands
12437 @pindex calc-save-modes
12438 @cindex Continuous memory
12439 @cindex Saving mode settings
12440 @cindex Permanent mode settings
12441 @cindex Calc init file, mode settings
12442 You can save all of the current mode settings in your Calc init file
12443 (the file given by the variable @code{calc-settings-file}, typically
12444 @file{~/.calc.el}) with the @kbd{m m} (@code{calc-save-modes}) command.
12445 This will cause Emacs to reestablish these modes each time it starts up.
12446 The modes saved in the file include everything controlled by the @kbd{m}
12447 and @kbd{d} prefix keys, the current precision and binary word size,
12448 whether or not the trail is displayed, the current height of the Calc
12449 window, and more. The current interface (used when you type @kbd{M-#
12450 M-#}) is also saved. If there were already saved mode settings in the
12451 file, they are replaced. Otherwise, the new mode information is
12452 appended to the end of the file.
12455 @pindex calc-mode-record-mode
12456 The @kbd{m R} (@code{calc-mode-record-mode}) command tells Calc to
12457 record all the mode settings (as if by pressing @kbd{m m}) every
12458 time a mode setting changes. If the modes are saved this way, then this
12459 ``automatic mode recording'' mode is also saved.
12460 Type @kbd{m R} again to disable this method of recording the mode
12461 settings. To turn it off permanently, the @kbd{m m} command will also be
12462 necessary. (If Embedded mode is enabled, other options for recording
12463 the modes are available; @pxref{Mode Settings in Embedded Mode}.)
12466 @pindex calc-settings-file-name
12467 The @kbd{m F} (@code{calc-settings-file-name}) command allows you to
12468 choose a different file than the current value of @code{calc-settings-file}
12469 for @kbd{m m}, @kbd{Z P}, and similar commands to save permanent information.
12470 You are prompted for a file name. All Calc modes are then reset to
12471 their default values, then settings from the file you named are loaded
12472 if this file exists, and this file becomes the one that Calc will
12473 use in the future for commands like @kbd{m m}. The default settings
12474 file name is @file{~/.calc.el}. You can see the current file name by
12475 giving a blank response to the @kbd{m F} prompt. See also the
12476 discussion of the @code{calc-settings-file} variable; @pxref{Customizable Variables}.
12478 If the file name you give is your user init file (typically
12479 @file{~/.emacs}), @kbd{m F} will not automatically load the new file. This
12480 is because your user init file may contain other things you don't want
12481 to reread. You can give
12482 a numeric prefix argument of 1 to @kbd{m F} to force it to read the
12483 file no matter what. Conversely, an argument of @mathit{-1} tells
12484 @kbd{m F} @emph{not} to read the new file. An argument of 2 or @mathit{-2}
12485 tells @kbd{m F} not to reset the modes to their defaults beforehand,
12486 which is useful if you intend your new file to have a variant of the
12487 modes present in the file you were using before.
12490 @pindex calc-always-load-extensions
12491 The @kbd{m x} (@code{calc-always-load-extensions}) command enables a mode
12492 in which the first use of Calc loads the entire program, including all
12493 extensions modules. Otherwise, the extensions modules will not be loaded
12494 until the various advanced Calc features are used. Since this mode only
12495 has effect when Calc is first loaded, @kbd{m x} is usually followed by
12496 @kbd{m m} to make the mode-setting permanent. To load all of Calc just
12497 once, rather than always in the future, you can press @kbd{M-# L}.
12500 @pindex calc-shift-prefix
12501 The @kbd{m S} (@code{calc-shift-prefix}) command enables a mode in which
12502 all of Calc's letter prefix keys may be typed shifted as well as unshifted.
12503 If you are typing, say, @kbd{a S} (@code{calc-solve-for}) quite often
12504 you might find it easier to turn this mode on so that you can type
12505 @kbd{A S} instead. When this mode is enabled, the commands that used to
12506 be on those single shifted letters (e.g., @kbd{A} (@code{calc-abs})) can
12507 now be invoked by pressing the shifted letter twice: @kbd{A A}. Note
12508 that the @kbd{v} prefix key always works both shifted and unshifted, and
12509 the @kbd{z} and @kbd{Z} prefix keys are always distinct. Also, the @kbd{h}
12510 prefix is not affected by this mode. Press @kbd{m S} again to disable
12511 shifted-prefix mode.
12513 @node Precision, Inverse and Hyperbolic, General Mode Commands, Mode Settings
12518 @pindex calc-precision
12519 @cindex Precision of calculations
12520 The @kbd{p} (@code{calc-precision}) command controls the precision to
12521 which floating-point calculations are carried. The precision must be
12522 at least 3 digits and may be arbitrarily high, within the limits of
12523 memory and time. This affects only floats: Integer and rational
12524 calculations are always carried out with as many digits as necessary.
12526 The @kbd{p} key prompts for the current precision. If you wish you
12527 can instead give the precision as a numeric prefix argument.
12529 Many internal calculations are carried to one or two digits higher
12530 precision than normal. Results are rounded down afterward to the
12531 current precision. Unless a special display mode has been selected,
12532 floats are always displayed with their full stored precision, i.e.,
12533 what you see is what you get. Reducing the current precision does not
12534 round values already on the stack, but those values will be rounded
12535 down before being used in any calculation. The @kbd{c 0} through
12536 @kbd{c 9} commands (@pxref{Conversions}) can be used to round an
12537 existing value to a new precision.
12539 @cindex Accuracy of calculations
12540 It is important to distinguish the concepts of @dfn{precision} and
12541 @dfn{accuracy}. In the normal usage of these words, the number
12542 123.4567 has a precision of 7 digits but an accuracy of 4 digits.
12543 The precision is the total number of digits not counting leading
12544 or trailing zeros (regardless of the position of the decimal point).
12545 The accuracy is simply the number of digits after the decimal point
12546 (again not counting trailing zeros). In Calc you control the precision,
12547 not the accuracy of computations. If you were to set the accuracy
12548 instead, then calculations like @samp{exp(100)} would generate many
12549 more digits than you would typically need, while @samp{exp(-100)} would
12550 probably round to zero! In Calc, both these computations give you
12551 exactly 12 (or the requested number of) significant digits.
12553 The only Calc features that deal with accuracy instead of precision
12554 are fixed-point display mode for floats (@kbd{d f}; @pxref{Float Formats}),
12555 and the rounding functions like @code{floor} and @code{round}
12556 (@pxref{Integer Truncation}). Also, @kbd{c 0} through @kbd{c 9}
12557 deal with both precision and accuracy depending on the magnitudes
12558 of the numbers involved.
12560 If you need to work with a particular fixed accuracy (say, dollars and
12561 cents with two digits after the decimal point), one solution is to work
12562 with integers and an ``implied'' decimal point. For example, $8.99
12563 divided by 6 would be entered @kbd{899 @key{RET} 6 /}, yielding 149.833
12564 (actually $1.49833 with our implied decimal point); pressing @kbd{R}
12565 would round this to 150 cents, i.e., $1.50.
12567 @xref{Floats}, for still more on floating-point precision and related
12570 @node Inverse and Hyperbolic, Calculation Modes, Precision, Mode Settings
12571 @section Inverse and Hyperbolic Flags
12575 @pindex calc-inverse
12576 There is no single-key equivalent to the @code{calc-arcsin} function.
12577 Instead, you must first press @kbd{I} (@code{calc-inverse}) to set
12578 the @dfn{Inverse Flag}, then press @kbd{S} (@code{calc-sin}).
12579 The @kbd{I} key actually toggles the Inverse Flag. When this flag
12580 is set, the word @samp{Inv} appears in the mode line.
12583 @pindex calc-hyperbolic
12584 Likewise, the @kbd{H} key (@code{calc-hyperbolic}) sets or clears the
12585 Hyperbolic Flag, which transforms @code{calc-sin} into @code{calc-sinh}.
12586 If both of these flags are set at once, the effect will be
12587 @code{calc-arcsinh}. (The Hyperbolic flag is also used by some
12588 non-trigonometric commands; for example @kbd{H L} computes a base-10,
12589 instead of base-@mathit{e}, logarithm.)
12591 Command names like @code{calc-arcsin} are provided for completeness, and
12592 may be executed with @kbd{x} or @kbd{M-x}. Their effect is simply to
12593 toggle the Inverse and/or Hyperbolic flags and then execute the
12594 corresponding base command (@code{calc-sin} in this case).
12596 The Inverse and Hyperbolic flags apply only to the next Calculator
12597 command, after which they are automatically cleared. (They are also
12598 cleared if the next keystroke is not a Calc command.) Digits you
12599 type after @kbd{I} or @kbd{H} (or @kbd{K}) are treated as prefix
12600 arguments for the next command, not as numeric entries. The same
12601 is true of @kbd{C-u}, but not of the minus sign (@kbd{K -} means to
12602 subtract and keep arguments).
12604 The third Calc prefix flag, @kbd{K} (keep-arguments), is discussed
12605 elsewhere. @xref{Keep Arguments}.
12607 @node Calculation Modes, Simplification Modes, Inverse and Hyperbolic, Mode Settings
12608 @section Calculation Modes
12611 The commands in this section are two-key sequences beginning with
12612 the @kbd{m} prefix. (That's the letter @kbd{m}, not the @key{META} key.)
12613 The @samp{m a} (@code{calc-algebraic-mode}) command is described elsewhere
12614 (@pxref{Algebraic Entry}).
12623 * Automatic Recomputation::
12624 * Working Message::
12627 @node Angular Modes, Polar Mode, Calculation Modes, Calculation Modes
12628 @subsection Angular Modes
12631 @cindex Angular mode
12632 The Calculator supports three notations for angles: radians, degrees,
12633 and degrees-minutes-seconds. When a number is presented to a function
12634 like @code{sin} that requires an angle, the current angular mode is
12635 used to interpret the number as either radians or degrees. If an HMS
12636 form is presented to @code{sin}, it is always interpreted as
12637 degrees-minutes-seconds.
12639 Functions that compute angles produce a number in radians, a number in
12640 degrees, or an HMS form depending on the current angular mode. If the
12641 result is a complex number and the current mode is HMS, the number is
12642 instead expressed in degrees. (Complex-number calculations would
12643 normally be done in Radians mode, though. Complex numbers are converted
12644 to degrees by calculating the complex result in radians and then
12645 multiplying by 180 over @cpi{}.)
12648 @pindex calc-radians-mode
12650 @pindex calc-degrees-mode
12652 @pindex calc-hms-mode
12653 The @kbd{m r} (@code{calc-radians-mode}), @kbd{m d} (@code{calc-degrees-mode}),
12654 and @kbd{m h} (@code{calc-hms-mode}) commands control the angular mode.
12655 The current angular mode is displayed on the Emacs mode line.
12656 The default angular mode is Degrees.
12658 @node Polar Mode, Fraction Mode, Angular Modes, Calculation Modes
12659 @subsection Polar Mode
12663 The Calculator normally ``prefers'' rectangular complex numbers in the
12664 sense that rectangular form is used when the proper form can not be
12665 decided from the input. This might happen by multiplying a rectangular
12666 number by a polar one, by taking the square root of a negative real
12667 number, or by entering @kbd{( 2 @key{SPC} 3 )}.
12670 @pindex calc-polar-mode
12671 The @kbd{m p} (@code{calc-polar-mode}) command toggles complex-number
12672 preference between rectangular and polar forms. In Polar mode, all
12673 of the above example situations would produce polar complex numbers.
12675 @node Fraction Mode, Infinite Mode, Polar Mode, Calculation Modes
12676 @subsection Fraction Mode
12679 @cindex Fraction mode
12680 @cindex Division of integers
12681 Division of two integers normally yields a floating-point number if the
12682 result cannot be expressed as an integer. In some cases you would
12683 rather get an exact fractional answer. One way to accomplish this is
12684 to use the @kbd{:} (@code{calc-fdiv}) [@code{fdiv}] command, which
12685 divides the two integers on the top of the stack to produce a fraction:
12686 @kbd{6 @key{RET} 4 :} produces @expr{3:2} even though
12687 @kbd{6 @key{RET} 4 /} produces @expr{1.5}.
12690 @pindex calc-frac-mode
12691 To set the Calculator to produce fractional results for normal integer
12692 divisions, use the @kbd{m f} (@code{calc-frac-mode}) command.
12693 For example, @expr{8/4} produces @expr{2} in either mode,
12694 but @expr{6/4} produces @expr{3:2} in Fraction mode, @expr{1.5} in
12697 At any time you can use @kbd{c f} (@code{calc-float}) to convert a
12698 fraction to a float, or @kbd{c F} (@code{calc-fraction}) to convert a
12699 float to a fraction. @xref{Conversions}.
12701 @node Infinite Mode, Symbolic Mode, Fraction Mode, Calculation Modes
12702 @subsection Infinite Mode
12705 @cindex Infinite mode
12706 The Calculator normally treats results like @expr{1 / 0} as errors;
12707 formulas like this are left in unsimplified form. But Calc can be
12708 put into a mode where such calculations instead produce ``infinite''
12712 @pindex calc-infinite-mode
12713 The @kbd{m i} (@code{calc-infinite-mode}) command turns this mode
12714 on and off. When the mode is off, infinities do not arise except
12715 in calculations that already had infinities as inputs. (One exception
12716 is that infinite open intervals like @samp{[0 .. inf)} can be
12717 generated; however, intervals closed at infinity (@samp{[0 .. inf]})
12718 will not be generated when Infinite mode is off.)
12720 With Infinite mode turned on, @samp{1 / 0} will generate @code{uinf},
12721 an undirected infinity. @xref{Infinities}, for a discussion of the
12722 difference between @code{inf} and @code{uinf}. Also, @expr{0 / 0}
12723 evaluates to @code{nan}, the ``indeterminate'' symbol. Various other
12724 functions can also return infinities in this mode; for example,
12725 @samp{ln(0) = -inf}, and @samp{gamma(-7) = uinf}. Once again,
12726 note that @samp{exp(inf) = inf} regardless of Infinite mode because
12727 this calculation has infinity as an input.
12729 @cindex Positive Infinite mode
12730 The @kbd{m i} command with a numeric prefix argument of zero,
12731 i.e., @kbd{C-u 0 m i}, turns on a Positive Infinite mode in
12732 which zero is treated as positive instead of being directionless.
12733 Thus, @samp{1 / 0 = inf} and @samp{-1 / 0 = -inf} in this mode.
12734 Note that zero never actually has a sign in Calc; there are no
12735 separate representations for @mathit{+0} and @mathit{-0}. Positive
12736 Infinite mode merely changes the interpretation given to the
12737 single symbol, @samp{0}. One consequence of this is that, while
12738 you might expect @samp{1 / -0 = -inf}, actually @samp{1 / -0}
12739 is equivalent to @samp{1 / 0}, which is equal to positive @code{inf}.
12741 @node Symbolic Mode, Matrix Mode, Infinite Mode, Calculation Modes
12742 @subsection Symbolic Mode
12745 @cindex Symbolic mode
12746 @cindex Inexact results
12747 Calculations are normally performed numerically wherever possible.
12748 For example, the @code{calc-sqrt} command, or @code{sqrt} function in an
12749 algebraic expression, produces a numeric answer if the argument is a
12750 number or a symbolic expression if the argument is an expression:
12751 @kbd{2 Q} pushes 1.4142 but @kbd{@key{'} x+1 @key{RET} Q} pushes @samp{sqrt(x+1)}.
12754 @pindex calc-symbolic-mode
12755 In @dfn{Symbolic mode}, controlled by the @kbd{m s} (@code{calc-symbolic-mode})
12756 command, functions which would produce inexact, irrational results are
12757 left in symbolic form. Thus @kbd{16 Q} pushes 4, but @kbd{2 Q} pushes
12761 @pindex calc-eval-num
12762 The shift-@kbd{N} (@code{calc-eval-num}) command evaluates numerically
12763 the expression at the top of the stack, by temporarily disabling
12764 @code{calc-symbolic-mode} and executing @kbd{=} (@code{calc-evaluate}).
12765 Given a numeric prefix argument, it also
12766 sets the floating-point precision to the specified value for the duration
12769 To evaluate a formula numerically without expanding the variables it
12770 contains, you can use the key sequence @kbd{m s a v m s} (this uses
12771 @code{calc-alg-evaluate}, which resimplifies but doesn't evaluate
12774 @node Matrix Mode, Automatic Recomputation, Symbolic Mode, Calculation Modes
12775 @subsection Matrix and Scalar Modes
12778 @cindex Matrix mode
12779 @cindex Scalar mode
12780 Calc sometimes makes assumptions during algebraic manipulation that
12781 are awkward or incorrect when vectors and matrices are involved.
12782 Calc has two modes, @dfn{Matrix mode} and @dfn{Scalar mode}, which
12783 modify its behavior around vectors in useful ways.
12786 @pindex calc-matrix-mode
12787 Press @kbd{m v} (@code{calc-matrix-mode}) once to enter Matrix mode.
12788 In this mode, all objects are assumed to be matrices unless provably
12789 otherwise. One major effect is that Calc will no longer consider
12790 multiplication to be commutative. (Recall that in matrix arithmetic,
12791 @samp{A*B} is not the same as @samp{B*A}.) This assumption affects
12792 rewrite rules and algebraic simplification. Another effect of this
12793 mode is that calculations that would normally produce constants like
12794 0 and 1 (e.g., @expr{a - a} and @expr{a / a}, respectively) will now
12795 produce function calls that represent ``generic'' zero or identity
12796 matrices: @samp{idn(0)}, @samp{idn(1)}. The @code{idn} function
12797 @samp{idn(@var{a},@var{n})} returns @var{a} times an @var{n}x@var{n}
12798 identity matrix; if @var{n} is omitted, it doesn't know what
12799 dimension to use and so the @code{idn} call remains in symbolic
12800 form. However, if this generic identity matrix is later combined
12801 with a matrix whose size is known, it will be converted into
12802 a true identity matrix of the appropriate size. On the other hand,
12803 if it is combined with a scalar (as in @samp{idn(1) + 2}), Calc
12804 will assume it really was a scalar after all and produce, e.g., 3.
12806 Press @kbd{m v} a second time to get Scalar mode. Here, objects are
12807 assumed @emph{not} to be vectors or matrices unless provably so.
12808 For example, normally adding a variable to a vector, as in
12809 @samp{[x, y, z] + a}, will leave the sum in symbolic form because
12810 as far as Calc knows, @samp{a} could represent either a number or
12811 another 3-vector. In Scalar mode, @samp{a} is assumed to be a
12812 non-vector, and the addition is evaluated to @samp{[x+a, y+a, z+a]}.
12814 Press @kbd{m v} a third time to return to the normal mode of operation.
12816 If you press @kbd{m v} with a numeric prefix argument @var{n}, you
12817 get a special ``dimensioned'' Matrix mode in which matrices of
12818 unknown size are assumed to be @var{n}x@var{n} square matrices.
12819 Then, the function call @samp{idn(1)} will expand into an actual
12820 matrix rather than representing a ``generic'' matrix.
12822 @cindex Declaring scalar variables
12823 Of course these modes are approximations to the true state of
12824 affairs, which is probably that some quantities will be matrices
12825 and others will be scalars. One solution is to ``declare''
12826 certain variables or functions to be scalar-valued.
12827 @xref{Declarations}, to see how to make declarations in Calc.
12829 There is nothing stopping you from declaring a variable to be
12830 scalar and then storing a matrix in it; however, if you do, the
12831 results you get from Calc may not be valid. Suppose you let Calc
12832 get the result @samp{[x+a, y+a, z+a]} shown above, and then stored
12833 @samp{[1, 2, 3]} in @samp{a}. The result would not be the same as
12834 for @samp{[x, y, z] + [1, 2, 3]}, but that's because you have broken
12835 your earlier promise to Calc that @samp{a} would be scalar.
12837 Another way to mix scalars and matrices is to use selections
12838 (@pxref{Selecting Subformulas}). Use Matrix mode when operating on
12839 your formula normally; then, to apply Scalar mode to a certain part
12840 of the formula without affecting the rest just select that part,
12841 change into Scalar mode and press @kbd{=} to resimplify the part
12842 under this mode, then change back to Matrix mode before deselecting.
12844 @node Automatic Recomputation, Working Message, Matrix Mode, Calculation Modes
12845 @subsection Automatic Recomputation
12848 The @dfn{evaluates-to} operator, @samp{=>}, has the special
12849 property that any @samp{=>} formulas on the stack are recomputed
12850 whenever variable values or mode settings that might affect them
12851 are changed. @xref{Evaluates-To Operator}.
12854 @pindex calc-auto-recompute
12855 The @kbd{m C} (@code{calc-auto-recompute}) command turns this
12856 automatic recomputation on and off. If you turn it off, Calc will
12857 not update @samp{=>} operators on the stack (nor those in the
12858 attached Embedded mode buffer, if there is one). They will not
12859 be updated unless you explicitly do so by pressing @kbd{=} or until
12860 you press @kbd{m C} to turn recomputation back on. (While automatic
12861 recomputation is off, you can think of @kbd{m C m C} as a command
12862 to update all @samp{=>} operators while leaving recomputation off.)
12864 To update @samp{=>} operators in an Embedded buffer while
12865 automatic recomputation is off, use @w{@kbd{M-# u}}.
12866 @xref{Embedded Mode}.
12868 @node Working Message, , Automatic Recomputation, Calculation Modes
12869 @subsection Working Messages
12872 @cindex Performance
12873 @cindex Working messages
12874 Since the Calculator is written entirely in Emacs Lisp, which is not
12875 designed for heavy numerical work, many operations are quite slow.
12876 The Calculator normally displays the message @samp{Working...} in the
12877 echo area during any command that may be slow. In addition, iterative
12878 operations such as square roots and trigonometric functions display the
12879 intermediate result at each step. Both of these types of messages can
12880 be disabled if you find them distracting.
12883 @pindex calc-working
12884 Type @kbd{m w} (@code{calc-working}) with a numeric prefix of 0 to
12885 disable all ``working'' messages. Use a numeric prefix of 1 to enable
12886 only the plain @samp{Working...} message. Use a numeric prefix of 2 to
12887 see intermediate results as well. With no numeric prefix this displays
12890 While it may seem that the ``working'' messages will slow Calc down
12891 considerably, experiments have shown that their impact is actually
12892 quite small. But if your terminal is slow you may find that it helps
12893 to turn the messages off.
12895 @node Simplification Modes, Declarations, Calculation Modes, Mode Settings
12896 @section Simplification Modes
12899 The current @dfn{simplification mode} controls how numbers and formulas
12900 are ``normalized'' when being taken from or pushed onto the stack.
12901 Some normalizations are unavoidable, such as rounding floating-point
12902 results to the current precision, and reducing fractions to simplest
12903 form. Others, such as simplifying a formula like @expr{a+a} (or @expr{2+3}),
12904 are done by default but can be turned off when necessary.
12906 When you press a key like @kbd{+} when @expr{2} and @expr{3} are on the
12907 stack, Calc pops these numbers, normalizes them, creates the formula
12908 @expr{2+3}, normalizes it, and pushes the result. Of course the standard
12909 rules for normalizing @expr{2+3} will produce the result @expr{5}.
12911 Simplification mode commands consist of the lower-case @kbd{m} prefix key
12912 followed by a shifted letter.
12915 @pindex calc-no-simplify-mode
12916 The @kbd{m O} (@code{calc-no-simplify-mode}) command turns off all optional
12917 simplifications. These would leave a formula like @expr{2+3} alone. In
12918 fact, nothing except simple numbers are ever affected by normalization
12922 @pindex calc-num-simplify-mode
12923 The @kbd{m N} (@code{calc-num-simplify-mode}) command turns off simplification
12924 of any formulas except those for which all arguments are constants. For
12925 example, @expr{1+2} is simplified to @expr{3}, and @expr{a+(2-2)} is
12926 simplified to @expr{a+0} but no further, since one argument of the sum
12927 is not a constant. Unfortunately, @expr{(a+2)-2} is @emph{not} simplified
12928 because the top-level @samp{-} operator's arguments are not both
12929 constant numbers (one of them is the formula @expr{a+2}).
12930 A constant is a number or other numeric object (such as a constant
12931 error form or modulo form), or a vector all of whose
12932 elements are constant.
12935 @pindex calc-default-simplify-mode
12936 The @kbd{m D} (@code{calc-default-simplify-mode}) command restores the
12937 default simplifications for all formulas. This includes many easy and
12938 fast algebraic simplifications such as @expr{a+0} to @expr{a}, and
12939 @expr{a + 2 a} to @expr{3 a}, as well as evaluating functions like
12940 @expr{@tfn{deriv}(x^2, x)} to @expr{2 x}.
12943 @pindex calc-bin-simplify-mode
12944 The @kbd{m B} (@code{calc-bin-simplify-mode}) mode applies the default
12945 simplifications to a result and then, if the result is an integer,
12946 uses the @kbd{b c} (@code{calc-clip}) command to clip the integer according
12947 to the current binary word size. @xref{Binary Functions}. Real numbers
12948 are rounded to the nearest integer and then clipped; other kinds of
12949 results (after the default simplifications) are left alone.
12952 @pindex calc-alg-simplify-mode
12953 The @kbd{m A} (@code{calc-alg-simplify-mode}) mode does algebraic
12954 simplification; it applies all the default simplifications, and also
12955 the more powerful (and slower) simplifications made by @kbd{a s}
12956 (@code{calc-simplify}). @xref{Algebraic Simplifications}.
12959 @pindex calc-ext-simplify-mode
12960 The @kbd{m E} (@code{calc-ext-simplify-mode}) mode does ``extended''
12961 algebraic simplification, as by the @kbd{a e} (@code{calc-simplify-extended})
12962 command. @xref{Unsafe Simplifications}.
12965 @pindex calc-units-simplify-mode
12966 The @kbd{m U} (@code{calc-units-simplify-mode}) mode does units
12967 simplification; it applies the command @kbd{u s}
12968 (@code{calc-simplify-units}), which in turn
12969 is a superset of @kbd{a s}. In this mode, variable names which
12970 are identifiable as unit names (like @samp{mm} for ``millimeters'')
12971 are simplified with their unit definitions in mind.
12973 A common technique is to set the simplification mode down to the lowest
12974 amount of simplification you will allow to be applied automatically, then
12975 use manual commands like @kbd{a s} and @kbd{c c} (@code{calc-clean}) to
12976 perform higher types of simplifications on demand. @xref{Algebraic
12977 Definitions}, for another sample use of No-Simplification mode.
12979 @node Declarations, Display Modes, Simplification Modes, Mode Settings
12980 @section Declarations
12983 A @dfn{declaration} is a statement you make that promises you will
12984 use a certain variable or function in a restricted way. This may
12985 give Calc the freedom to do things that it couldn't do if it had to
12986 take the fully general situation into account.
12989 * Declaration Basics::
12990 * Kinds of Declarations::
12991 * Functions for Declarations::
12994 @node Declaration Basics, Kinds of Declarations, Declarations, Declarations
12995 @subsection Declaration Basics
12999 @pindex calc-declare-variable
13000 The @kbd{s d} (@code{calc-declare-variable}) command is the easiest
13001 way to make a declaration for a variable. This command prompts for
13002 the variable name, then prompts for the declaration. The default
13003 at the declaration prompt is the previous declaration, if any.
13004 You can edit this declaration, or press @kbd{C-k} to erase it and
13005 type a new declaration. (Or, erase it and press @key{RET} to clear
13006 the declaration, effectively ``undeclaring'' the variable.)
13008 A declaration is in general a vector of @dfn{type symbols} and
13009 @dfn{range} values. If there is only one type symbol or range value,
13010 you can write it directly rather than enclosing it in a vector.
13011 For example, @kbd{s d foo @key{RET} real @key{RET}} declares @code{foo} to
13012 be a real number, and @kbd{s d bar @key{RET} [int, const, [1..6]] @key{RET}}
13013 declares @code{bar} to be a constant integer between 1 and 6.
13014 (Actually, you can omit the outermost brackets and Calc will
13015 provide them for you: @kbd{s d bar @key{RET} int, const, [1..6] @key{RET}}.)
13017 @cindex @code{Decls} variable
13019 Declarations in Calc are kept in a special variable called @code{Decls}.
13020 This variable encodes the set of all outstanding declarations in
13021 the form of a matrix. Each row has two elements: A variable or
13022 vector of variables declared by that row, and the declaration
13023 specifier as described above. You can use the @kbd{s D} command to
13024 edit this variable if you wish to see all the declarations at once.
13025 @xref{Operations on Variables}, for a description of this command
13026 and the @kbd{s p} command that allows you to save your declarations
13027 permanently if you wish.
13029 Items being declared can also be function calls. The arguments in
13030 the call are ignored; the effect is to say that this function returns
13031 values of the declared type for any valid arguments. The @kbd{s d}
13032 command declares only variables, so if you wish to make a function
13033 declaration you will have to edit the @code{Decls} matrix yourself.
13035 For example, the declaration matrix
13041 [ f(1,2,3), [0 .. inf) ] ]
13046 declares that @code{foo} represents a real number, @code{j}, @code{k}
13047 and @code{n} represent integers, and the function @code{f} always
13048 returns a real number in the interval shown.
13051 If there is a declaration for the variable @code{All}, then that
13052 declaration applies to all variables that are not otherwise declared.
13053 It does not apply to function names. For example, using the row
13054 @samp{[All, real]} says that all your variables are real unless they
13055 are explicitly declared without @code{real} in some other row.
13056 The @kbd{s d} command declares @code{All} if you give a blank
13057 response to the variable-name prompt.
13059 @node Kinds of Declarations, Functions for Declarations, Declaration Basics, Declarations
13060 @subsection Kinds of Declarations
13063 The type-specifier part of a declaration (that is, the second prompt
13064 in the @kbd{s d} command) can be a type symbol, an interval, or a
13065 vector consisting of zero or more type symbols followed by zero or
13066 more intervals or numbers that represent the set of possible values
13071 [ [ a, [1, 2, 3, 4, 5] ]
13073 [ c, [int, 1 .. 5] ] ]
13077 Here @code{a} is declared to contain one of the five integers shown;
13078 @code{b} is any number in the interval from 1 to 5 (any real number
13079 since we haven't specified), and @code{c} is any integer in that
13080 interval. Thus the declarations for @code{a} and @code{c} are
13081 nearly equivalent (see below).
13083 The type-specifier can be the empty vector @samp{[]} to say that
13084 nothing is known about a given variable's value. This is the same
13085 as not declaring the variable at all except that it overrides any
13086 @code{All} declaration which would otherwise apply.
13088 The initial value of @code{Decls} is the empty vector @samp{[]}.
13089 If @code{Decls} has no stored value or if the value stored in it
13090 is not valid, it is ignored and there are no declarations as far
13091 as Calc is concerned. (The @kbd{s d} command will replace such a
13092 malformed value with a fresh empty matrix, @samp{[]}, before recording
13093 the new declaration.) Unrecognized type symbols are ignored.
13095 The following type symbols describe what sorts of numbers will be
13096 stored in a variable:
13102 Numerical integers. (Integers or integer-valued floats.)
13104 Fractions. (Rational numbers which are not integers.)
13106 Rational numbers. (Either integers or fractions.)
13108 Floating-point numbers.
13110 Real numbers. (Integers, fractions, or floats. Actually,
13111 intervals and error forms with real components also count as
13114 Positive real numbers. (Strictly greater than zero.)
13116 Nonnegative real numbers. (Greater than or equal to zero.)
13118 Numbers. (Real or complex.)
13121 Calc uses this information to determine when certain simplifications
13122 of formulas are safe. For example, @samp{(x^y)^z} cannot be
13123 simplified to @samp{x^(y z)} in general; for example,
13124 @samp{((-3)^2)^1:2} is 3, but @samp{(-3)^(2*1:2) = (-3)^1} is @mathit{-3}.
13125 However, this simplification @emph{is} safe if @code{z} is known
13126 to be an integer, or if @code{x} is known to be a nonnegative
13127 real number. If you have given declarations that allow Calc to
13128 deduce either of these facts, Calc will perform this simplification
13131 Calc can apply a certain amount of logic when using declarations.
13132 For example, @samp{(x^y)^(2n+1)} will be simplified if @code{n}
13133 has been declared @code{int}; Calc knows that an integer times an
13134 integer, plus an integer, must always be an integer. (In fact,
13135 Calc would simplify @samp{(-x)^(2n+1)} to @samp{-(x^(2n+1))} since
13136 it is able to determine that @samp{2n+1} must be an odd integer.)
13138 Similarly, @samp{(abs(x)^y)^z} will be simplified to @samp{abs(x)^(y z)}
13139 because Calc knows that the @code{abs} function always returns a
13140 nonnegative real. If you had a @code{myabs} function that also had
13141 this property, you could get Calc to recognize it by adding the row
13142 @samp{[myabs(), nonneg]} to the @code{Decls} matrix.
13144 One instance of this simplification is @samp{sqrt(x^2)} (since the
13145 @code{sqrt} function is effectively a one-half power). Normally
13146 Calc leaves this formula alone. After the command
13147 @kbd{s d x @key{RET} real @key{RET}}, however, it can simplify the formula to
13148 @samp{abs(x)}. And after @kbd{s d x @key{RET} nonneg @key{RET}}, Calc can
13149 simplify this formula all the way to @samp{x}.
13151 If there are any intervals or real numbers in the type specifier,
13152 they comprise the set of possible values that the variable or
13153 function being declared can have. In particular, the type symbol
13154 @code{real} is effectively the same as the range @samp{[-inf .. inf]}
13155 (note that infinity is included in the range of possible values);
13156 @code{pos} is the same as @samp{(0 .. inf]}, and @code{nonneg} is
13157 the same as @samp{[0 .. inf]}. Saying @samp{[real, [-5 .. 5]]} is
13158 redundant because the fact that the variable is real can be
13159 deduced just from the interval, but @samp{[int, [-5 .. 5]]} and
13160 @samp{[rat, [-5 .. 5]]} are useful combinations.
13162 Note that the vector of intervals or numbers is in the same format
13163 used by Calc's set-manipulation commands. @xref{Set Operations}.
13165 The type specifier @samp{[1, 2, 3]} is equivalent to
13166 @samp{[numint, 1, 2, 3]}, @emph{not} to @samp{[int, 1, 2, 3]}.
13167 In other words, the range of possible values means only that
13168 the variable's value must be numerically equal to a number in
13169 that range, but not that it must be equal in type as well.
13170 Calc's set operations act the same way; @samp{in(2, [1., 2., 3.])}
13171 and @samp{in(1.5, [1:2, 3:2, 5:2])} both report ``true.''
13173 If you use a conflicting combination of type specifiers, the
13174 results are unpredictable. An example is @samp{[pos, [0 .. 5]]},
13175 where the interval does not lie in the range described by the
13178 ``Real'' declarations mostly affect simplifications involving powers
13179 like the one described above. Another case where they are used
13180 is in the @kbd{a P} command which returns a list of all roots of a
13181 polynomial; if the variable has been declared real, only the real
13182 roots (if any) will be included in the list.
13184 ``Integer'' declarations are used for simplifications which are valid
13185 only when certain values are integers (such as @samp{(x^y)^z}
13188 Another command that makes use of declarations is @kbd{a s}, when
13189 simplifying equations and inequalities. It will cancel @code{x}
13190 from both sides of @samp{a x = b x} only if it is sure @code{x}
13191 is non-zero, say, because it has a @code{pos} declaration.
13192 To declare specifically that @code{x} is real and non-zero,
13193 use @samp{[[-inf .. 0), (0 .. inf]]}. (There is no way in the
13194 current notation to say that @code{x} is nonzero but not necessarily
13195 real.) The @kbd{a e} command does ``unsafe'' simplifications,
13196 including cancelling @samp{x} from the equation when @samp{x} is
13197 not known to be nonzero.
13199 Another set of type symbols distinguish between scalars and vectors.
13203 The value is not a vector.
13205 The value is a vector.
13207 The value is a matrix (a rectangular vector of vectors).
13210 These type symbols can be combined with the other type symbols
13211 described above; @samp{[int, matrix]} describes an object which
13212 is a matrix of integers.
13214 Scalar/vector declarations are used to determine whether certain
13215 algebraic operations are safe. For example, @samp{[a, b, c] + x}
13216 is normally not simplified to @samp{[a + x, b + x, c + x]}, but
13217 it will be if @code{x} has been declared @code{scalar}. On the
13218 other hand, multiplication is usually assumed to be commutative,
13219 but the terms in @samp{x y} will never be exchanged if both @code{x}
13220 and @code{y} are known to be vectors or matrices. (Calc currently
13221 never distinguishes between @code{vector} and @code{matrix}
13224 @xref{Matrix Mode}, for a discussion of Matrix mode and
13225 Scalar mode, which are similar to declaring @samp{[All, matrix]}
13226 or @samp{[All, scalar]} but much more convenient.
13228 One more type symbol that is recognized is used with the @kbd{H a d}
13229 command for taking total derivatives of a formula. @xref{Calculus}.
13233 The value is a constant with respect to other variables.
13236 Calc does not check the declarations for a variable when you store
13237 a value in it. However, storing @mathit{-3.5} in a variable that has
13238 been declared @code{pos}, @code{int}, or @code{matrix} may have
13239 unexpected effects; Calc may evaluate @samp{sqrt(x^2)} to @expr{3.5}
13240 if it substitutes the value first, or to @expr{-3.5} if @code{x}
13241 was declared @code{pos} and the formula @samp{sqrt(x^2)} is
13242 simplified to @samp{x} before the value is substituted. Before
13243 using a variable for a new purpose, it is best to use @kbd{s d}
13244 or @kbd{s D} to check to make sure you don't still have an old
13245 declaration for the variable that will conflict with its new meaning.
13247 @node Functions for Declarations, , Kinds of Declarations, Declarations
13248 @subsection Functions for Declarations
13251 Calc has a set of functions for accessing the current declarations
13252 in a convenient manner. These functions return 1 if the argument
13253 can be shown to have the specified property, or 0 if the argument
13254 can be shown @emph{not} to have that property; otherwise they are
13255 left unevaluated. These functions are suitable for use with rewrite
13256 rules (@pxref{Conditional Rewrite Rules}) or programming constructs
13257 (@pxref{Conditionals in Macros}). They can be entered only using
13258 algebraic notation. @xref{Logical Operations}, for functions
13259 that perform other tests not related to declarations.
13261 For example, @samp{dint(17)} returns 1 because 17 is an integer, as
13262 do @samp{dint(n)} and @samp{dint(2 n - 3)} if @code{n} has been declared
13263 @code{int}, but @samp{dint(2.5)} and @samp{dint(n + 0.5)} return 0.
13264 Calc consults knowledge of its own built-in functions as well as your
13265 own declarations: @samp{dint(floor(x))} returns 1.
13279 The @code{dint} function checks if its argument is an integer.
13280 The @code{dnatnum} function checks if its argument is a natural
13281 number, i.e., a nonnegative integer. The @code{dnumint} function
13282 checks if its argument is numerically an integer, i.e., either an
13283 integer or an integer-valued float. Note that these and the other
13284 data type functions also accept vectors or matrices composed of
13285 suitable elements, and that real infinities @samp{inf} and @samp{-inf}
13286 are considered to be integers for the purposes of these functions.
13292 The @code{drat} function checks if its argument is rational, i.e.,
13293 an integer or fraction. Infinities count as rational, but intervals
13294 and error forms do not.
13300 The @code{dreal} function checks if its argument is real. This
13301 includes integers, fractions, floats, real error forms, and intervals.
13307 The @code{dimag} function checks if its argument is imaginary,
13308 i.e., is mathematically equal to a real number times @expr{i}.
13322 The @code{dpos} function checks for positive (but nonzero) reals.
13323 The @code{dneg} function checks for negative reals. The @code{dnonneg}
13324 function checks for nonnegative reals, i.e., reals greater than or
13325 equal to zero. Note that the @kbd{a s} command can simplify an
13326 expression like @expr{x > 0} to 1 or 0 using @code{dpos}, and that
13327 @kbd{a s} is effectively applied to all conditions in rewrite rules,
13328 so the actual functions @code{dpos}, @code{dneg}, and @code{dnonneg}
13329 are rarely necessary.
13335 The @code{dnonzero} function checks that its argument is nonzero.
13336 This includes all nonzero real or complex numbers, all intervals that
13337 do not include zero, all nonzero modulo forms, vectors all of whose
13338 elements are nonzero, and variables or formulas whose values can be
13339 deduced to be nonzero. It does not include error forms, since they
13340 represent values which could be anything including zero. (This is
13341 also the set of objects considered ``true'' in conditional contexts.)
13351 The @code{deven} function returns 1 if its argument is known to be
13352 an even integer (or integer-valued float); it returns 0 if its argument
13353 is known not to be even (because it is known to be odd or a non-integer).
13354 The @kbd{a s} command uses this to simplify a test of the form
13355 @samp{x % 2 = 0}. There is also an analogous @code{dodd} function.
13361 The @code{drange} function returns a set (an interval or a vector
13362 of intervals and/or numbers; @pxref{Set Operations}) that describes
13363 the set of possible values of its argument. If the argument is
13364 a variable or a function with a declaration, the range is copied
13365 from the declaration. Otherwise, the possible signs of the
13366 expression are determined using a method similar to @code{dpos},
13367 etc., and a suitable set like @samp{[0 .. inf]} is returned. If
13368 the expression is not provably real, the @code{drange} function
13369 remains unevaluated.
13375 The @code{dscalar} function returns 1 if its argument is provably
13376 scalar, or 0 if its argument is provably non-scalar. It is left
13377 unevaluated if this cannot be determined. (If Matrix mode or Scalar
13378 mode is in effect, this function returns 1 or 0, respectively,
13379 if it has no other information.) When Calc interprets a condition
13380 (say, in a rewrite rule) it considers an unevaluated formula to be
13381 ``false.'' Thus, @samp{dscalar(a)} is ``true'' only if @code{a} is
13382 provably scalar, and @samp{!dscalar(a)} is ``true'' only if @code{a}
13383 is provably non-scalar; both are ``false'' if there is insufficient
13384 information to tell.
13386 @node Display Modes, Language Modes, Declarations, Mode Settings
13387 @section Display Modes
13390 The commands in this section are two-key sequences beginning with the
13391 @kbd{d} prefix. The @kbd{d l} (@code{calc-line-numbering}) and @kbd{d b}
13392 (@code{calc-line-breaking}) commands are described elsewhere;
13393 @pxref{Stack Basics} and @pxref{Normal Language Modes}, respectively.
13394 Display formats for vectors and matrices are also covered elsewhere;
13395 @pxref{Vector and Matrix Formats}.
13397 One thing all display modes have in common is their treatment of the
13398 @kbd{H} prefix. This prefix causes any mode command that would normally
13399 refresh the stack to leave the stack display alone. The word ``Dirty''
13400 will appear in the mode line when Calc thinks the stack display may not
13401 reflect the latest mode settings.
13403 @kindex d @key{RET}
13404 @pindex calc-refresh-top
13405 The @kbd{d @key{RET}} (@code{calc-refresh-top}) command reformats the
13406 top stack entry according to all the current modes. Positive prefix
13407 arguments reformat the top @var{n} entries; negative prefix arguments
13408 reformat the specified entry, and a prefix of zero is equivalent to
13409 @kbd{d @key{SPC}} (@code{calc-refresh}), which reformats the entire stack.
13410 For example, @kbd{H d s M-2 d @key{RET}} changes to scientific notation
13411 but reformats only the top two stack entries in the new mode.
13413 The @kbd{I} prefix has another effect on the display modes. The mode
13414 is set only temporarily; the top stack entry is reformatted according
13415 to that mode, then the original mode setting is restored. In other
13416 words, @kbd{I d s} is equivalent to @kbd{H d s d @key{RET} H d (@var{old mode})}.
13420 * Grouping Digits::
13422 * Complex Formats::
13423 * Fraction Formats::
13426 * Truncating the Stack::
13431 @node Radix Modes, Grouping Digits, Display Modes, Display Modes
13432 @subsection Radix Modes
13435 @cindex Radix display
13436 @cindex Non-decimal numbers
13437 @cindex Decimal and non-decimal numbers
13438 Calc normally displays numbers in decimal (@dfn{base-10} or @dfn{radix-10})
13439 notation. Calc can actually display in any radix from two (binary) to 36.
13440 When the radix is above 10, the letters @code{A} to @code{Z} are used as
13441 digits. When entering such a number, letter keys are interpreted as
13442 potential digits rather than terminating numeric entry mode.
13448 @cindex Hexadecimal integers
13449 @cindex Octal integers
13450 The key sequences @kbd{d 2}, @kbd{d 8}, @kbd{d 6}, and @kbd{d 0} select
13451 binary, octal, hexadecimal, and decimal as the current display radix,
13452 respectively. Numbers can always be entered in any radix, though the
13453 current radix is used as a default if you press @kbd{#} without any initial
13454 digits. A number entered without a @kbd{#} is @emph{always} interpreted
13459 To set the radix generally, use @kbd{d r} (@code{calc-radix}) and enter
13460 an integer from 2 to 36. You can specify the radix as a numeric prefix
13461 argument; otherwise you will be prompted for it.
13464 @pindex calc-leading-zeros
13465 @cindex Leading zeros
13466 Integers normally are displayed with however many digits are necessary to
13467 represent the integer and no more. The @kbd{d z} (@code{calc-leading-zeros})
13468 command causes integers to be padded out with leading zeros according to the
13469 current binary word size. (@xref{Binary Functions}, for a discussion of
13470 word size.) If the absolute value of the word size is @expr{w}, all integers
13471 are displayed with at least enough digits to represent
13472 @texline @math{2^w-1}
13473 @infoline @expr{(2^w)-1}
13474 in the current radix. (Larger integers will still be displayed in their
13477 @node Grouping Digits, Float Formats, Radix Modes, Display Modes
13478 @subsection Grouping Digits
13482 @pindex calc-group-digits
13483 @cindex Grouping digits
13484 @cindex Digit grouping
13485 Long numbers can be hard to read if they have too many digits. For
13486 example, the factorial of 30 is 33 digits long! Press @kbd{d g}
13487 (@code{calc-group-digits}) to enable @dfn{Grouping} mode, in which digits
13488 are displayed in clumps of 3 or 4 (depending on the current radix)
13489 separated by commas.
13491 The @kbd{d g} command toggles grouping on and off.
13492 With a numeric prefix of 0, this command displays the current state of
13493 the grouping flag; with an argument of minus one it disables grouping;
13494 with a positive argument @expr{N} it enables grouping on every @expr{N}
13495 digits. For floating-point numbers, grouping normally occurs only
13496 before the decimal point. A negative prefix argument @expr{-N} enables
13497 grouping every @expr{N} digits both before and after the decimal point.
13500 @pindex calc-group-char
13501 The @kbd{d ,} (@code{calc-group-char}) command allows you to choose any
13502 character as the grouping separator. The default is the comma character.
13503 If you find it difficult to read vectors of large integers grouped with
13504 commas, you may wish to use spaces or some other character instead.
13505 This command takes the next character you type, whatever it is, and
13506 uses it as the digit separator. As a special case, @kbd{d , \} selects
13507 @samp{\,} (@TeX{}'s thin-space symbol) as the digit separator.
13509 Please note that grouped numbers will not generally be parsed correctly
13510 if re-read in textual form, say by the use of @kbd{M-# y} and @kbd{M-# g}.
13511 (@xref{Kill and Yank}, for details on these commands.) One exception is
13512 the @samp{\,} separator, which doesn't interfere with parsing because it
13513 is ignored by @TeX{} language mode.
13515 @node Float Formats, Complex Formats, Grouping Digits, Display Modes
13516 @subsection Float Formats
13519 Floating-point quantities are normally displayed in standard decimal
13520 form, with scientific notation used if the exponent is especially high
13521 or low. All significant digits are normally displayed. The commands
13522 in this section allow you to choose among several alternative display
13523 formats for floats.
13526 @pindex calc-normal-notation
13527 The @kbd{d n} (@code{calc-normal-notation}) command selects the normal
13528 display format. All significant figures in a number are displayed.
13529 With a positive numeric prefix, numbers are rounded if necessary to
13530 that number of significant digits. With a negative numerix prefix,
13531 the specified number of significant digits less than the current
13532 precision is used. (Thus @kbd{C-u -2 d n} displays 10 digits if the
13533 current precision is 12.)
13536 @pindex calc-fix-notation
13537 The @kbd{d f} (@code{calc-fix-notation}) command selects fixed-point
13538 notation. The numeric argument is the number of digits after the
13539 decimal point, zero or more. This format will relax into scientific
13540 notation if a nonzero number would otherwise have been rounded all the
13541 way to zero. Specifying a negative number of digits is the same as
13542 for a positive number, except that small nonzero numbers will be rounded
13543 to zero rather than switching to scientific notation.
13546 @pindex calc-sci-notation
13547 @cindex Scientific notation, display of
13548 The @kbd{d s} (@code{calc-sci-notation}) command selects scientific
13549 notation. A positive argument sets the number of significant figures
13550 displayed, of which one will be before and the rest after the decimal
13551 point. A negative argument works the same as for @kbd{d n} format.
13552 The default is to display all significant digits.
13555 @pindex calc-eng-notation
13556 @cindex Engineering notation, display of
13557 The @kbd{d e} (@code{calc-eng-notation}) command selects engineering
13558 notation. This is similar to scientific notation except that the
13559 exponent is rounded down to a multiple of three, with from one to three
13560 digits before the decimal point. An optional numeric prefix sets the
13561 number of significant digits to display, as for @kbd{d s}.
13563 It is important to distinguish between the current @emph{precision} and
13564 the current @emph{display format}. After the commands @kbd{C-u 10 p}
13565 and @kbd{C-u 6 d n} the Calculator computes all results to ten
13566 significant figures but displays only six. (In fact, intermediate
13567 calculations are often carried to one or two more significant figures,
13568 but values placed on the stack will be rounded down to ten figures.)
13569 Numbers are never actually rounded to the display precision for storage,
13570 except by commands like @kbd{C-k} and @kbd{M-# y} which operate on the
13571 actual displayed text in the Calculator buffer.
13574 @pindex calc-point-char
13575 The @kbd{d .} (@code{calc-point-char}) command selects the character used
13576 as a decimal point. Normally this is a period; users in some countries
13577 may wish to change this to a comma. Note that this is only a display
13578 style; on entry, periods must always be used to denote floating-point
13579 numbers, and commas to separate elements in a list.
13581 @node Complex Formats, Fraction Formats, Float Formats, Display Modes
13582 @subsection Complex Formats
13586 @pindex calc-complex-notation
13587 There are three supported notations for complex numbers in rectangular
13588 form. The default is as a pair of real numbers enclosed in parentheses
13589 and separated by a comma: @samp{(a,b)}. The @kbd{d c}
13590 (@code{calc-complex-notation}) command selects this style.
13593 @pindex calc-i-notation
13595 @pindex calc-j-notation
13596 The other notations are @kbd{d i} (@code{calc-i-notation}), in which
13597 numbers are displayed in @samp{a+bi} form, and @kbd{d j}
13598 (@code{calc-j-notation}) which displays the form @samp{a+bj} preferred
13599 in some disciplines.
13601 @cindex @code{i} variable
13603 Complex numbers are normally entered in @samp{(a,b)} format.
13604 If you enter @samp{2+3i} as an algebraic formula, it will be stored as
13605 the formula @samp{2 + 3 * i}. However, if you use @kbd{=} to evaluate
13606 this formula and you have not changed the variable @samp{i}, the @samp{i}
13607 will be interpreted as @samp{(0,1)} and the formula will be simplified
13608 to @samp{(2,3)}. Other commands (like @code{calc-sin}) will @emph{not}
13609 interpret the formula @samp{2 + 3 * i} as a complex number.
13610 @xref{Variables}, under ``special constants.''
13612 @node Fraction Formats, HMS Formats, Complex Formats, Display Modes
13613 @subsection Fraction Formats
13617 @pindex calc-over-notation
13618 Display of fractional numbers is controlled by the @kbd{d o}
13619 (@code{calc-over-notation}) command. By default, a number like
13620 eight thirds is displayed in the form @samp{8:3}. The @kbd{d o} command
13621 prompts for a one- or two-character format. If you give one character,
13622 that character is used as the fraction separator. Common separators are
13623 @samp{:} and @samp{/}. (During input of numbers, the @kbd{:} key must be
13624 used regardless of the display format; in particular, the @kbd{/} is used
13625 for RPN-style division, @emph{not} for entering fractions.)
13627 If you give two characters, fractions use ``integer-plus-fractional-part''
13628 notation. For example, the format @samp{+/} would display eight thirds
13629 as @samp{2+2/3}. If two colons are present in a number being entered,
13630 the number is interpreted in this form (so that the entries @kbd{2:2:3}
13631 and @kbd{8:3} are equivalent).
13633 It is also possible to follow the one- or two-character format with
13634 a number. For example: @samp{:10} or @samp{+/3}. In this case,
13635 Calc adjusts all fractions that are displayed to have the specified
13636 denominator, if possible. Otherwise it adjusts the denominator to
13637 be a multiple of the specified value. For example, in @samp{:6} mode
13638 the fraction @expr{1:6} will be unaffected, but @expr{2:3} will be
13639 displayed as @expr{4:6}, @expr{1:2} will be displayed as @expr{3:6},
13640 and @expr{1:8} will be displayed as @expr{3:24}. Integers are also
13641 affected by this mode: 3 is displayed as @expr{18:6}. Note that the
13642 format @samp{:1} writes fractions the same as @samp{:}, but it writes
13643 integers as @expr{n:1}.
13645 The fraction format does not affect the way fractions or integers are
13646 stored, only the way they appear on the screen. The fraction format
13647 never affects floats.
13649 @node HMS Formats, Date Formats, Fraction Formats, Display Modes
13650 @subsection HMS Formats
13654 @pindex calc-hms-notation
13655 The @kbd{d h} (@code{calc-hms-notation}) command controls the display of
13656 HMS (hours-minutes-seconds) forms. It prompts for a string which
13657 consists basically of an ``hours'' marker, optional punctuation, a
13658 ``minutes'' marker, more optional punctuation, and a ``seconds'' marker.
13659 Punctuation is zero or more spaces, commas, or semicolons. The hours
13660 marker is one or more non-punctuation characters. The minutes and
13661 seconds markers must be single non-punctuation characters.
13663 The default HMS format is @samp{@@ ' "}, producing HMS values of the form
13664 @samp{23@@ 30' 15.75"}. The format @samp{deg, ms} would display this same
13665 value as @samp{23deg, 30m15.75s}. During numeric entry, the @kbd{h} or @kbd{o}
13666 keys are recognized as synonyms for @kbd{@@} regardless of display format.
13667 The @kbd{m} and @kbd{s} keys are recognized as synonyms for @kbd{'} and
13668 @kbd{"}, respectively, but only if an @kbd{@@} (or @kbd{h} or @kbd{o}) has
13669 already been typed; otherwise, they have their usual meanings
13670 (@kbd{m-} prefix and @kbd{s-} prefix). Thus, @kbd{5 "}, @kbd{0 @@ 5 "}, and
13671 @kbd{0 h 5 s} are some of the ways to enter the quantity ``five seconds.''
13672 The @kbd{'} key is recognized as ``minutes'' only if @kbd{@@} (or @kbd{h} or
13673 @kbd{o}) has already been pressed; otherwise it means to switch to algebraic
13676 @node Date Formats, Truncating the Stack, HMS Formats, Display Modes
13677 @subsection Date Formats
13681 @pindex calc-date-notation
13682 The @kbd{d d} (@code{calc-date-notation}) command controls the display
13683 of date forms (@pxref{Date Forms}). It prompts for a string which
13684 contains letters that represent the various parts of a date and time.
13685 To show which parts should be omitted when the form represents a pure
13686 date with no time, parts of the string can be enclosed in @samp{< >}
13687 marks. If you don't include @samp{< >} markers in the format, Calc
13688 guesses at which parts, if any, should be omitted when formatting
13691 The default format is: @samp{<H:mm:SSpp >Www Mmm D, YYYY}.
13692 An example string in this format is @samp{3:32pm Wed Jan 9, 1991}.
13693 If you enter a blank format string, this default format is
13696 Calc uses @samp{< >} notation for nameless functions as well as for
13697 dates. @xref{Specifying Operators}. To avoid confusion with nameless
13698 functions, your date formats should avoid using the @samp{#} character.
13701 * Date Formatting Codes::
13702 * Free-Form Dates::
13703 * Standard Date Formats::
13706 @node Date Formatting Codes, Free-Form Dates, Date Formats, Date Formats
13707 @subsubsection Date Formatting Codes
13710 When displaying a date, the current date format is used. All
13711 characters except for letters and @samp{<} and @samp{>} are
13712 copied literally when dates are formatted. The portion between
13713 @samp{< >} markers is omitted for pure dates, or included for
13714 date/time forms. Letters are interpreted according to the table
13717 When dates are read in during algebraic entry, Calc first tries to
13718 match the input string to the current format either with or without
13719 the time part. The punctuation characters (including spaces) must
13720 match exactly; letter fields must correspond to suitable text in
13721 the input. If this doesn't work, Calc checks if the input is a
13722 simple number; if so, the number is interpreted as a number of days
13723 since Jan 1, 1 AD. Otherwise, Calc tries a much more relaxed and
13724 flexible algorithm which is described in the next section.
13726 Weekday names are ignored during reading.
13728 Two-digit year numbers are interpreted as lying in the range
13729 from 1941 to 2039. Years outside that range are always
13730 entered and displayed in full. Year numbers with a leading
13731 @samp{+} sign are always interpreted exactly, allowing the
13732 entry and display of the years 1 through 99 AD.
13734 Here is a complete list of the formatting codes for dates:
13738 Year: ``91'' for 1991, ``7'' for 2007, ``+23'' for 23 AD.
13740 Year: ``91'' for 1991, ``07'' for 2007, ``+23'' for 23 AD.
13742 Year: ``91'' for 1991, `` 7'' for 2007, ``+23'' for 23 AD.
13744 Year: ``1991'' for 1991, ``23'' for 23 AD.
13746 Year: ``1991'' for 1991, ``+23'' for 23 AD.
13748 Year: ``ad'' or blank.
13750 Year: ``AD'' or blank.
13752 Year: ``ad '' or blank. (Note trailing space.)
13754 Year: ``AD '' or blank.
13756 Year: ``a.d.'' or blank.
13758 Year: ``A.D.'' or blank.
13760 Year: ``bc'' or blank.
13762 Year: ``BC'' or blank.
13764 Year: `` bc'' or blank. (Note leading space.)
13766 Year: `` BC'' or blank.
13768 Year: ``b.c.'' or blank.
13770 Year: ``B.C.'' or blank.
13772 Month: ``8'' for August.
13774 Month: ``08'' for August.
13776 Month: `` 8'' for August.
13778 Month: ``AUG'' for August.
13780 Month: ``Aug'' for August.
13782 Month: ``aug'' for August.
13784 Month: ``AUGUST'' for August.
13786 Month: ``August'' for August.
13788 Day: ``7'' for 7th day of month.
13790 Day: ``07'' for 7th day of month.
13792 Day: `` 7'' for 7th day of month.
13794 Weekday: ``0'' for Sunday, ``6'' for Saturday.
13796 Weekday: ``SUN'' for Sunday.
13798 Weekday: ``Sun'' for Sunday.
13800 Weekday: ``sun'' for Sunday.
13802 Weekday: ``SUNDAY'' for Sunday.
13804 Weekday: ``Sunday'' for Sunday.
13806 Day of year: ``34'' for Feb. 3.
13808 Day of year: ``034'' for Feb. 3.
13810 Day of year: `` 34'' for Feb. 3.
13812 Hour: ``5'' for 5 AM; ``17'' for 5 PM.
13814 Hour: ``05'' for 5 AM; ``17'' for 5 PM.
13816 Hour: `` 5'' for 5 AM; ``17'' for 5 PM.
13818 Hour: ``5'' for 5 AM and 5 PM.
13820 Hour: ``05'' for 5 AM and 5 PM.
13822 Hour: `` 5'' for 5 AM and 5 PM.
13824 AM/PM: ``a'' or ``p''.
13826 AM/PM: ``A'' or ``P''.
13828 AM/PM: ``am'' or ``pm''.
13830 AM/PM: ``AM'' or ``PM''.
13832 AM/PM: ``a.m.'' or ``p.m.''.
13834 AM/PM: ``A.M.'' or ``P.M.''.
13836 Minutes: ``7'' for 7.
13838 Minutes: ``07'' for 7.
13840 Minutes: `` 7'' for 7.
13842 Seconds: ``7'' for 7; ``7.23'' for 7.23.
13844 Seconds: ``07'' for 7; ``07.23'' for 7.23.
13846 Seconds: `` 7'' for 7; `` 7.23'' for 7.23.
13848 Optional seconds: ``07'' for 7; blank for 0.
13850 Optional seconds: `` 7'' for 7; blank for 0.
13852 Numeric date/time: ``726842.25'' for 6:00am Wed Jan 9, 1991.
13854 Numeric date: ``726842'' for any time on Wed Jan 9, 1991.
13856 Julian date/time: ``2448265.75'' for 6:00am Wed Jan 9, 1991.
13858 Julian date: ``2448266'' for any time on Wed Jan 9, 1991.
13860 Unix time: ``663400800'' for 6:00am Wed Jan 9, 1991.
13862 Brackets suppression. An ``X'' at the front of the format
13863 causes the surrounding @w{@samp{< >}} delimiters to be omitted
13864 when formatting dates. Note that the brackets are still
13865 required for algebraic entry.
13868 If ``SS'' or ``BS'' (optional seconds) is preceded by a colon, the
13869 colon is also omitted if the seconds part is zero.
13871 If ``bb,'' ``bbb'' or ``bbbb'' or their upper-case equivalents
13872 appear in the format, then negative year numbers are displayed
13873 without a minus sign. Note that ``aa'' and ``bb'' are mutually
13874 exclusive. Some typical usages would be @samp{YYYY AABB};
13875 @samp{AAAYYYYBBB}; @samp{YYYYBBB}.
13877 The formats ``YY,'' ``YYYY,'' ``MM,'' ``DD,'' ``ddd,'' ``hh,'' ``HH,''
13878 ``mm,'' ``ss,'' and ``SS'' actually match any number of digits during
13879 reading unless several of these codes are strung together with no
13880 punctuation in between, in which case the input must have exactly as
13881 many digits as there are letters in the format.
13883 The ``j,'' ``J,'' and ``U'' formats do not make any time zone
13884 adjustment. They effectively use @samp{julian(x,0)} and
13885 @samp{unixtime(x,0)} to make the conversion; @pxref{Date Arithmetic}.
13887 @node Free-Form Dates, Standard Date Formats, Date Formatting Codes, Date Formats
13888 @subsubsection Free-Form Dates
13891 When reading a date form during algebraic entry, Calc falls back
13892 on the algorithm described here if the input does not exactly
13893 match the current date format. This algorithm generally
13894 ``does the right thing'' and you don't have to worry about it,
13895 but it is described here in full detail for the curious.
13897 Calc does not distinguish between upper- and lower-case letters
13898 while interpreting dates.
13900 First, the time portion, if present, is located somewhere in the
13901 text and then removed. The remaining text is then interpreted as
13904 A time is of the form @samp{hh:mm:ss}, possibly with the seconds
13905 part omitted and possibly with an AM/PM indicator added to indicate
13906 12-hour time. If the AM/PM is present, the minutes may also be
13907 omitted. The AM/PM part may be any of the words @samp{am},
13908 @samp{pm}, @samp{noon}, or @samp{midnight}; each of these may be
13909 abbreviated to one letter, and the alternate forms @samp{a.m.},
13910 @samp{p.m.}, and @samp{mid} are also understood. Obviously
13911 @samp{noon} and @samp{midnight} are allowed only on 12:00:00.
13912 The words @samp{noon}, @samp{mid}, and @samp{midnight} are also
13913 recognized with no number attached.
13915 If there is no AM/PM indicator, the time is interpreted in 24-hour
13918 To read the date portion, all words and numbers are isolated
13919 from the string; other characters are ignored. All words must
13920 be either month names or day-of-week names (the latter of which
13921 are ignored). Names can be written in full or as three-letter
13924 Large numbers, or numbers with @samp{+} or @samp{-} signs,
13925 are interpreted as years. If one of the other numbers is
13926 greater than 12, then that must be the day and the remaining
13927 number in the input is therefore the month. Otherwise, Calc
13928 assumes the month, day and year are in the same order that they
13929 appear in the current date format. If the year is omitted, the
13930 current year is taken from the system clock.
13932 If there are too many or too few numbers, or any unrecognizable
13933 words, then the input is rejected.
13935 If there are any large numbers (of five digits or more) other than
13936 the year, they are ignored on the assumption that they are something
13937 like Julian dates that were included along with the traditional
13938 date components when the date was formatted.
13940 One of the words @samp{ad}, @samp{a.d.}, @samp{bc}, or @samp{b.c.}
13941 may optionally be used; the latter two are equivalent to a
13942 minus sign on the year value.
13944 If you always enter a four-digit year, and use a name instead
13945 of a number for the month, there is no danger of ambiguity.
13947 @node Standard Date Formats, , Free-Form Dates, Date Formats
13948 @subsubsection Standard Date Formats
13951 There are actually ten standard date formats, numbered 0 through 9.
13952 Entering a blank line at the @kbd{d d} command's prompt gives
13953 you format number 1, Calc's usual format. You can enter any digit
13954 to select the other formats.
13956 To create your own standard date formats, give a numeric prefix
13957 argument from 0 to 9 to the @w{@kbd{d d}} command. The format you
13958 enter will be recorded as the new standard format of that
13959 number, as well as becoming the new current date format.
13960 You can save your formats permanently with the @w{@kbd{m m}}
13961 command (@pxref{Mode Settings}).
13965 @samp{N} (Numerical format)
13967 @samp{<H:mm:SSpp >Www Mmm D, YYYY} (American format)
13969 @samp{D Mmm YYYY<, h:mm:SS>} (European format)
13971 @samp{Www Mmm BD< hh:mm:ss> YYYY} (Unix written date format)
13973 @samp{M/D/Y< H:mm:SSpp>} (American slashed format)
13975 @samp{D.M.Y< h:mm:SS>} (European dotted format)
13977 @samp{M-D-Y< H:mm:SSpp>} (American dashed format)
13979 @samp{D-M-Y< h:mm:SS>} (European dashed format)
13981 @samp{j<, h:mm:ss>} (Julian day plus time)
13983 @samp{YYddd< hh:mm:ss>} (Year-day format)
13986 @node Truncating the Stack, Justification, Date Formats, Display Modes
13987 @subsection Truncating the Stack
13991 @pindex calc-truncate-stack
13992 @cindex Truncating the stack
13993 @cindex Narrowing the stack
13994 The @kbd{d t} (@code{calc-truncate-stack}) command moves the @samp{.}@:
13995 line that marks the top-of-stack up or down in the Calculator buffer.
13996 The number right above that line is considered to the be at the top of
13997 the stack. Any numbers below that line are ``hidden'' from all stack
13998 operations (although still visible to the user). This is similar to the
13999 Emacs ``narrowing'' feature, except that the values below the @samp{.}
14000 are @emph{visible}, just temporarily frozen. This feature allows you to
14001 keep several independent calculations running at once in different parts
14002 of the stack, or to apply a certain command to an element buried deep in
14005 Pressing @kbd{d t} by itself moves the @samp{.} to the line the cursor
14006 is on. Thus, this line and all those below it become hidden. To un-hide
14007 these lines, move down to the end of the buffer and press @w{@kbd{d t}}.
14008 With a positive numeric prefix argument @expr{n}, @kbd{d t} hides the
14009 bottom @expr{n} values in the buffer. With a negative argument, it hides
14010 all but the top @expr{n} values. With an argument of zero, it hides zero
14011 values, i.e., moves the @samp{.} all the way down to the bottom.
14014 @pindex calc-truncate-up
14016 @pindex calc-truncate-down
14017 The @kbd{d [} (@code{calc-truncate-up}) and @kbd{d ]}
14018 (@code{calc-truncate-down}) commands move the @samp{.} up or down one
14019 line at a time (or several lines with a prefix argument).
14021 @node Justification, Labels, Truncating the Stack, Display Modes
14022 @subsection Justification
14026 @pindex calc-left-justify
14028 @pindex calc-center-justify
14030 @pindex calc-right-justify
14031 Values on the stack are normally left-justified in the window. You can
14032 control this arrangement by typing @kbd{d <} (@code{calc-left-justify}),
14033 @kbd{d >} (@code{calc-right-justify}), or @kbd{d =}
14034 (@code{calc-center-justify}). For example, in Right-Justification mode,
14035 stack entries are displayed flush-right against the right edge of the
14038 If you change the width of the Calculator window you may have to type
14039 @kbd{d @key{SPC}} (@code{calc-refresh}) to re-align right-justified or centered
14042 Right-justification is especially useful together with fixed-point
14043 notation (see @code{d f}; @code{calc-fix-notation}). With these modes
14044 together, the decimal points on numbers will always line up.
14046 With a numeric prefix argument, the justification commands give you
14047 a little extra control over the display. The argument specifies the
14048 horizontal ``origin'' of a display line. It is also possible to
14049 specify a maximum line width using the @kbd{d b} command (@pxref{Normal
14050 Language Modes}). For reference, the precise rules for formatting and
14051 breaking lines are given below. Notice that the interaction between
14052 origin and line width is slightly different in each justification
14055 In Left-Justified mode, the line is indented by a number of spaces
14056 given by the origin (default zero). If the result is longer than the
14057 maximum line width, if given, or too wide to fit in the Calc window
14058 otherwise, then it is broken into lines which will fit; each broken
14059 line is indented to the origin.
14061 In Right-Justified mode, lines are shifted right so that the rightmost
14062 character is just before the origin, or just before the current
14063 window width if no origin was specified. If the line is too long
14064 for this, then it is broken; the current line width is used, if
14065 specified, or else the origin is used as a width if that is
14066 specified, or else the line is broken to fit in the window.
14068 In Centering mode, the origin is the column number of the center of
14069 each stack entry. If a line width is specified, lines will not be
14070 allowed to go past that width; Calc will either indent less or
14071 break the lines if necessary. If no origin is specified, half the
14072 line width or Calc window width is used.
14074 Note that, in each case, if line numbering is enabled the display
14075 is indented an additional four spaces to make room for the line
14076 number. The width of the line number is taken into account when
14077 positioning according to the current Calc window width, but not
14078 when positioning by explicit origins and widths. In the latter
14079 case, the display is formatted as specified, and then uniformly
14080 shifted over four spaces to fit the line numbers.
14082 @node Labels, , Justification, Display Modes
14087 @pindex calc-left-label
14088 The @kbd{d @{} (@code{calc-left-label}) command prompts for a string,
14089 then displays that string to the left of every stack entry. If the
14090 entries are left-justified (@pxref{Justification}), then they will
14091 appear immediately after the label (unless you specified an origin
14092 greater than the length of the label). If the entries are centered
14093 or right-justified, the label appears on the far left and does not
14094 affect the horizontal position of the stack entry.
14096 Give a blank string (with @kbd{d @{ @key{RET}}) to turn the label off.
14099 @pindex calc-right-label
14100 The @kbd{d @}} (@code{calc-right-label}) command similarly adds a
14101 label on the righthand side. It does not affect positioning of
14102 the stack entries unless they are right-justified. Also, if both
14103 a line width and an origin are given in Right-Justified mode, the
14104 stack entry is justified to the origin and the righthand label is
14105 justified to the line width.
14107 One application of labels would be to add equation numbers to
14108 formulas you are manipulating in Calc and then copying into a
14109 document (possibly using Embedded mode). The equations would
14110 typically be centered, and the equation numbers would be on the
14111 left or right as you prefer.
14113 @node Language Modes, Modes Variable, Display Modes, Mode Settings
14114 @section Language Modes
14117 The commands in this section change Calc to use a different notation for
14118 entry and display of formulas, corresponding to the conventions of some
14119 other common language such as Pascal or La@TeX{}. Objects displayed on the
14120 stack or yanked from the Calculator to an editing buffer will be formatted
14121 in the current language; objects entered in algebraic entry or yanked from
14122 another buffer will be interpreted according to the current language.
14124 The current language has no effect on things written to or read from the
14125 trail buffer, nor does it affect numeric entry. Only algebraic entry is
14126 affected. You can make even algebraic entry ignore the current language
14127 and use the standard notation by giving a numeric prefix, e.g., @kbd{C-u '}.
14129 For example, suppose the formula @samp{2*a[1] + atan(a[2])} occurs in a C
14130 program; elsewhere in the program you need the derivatives of this formula
14131 with respect to @samp{a[1]} and @samp{a[2]}. First, type @kbd{d C}
14132 to switch to C notation. Now use @code{C-u M-# g} to grab the formula
14133 into the Calculator, @kbd{a d a[1] @key{RET}} to differentiate with respect
14134 to the first variable, and @kbd{M-# y} to yank the formula for the derivative
14135 back into your C program. Press @kbd{U} to undo the differentiation and
14136 repeat with @kbd{a d a[2] @key{RET}} for the other derivative.
14138 Without being switched into C mode first, Calc would have misinterpreted
14139 the brackets in @samp{a[1]} and @samp{a[2]}, would not have known that
14140 @code{atan} was equivalent to Calc's built-in @code{arctan} function,
14141 and would have written the formula back with notations (like implicit
14142 multiplication) which would not have been valid for a C program.
14144 As another example, suppose you are maintaining a C program and a La@TeX{}
14145 document, each of which needs a copy of the same formula. You can grab the
14146 formula from the program in C mode, switch to La@TeX{} mode, and yank the
14147 formula into the document in La@TeX{} math-mode format.
14149 Language modes are selected by typing the letter @kbd{d} followed by a
14150 shifted letter key.
14153 * Normal Language Modes::
14154 * C FORTRAN Pascal::
14155 * TeX and LaTeX Language Modes::
14156 * Eqn Language Mode::
14157 * Mathematica Language Mode::
14158 * Maple Language Mode::
14163 @node Normal Language Modes, C FORTRAN Pascal, Language Modes, Language Modes
14164 @subsection Normal Language Modes
14168 @pindex calc-normal-language
14169 The @kbd{d N} (@code{calc-normal-language}) command selects the usual
14170 notation for Calc formulas, as described in the rest of this manual.
14171 Matrices are displayed in a multi-line tabular format, but all other
14172 objects are written in linear form, as they would be typed from the
14176 @pindex calc-flat-language
14177 @cindex Matrix display
14178 The @kbd{d O} (@code{calc-flat-language}) command selects a language
14179 identical with the normal one, except that matrices are written in
14180 one-line form along with everything else. In some applications this
14181 form may be more suitable for yanking data into other buffers.
14184 @pindex calc-line-breaking
14185 @cindex Line breaking
14186 @cindex Breaking up long lines
14187 Even in one-line mode, long formulas or vectors will still be split
14188 across multiple lines if they exceed the width of the Calculator window.
14189 The @kbd{d b} (@code{calc-line-breaking}) command turns this line-breaking
14190 feature on and off. (It works independently of the current language.)
14191 If you give a numeric prefix argument of five or greater to the @kbd{d b}
14192 command, that argument will specify the line width used when breaking
14196 @pindex calc-big-language
14197 The @kbd{d B} (@code{calc-big-language}) command selects a language
14198 which uses textual approximations to various mathematical notations,
14199 such as powers, quotients, and square roots:
14209 in place of @samp{sqrt((a+1)/b + c^2)}.
14211 Subscripts like @samp{a_i} are displayed as actual subscripts in Big
14212 mode. Double subscripts, @samp{a_i_j} (@samp{subscr(subscr(a, i), j)})
14213 are displayed as @samp{a} with subscripts separated by commas:
14214 @samp{i, j}. They must still be entered in the usual underscore
14217 One slight ambiguity of Big notation is that
14226 can represent either the negative rational number @expr{-3:4}, or the
14227 actual expression @samp{-(3/4)}; but the latter formula would normally
14228 never be displayed because it would immediately be evaluated to
14229 @expr{-3:4} or @expr{-0.75}, so this ambiguity is not a problem in
14232 Non-decimal numbers are displayed with subscripts. Thus there is no
14233 way to tell the difference between @samp{16#C2} and @samp{C2_16},
14234 though generally you will know which interpretation is correct.
14235 Logarithms @samp{log(x,b)} and @samp{log10(x)} also use subscripts
14238 In Big mode, stack entries often take up several lines. To aid
14239 readability, stack entries are separated by a blank line in this mode.
14240 You may find it useful to expand the Calc window's height using
14241 @kbd{C-x ^} (@code{enlarge-window}) or to make the Calc window the only
14242 one on the screen with @kbd{C-x 1} (@code{delete-other-windows}).
14244 Long lines are currently not rearranged to fit the window width in
14245 Big mode, so you may need to use the @kbd{<} and @kbd{>} keys
14246 to scroll across a wide formula. For really big formulas, you may
14247 even need to use @kbd{@{} and @kbd{@}} to scroll up and down.
14250 @pindex calc-unformatted-language
14251 The @kbd{d U} (@code{calc-unformatted-language}) command altogether disables
14252 the use of operator notation in formulas. In this mode, the formula
14253 shown above would be displayed:
14256 sqrt(add(div(add(a, 1), b), pow(c, 2)))
14259 These four modes differ only in display format, not in the format
14260 expected for algebraic entry. The standard Calc operators work in
14261 all four modes, and unformatted notation works in any language mode
14262 (except that Mathematica mode expects square brackets instead of
14265 @node C FORTRAN Pascal, TeX and LaTeX Language Modes, Normal Language Modes, Language Modes
14266 @subsection C, FORTRAN, and Pascal Modes
14270 @pindex calc-c-language
14272 The @kbd{d C} (@code{calc-c-language}) command selects the conventions
14273 of the C language for display and entry of formulas. This differs from
14274 the normal language mode in a variety of (mostly minor) ways. In
14275 particular, C language operators and operator precedences are used in
14276 place of Calc's usual ones. For example, @samp{a^b} means @samp{xor(a,b)}
14277 in C mode; a value raised to a power is written as a function call,
14280 In C mode, vectors and matrices use curly braces instead of brackets.
14281 Octal and hexadecimal values are written with leading @samp{0} or @samp{0x}
14282 rather than using the @samp{#} symbol. Array subscripting is
14283 translated into @code{subscr} calls, so that @samp{a[i]} in C
14284 mode is the same as @samp{a_i} in Normal mode. Assignments
14285 turn into the @code{assign} function, which Calc normally displays
14286 using the @samp{:=} symbol.
14288 The variables @code{pi} and @code{e} would be displayed @samp{pi}
14289 and @samp{e} in Normal mode, but in C mode they are displayed as
14290 @samp{M_PI} and @samp{M_E}, corresponding to the names of constants
14291 typically provided in the @file{<math.h>} header. Functions whose
14292 names are different in C are translated automatically for entry and
14293 display purposes. For example, entering @samp{asin(x)} will push the
14294 formula @samp{arcsin(x)} onto the stack; this formula will be displayed
14295 as @samp{asin(x)} as long as C mode is in effect.
14298 @pindex calc-pascal-language
14299 @cindex Pascal language
14300 The @kbd{d P} (@code{calc-pascal-language}) command selects Pascal
14301 conventions. Like C mode, Pascal mode interprets array brackets and uses
14302 a different table of operators. Hexadecimal numbers are entered and
14303 displayed with a preceding dollar sign. (Thus the regular meaning of
14304 @kbd{$2} during algebraic entry does not work in Pascal mode, though
14305 @kbd{$} (and @kbd{$$}, etc.) not followed by digits works the same as
14306 always.) No special provisions are made for other non-decimal numbers,
14307 vectors, and so on, since there is no universally accepted standard way
14308 of handling these in Pascal.
14311 @pindex calc-fortran-language
14312 @cindex FORTRAN language
14313 The @kbd{d F} (@code{calc-fortran-language}) command selects FORTRAN
14314 conventions. Various function names are transformed into FORTRAN
14315 equivalents. Vectors are written as @samp{/1, 2, 3/}, and may be
14316 entered this way or using square brackets. Since FORTRAN uses round
14317 parentheses for both function calls and array subscripts, Calc displays
14318 both in the same way; @samp{a(i)} is interpreted as a function call
14319 upon reading, and subscripts must be entered as @samp{subscr(a, i)}.
14320 Also, if the variable @code{a} has been declared to have type
14321 @code{vector} or @code{matrix} then @samp{a(i)} will be parsed as a
14322 subscript. (@xref{Declarations}.) Usually it doesn't matter, though;
14323 if you enter the subscript expression @samp{a(i)} and Calc interprets
14324 it as a function call, you'll never know the difference unless you
14325 switch to another language mode or replace @code{a} with an actual
14326 vector (or unless @code{a} happens to be the name of a built-in
14329 Underscores are allowed in variable and function names in all of these
14330 language modes. The underscore here is equivalent to the @samp{#} in
14331 Normal mode, or to hyphens in the underlying Emacs Lisp variable names.
14333 FORTRAN and Pascal modes normally do not adjust the case of letters in
14334 formulas. Most built-in Calc names use lower-case letters. If you use a
14335 positive numeric prefix argument with @kbd{d P} or @kbd{d F}, these
14336 modes will use upper-case letters exclusively for display, and will
14337 convert to lower-case on input. With a negative prefix, these modes
14338 convert to lower-case for display and input.
14340 @node TeX and LaTeX Language Modes, Eqn Language Mode, C FORTRAN Pascal, Language Modes
14341 @subsection @TeX{} and La@TeX{} Language Modes
14345 @pindex calc-tex-language
14346 @cindex TeX language
14348 @pindex calc-latex-language
14349 @cindex LaTeX language
14350 The @kbd{d T} (@code{calc-tex-language}) command selects the conventions
14351 of ``math mode'' in Donald Knuth's @TeX{} typesetting language,
14352 and the @kbd{d L} (@code{calc-latex-language}) command selects the
14353 conventions of ``math mode'' in La@TeX{}, a typesetting language that
14354 uses @TeX{} as its formatting engine. Calc's La@TeX{} language mode can
14355 read any formula that the @TeX{} language mode can, although La@TeX{}
14356 mode may display it differently.
14358 Formulas are entered and displayed in the appropriate notation;
14359 @texline @math{\sin(a/b)}
14360 @infoline @expr{sin(a/b)}
14361 will appear as @samp{\sin\left( a \over b \right)} in @TeX{} mode and
14362 @samp{\sin\left(\frac@{a@}@{b@}\right)} in La@TeX{} mode.
14363 Math formulas are often enclosed by @samp{$ $} signs in @TeX{} and
14364 La@TeX{}; these should be omitted when interfacing with Calc. To Calc,
14365 the @samp{$} sign has the same meaning it always does in algebraic
14366 formulas (a reference to an existing entry on the stack).
14368 Complex numbers are displayed as in @samp{3 + 4i}. Fractions and
14369 quotients are written using @code{\over} in @TeX{} mode (as in
14370 @code{@{a \over b@}}) and @code{\frac} in La@TeX{} mode (as in
14371 @code{\frac@{a@}@{b@}}); binomial coefficients are written with
14372 @code{\choose} in @TeX{} mode (as in @code{@{a \choose b@}}) and
14373 @code{\binom} in La@TeX{} mode (as in @code{\binom@{a@}@{b@}}).
14374 Interval forms are written with @code{\ldots}, and error forms are
14375 written with @code{\pm}. Absolute values are written as in
14376 @samp{|x + 1|}, and the floor and ceiling functions are written with
14377 @code{\lfloor}, @code{\rfloor}, etc. The words @code{\left} and
14378 @code{\right} are ignored when reading formulas in @TeX{} and La@TeX{}
14379 modes. Both @code{inf} and @code{uinf} are written as @code{\infty};
14380 when read, @code{\infty} always translates to @code{inf}.
14382 Function calls are written the usual way, with the function name followed
14383 by the arguments in parentheses. However, functions for which @TeX{}
14384 and La@TeX{} have special names (like @code{\sin}) will use curly braces
14385 instead of parentheses for very simple arguments. During input, curly
14386 braces and parentheses work equally well for grouping, but when the
14387 document is formatted the curly braces will be invisible. Thus the
14389 @texline @math{\sin{2 x}}
14390 @infoline @expr{sin 2x}
14392 @texline @math{\sin(2 + x)}.
14393 @infoline @expr{sin(2 + x)}.
14395 Function and variable names not treated specially by @TeX{} and La@TeX{}
14396 are simply written out as-is, which will cause them to come out in
14397 italic letters in the printed document. If you invoke @kbd{d T} or
14398 @kbd{d L} with a positive numeric prefix argument, names of more than
14399 one character will instead be enclosed in a protective commands that
14400 will prevent them from being typeset in the math italics; they will be
14401 written @samp{\hbox@{@var{name}@}} in @TeX{} mode and
14402 @samp{\text@{@var{name}@}} in La@TeX{} mode. The
14403 @samp{\hbox@{ @}} and @samp{\text@{ @}} notations are ignored during
14404 reading. If you use a negative prefix argument, such function names are
14405 written @samp{\@var{name}}, and function names that begin with @code{\} during
14406 reading have the @code{\} removed. (Note that in this mode, long
14407 variable names are still written with @code{\hbox} or @code{\text}.
14408 However, you can always make an actual variable name like @code{\bar} in
14411 During reading, text of the form @samp{\matrix@{ ...@: @}} is replaced
14412 by @samp{[ ...@: ]}. The same also applies to @code{\pmatrix} and
14413 @code{\bmatrix}. In La@TeX{} mode this also applies to
14414 @samp{\begin@{matrix@} ... \end@{matrix@}},
14415 @samp{\begin@{bmatrix@} ... \end@{bmatrix@}},
14416 @samp{\begin@{pmatrix@} ... \end@{pmatrix@}}, as well as
14417 @samp{\begin@{smallmatrix@} ... \end@{smallmatrix@}}.
14418 The symbol @samp{&} is interpreted as a comma,
14419 and the symbols @samp{\cr} and @samp{\\} are interpreted as semicolons.
14420 During output, matrices are displayed in @samp{\matrix@{ a & b \\ c & d@}}
14421 format in @TeX{} mode and in
14422 @samp{\begin@{pmatrix@} a & b \\ c & d \end@{pmatrix@}} format in
14423 La@TeX{} mode; you may need to edit this afterwards to change to your
14424 preferred matrix form. If you invoke @kbd{d T} or @kbd{d L} with an
14425 argument of 2 or -2, then matrices will be displayed in two-dimensional
14436 This may be convenient for isolated matrices, but could lead to
14437 expressions being displayed like
14440 \begin@{pmatrix@} \times x
14447 While this wouldn't bother Calc, it is incorrect La@TeX{}.
14448 (Similarly for @TeX{}.)
14450 Accents like @code{\tilde} and @code{\bar} translate into function
14451 calls internally (@samp{tilde(x)}, @samp{bar(x)}). The @code{\underline}
14452 sequence is treated as an accent. The @code{\vec} accent corresponds
14453 to the function name @code{Vec}, because @code{vec} is the name of
14454 a built-in Calc function. The following table shows the accents
14455 in Calc, @TeX{}, La@TeX{} and @dfn{eqn} (described in the next section):
14459 @let@calcindexershow=@calcindexernoshow @c Suppress marginal notes
14460 @let@calcindexersh=@calcindexernoshow
14568 acute \acute \acute
14572 breve \breve \breve
14574 check \check \check
14580 dotdot \ddot \ddot dotdot
14583 grave \grave \grave
14588 tilde \tilde \tilde tilde
14590 under \underline \underline under
14595 The @samp{=>} (evaluates-to) operator appears as a @code{\to} symbol:
14596 @samp{@{@var{a} \to @var{b}@}}. @TeX{} defines @code{\to} as an
14597 alias for @code{\rightarrow}. However, if the @samp{=>} is the
14598 top-level expression being formatted, a slightly different notation
14599 is used: @samp{\evalto @var{a} \to @var{b}}. The @code{\evalto}
14600 word is ignored by Calc's input routines, and is undefined in @TeX{}.
14601 You will typically want to include one of the following definitions
14602 at the top of a @TeX{} file that uses @code{\evalto}:
14606 \def\evalto#1\to@{@}
14609 The first definition formats evaluates-to operators in the usual
14610 way. The second causes only the @var{b} part to appear in the
14611 printed document; the @var{a} part and the arrow are hidden.
14612 Another definition you may wish to use is @samp{\let\to=\Rightarrow}
14613 which causes @code{\to} to appear more like Calc's @samp{=>} symbol.
14614 @xref{Evaluates-To Operator}, for a discussion of @code{evalto}.
14616 The complete set of @TeX{} control sequences that are ignored during
14620 \hbox \mbox \text \left \right
14621 \, \> \: \; \! \quad \qquad \hfil \hfill
14622 \displaystyle \textstyle \dsize \tsize
14623 \scriptstyle \scriptscriptstyle \ssize \ssize
14624 \rm \bf \it \sl \roman \bold \italic \slanted
14625 \cal \mit \Cal \Bbb \frak \goth
14629 Note that, because these symbols are ignored, reading a @TeX{} or
14630 La@TeX{} formula into Calc and writing it back out may lose spacing and
14633 Also, the ``discretionary multiplication sign'' @samp{\*} is read
14634 the same as @samp{*}.
14637 The @TeX{} version of this manual includes some printed examples at the
14638 end of this section.
14641 Here are some examples of how various Calc formulas are formatted in @TeX{}:
14646 \sin\left( {a^2 \over b_i} \right)
14650 $$ \sin\left( a^2 \over b_i \right) $$
14656 [(3, 4), 3:4, 3 +/- 4, [3 .. inf)]
14657 [3 + 4i, @{3 \over 4@}, 3 \pm 4, [3 \ldots \infty)]
14662 $$ [3 + 4i, {3 \over 4}, 3 \pm 4, [ 3 \ldots \infty)] $$
14668 [abs(a), abs(a / b), floor(a), ceil(a / b)]
14669 [|a|, \left| a \over b \right|,
14670 \lfloor a \rfloor, \left\lceil a \over b \right\rceil]
14674 $$ [|a|, \left| a \over b \right|,
14675 \lfloor a \rfloor, \left\lceil a \over b \right\rceil] $$
14681 [sin(a), sin(2 a), sin(2 + a), sin(a / b)]
14682 [\sin@{a@}, \sin@{2 a@}, \sin(2 + a),
14683 \sin\left( @{a \over b@} \right)]
14688 $$ [\sin{a}, \sin{2 a}, \sin(2 + a), \sin\left( {a \over b} \right)] $$
14692 First with plain @kbd{d T}, then with @kbd{C-u d T}, then finally with
14693 @kbd{C-u - d T} (using the example definition
14694 @samp{\def\foo#1@{\tilde F(#1)@}}:
14698 [f(a), foo(bar), sin(pi)]
14699 [f(a), foo(bar), \sin{\pi}]
14700 [f(a), \hbox@{foo@}(\hbox@{bar@}), \sin@{\pi@}]
14701 [f(a), \foo@{\hbox@{bar@}@}, \sin@{\pi@}]
14705 $$ [f(a), foo(bar), \sin{\pi}] $$
14706 $$ [f(a), \hbox{foo}(\hbox{bar}), \sin{\pi}] $$
14707 $$ [f(a), \tilde F(\hbox{bar}), \sin{\pi}] $$
14711 First with @samp{\def\evalto@{@}}, then with @samp{\def\evalto#1\to@{@}}:
14716 \evalto 2 + 3 \to 5
14726 First with standard @code{\to}, then with @samp{\let\to\Rightarrow}:
14730 [2 + 3 => 5, a / 2 => (b + c) / 2]
14731 [@{2 + 3 \to 5@}, @{@{a \over 2@} \to @{b + c \over 2@}@}]
14736 $$ [{2 + 3 \to 5}, {{a \over 2} \to {b + c \over 2}}] $$
14737 {\let\to\Rightarrow
14738 $$ [{2 + 3 \to 5}, {{a \over 2} \to {b + c \over 2}}] $$}
14742 Matrices normally, then changing @code{\matrix} to @code{\pmatrix}:
14746 [ [ a / b, 0 ], [ 0, 2^(x + 1) ] ]
14747 \matrix@{ @{a \over b@} & 0 \\ 0 & 2^@{(x + 1)@} @}
14748 \pmatrix@{ @{a \over b@} & 0 \\ 0 & 2^@{(x + 1)@} @}
14753 $$ \matrix{ {a \over b} & 0 \cr 0 & 2^{(x + 1)} } $$
14754 $$ \pmatrix{ {a \over b} & 0 \cr 0 & 2^{(x + 1)} } $$
14759 @node Eqn Language Mode, Mathematica Language Mode, TeX and LaTeX Language Modes, Language Modes
14760 @subsection Eqn Language Mode
14764 @pindex calc-eqn-language
14765 @dfn{Eqn} is another popular formatter for math formulas. It is
14766 designed for use with the TROFF text formatter, and comes standard
14767 with many versions of Unix. The @kbd{d E} (@code{calc-eqn-language})
14768 command selects @dfn{eqn} notation.
14770 The @dfn{eqn} language's main idiosyncrasy is that whitespace plays
14771 a significant part in the parsing of the language. For example,
14772 @samp{sqrt x+1 + y} treats @samp{x+1} as the argument of the
14773 @code{sqrt} operator. @dfn{Eqn} also understands more conventional
14774 grouping using curly braces: @samp{sqrt@{x+1@} + y}. Braces are
14775 required only when the argument contains spaces.
14777 In Calc's @dfn{eqn} mode, however, curly braces are required to
14778 delimit arguments of operators like @code{sqrt}. The first of the
14779 above examples would treat only the @samp{x} as the argument of
14780 @code{sqrt}, and in fact @samp{sin x+1} would be interpreted as
14781 @samp{sin * x + 1}, because @code{sin} is not a special operator
14782 in the @dfn{eqn} language. If you always surround the argument
14783 with curly braces, Calc will never misunderstand.
14785 Calc also understands parentheses as grouping characters. Another
14786 peculiarity of @dfn{eqn}'s syntax makes it advisable to separate
14787 words with spaces from any surrounding characters that aren't curly
14788 braces, so Calc writes @samp{sin ( x + y )} in @dfn{eqn} mode.
14789 (The spaces around @code{sin} are important to make @dfn{eqn}
14790 recognize that @code{sin} should be typeset in a roman font, and
14791 the spaces around @code{x} and @code{y} are a good idea just in
14792 case the @dfn{eqn} document has defined special meanings for these
14795 Powers and subscripts are written with the @code{sub} and @code{sup}
14796 operators, respectively. Note that the caret symbol @samp{^} is
14797 treated the same as a space in @dfn{eqn} mode, as is the @samp{~}
14798 symbol (these are used to introduce spaces of various widths into
14799 the typeset output of @dfn{eqn}).
14801 As in La@TeX{} mode, Calc's formatter omits parentheses around the
14802 arguments of functions like @code{ln} and @code{sin} if they are
14803 ``simple-looking''; in this case Calc surrounds the argument with
14804 braces, separated by a @samp{~} from the function name: @samp{sin~@{x@}}.
14806 Font change codes (like @samp{roman @var{x}}) and positioning codes
14807 (like @samp{~} and @samp{down @var{n} @var{x}}) are ignored by the
14808 @dfn{eqn} reader. Also ignored are the words @code{left}, @code{right},
14809 @code{mark}, and @code{lineup}. Quotation marks in @dfn{eqn} mode input
14810 are treated the same as curly braces: @samp{sqrt "1+x"} is equivalent to
14811 @samp{sqrt @{1+x@}}; this is only an approximation to the true meaning
14812 of quotes in @dfn{eqn}, but it is good enough for most uses.
14814 Accent codes (@samp{@var{x} dot}) are handled by treating them as
14815 function calls (@samp{dot(@var{x})}) internally.
14816 @xref{TeX and LaTeX Language Modes}, for a table of these accent
14817 functions. The @code{prime} accent is treated specially if it occurs on
14818 a variable or function name: @samp{f prime prime @w{( x prime )}} is
14819 stored internally as @samp{f'@w{'}(x')}. For example, taking the
14820 derivative of @samp{f(2 x)} with @kbd{a d x} will produce @samp{2 f'(2
14821 x)}, which @dfn{eqn} mode will display as @samp{2 f prime ( 2 x )}.
14823 Assignments are written with the @samp{<-} (left-arrow) symbol,
14824 and @code{evalto} operators are written with @samp{->} or
14825 @samp{evalto ... ->} (@pxref{TeX and LaTeX Language Modes}, for a discussion
14826 of this). The regular Calc symbols @samp{:=} and @samp{=>} are also
14827 recognized for these operators during reading.
14829 Vectors in @dfn{eqn} mode use regular Calc square brackets, but
14830 matrices are formatted as @samp{matrix @{ ccol @{ a above b @} ... @}}.
14831 The words @code{lcol} and @code{rcol} are recognized as synonyms
14832 for @code{ccol} during input, and are generated instead of @code{ccol}
14833 if the matrix justification mode so specifies.
14835 @node Mathematica Language Mode, Maple Language Mode, Eqn Language Mode, Language Modes
14836 @subsection Mathematica Language Mode
14840 @pindex calc-mathematica-language
14841 @cindex Mathematica language
14842 The @kbd{d M} (@code{calc-mathematica-language}) command selects the
14843 conventions of Mathematica. Notable differences in Mathematica mode
14844 are that the names of built-in functions are capitalized, and function
14845 calls use square brackets instead of parentheses. Thus the Calc
14846 formula @samp{sin(2 x)} is entered and displayed @w{@samp{Sin[2 x]}} in
14849 Vectors and matrices use curly braces in Mathematica. Complex numbers
14850 are written @samp{3 + 4 I}. The standard special constants in Calc are
14851 written @code{Pi}, @code{E}, @code{I}, @code{GoldenRatio}, @code{EulerGamma},
14852 @code{Infinity}, @code{ComplexInfinity}, and @code{Indeterminate} in
14854 Non-decimal numbers are written, e.g., @samp{16^^7fff}. Floating-point
14855 numbers in scientific notation are written @samp{1.23*10.^3}.
14856 Subscripts use double square brackets: @samp{a[[i]]}.
14858 @node Maple Language Mode, Compositions, Mathematica Language Mode, Language Modes
14859 @subsection Maple Language Mode
14863 @pindex calc-maple-language
14864 @cindex Maple language
14865 The @kbd{d W} (@code{calc-maple-language}) command selects the
14866 conventions of Maple.
14868 Maple's language is much like C. Underscores are allowed in symbol
14869 names; square brackets are used for subscripts; explicit @samp{*}s for
14870 multiplications are required. Use either @samp{^} or @samp{**} to
14873 Maple uses square brackets for lists and curly braces for sets. Calc
14874 interprets both notations as vectors, and displays vectors with square
14875 brackets. This means Maple sets will be converted to lists when they
14876 pass through Calc. As a special case, matrices are written as calls
14877 to the function @code{matrix}, given a list of lists as the argument,
14878 and can be read in this form or with all-capitals @code{MATRIX}.
14880 The Maple interval notation @samp{2 .. 3} has no surrounding brackets;
14881 Calc reads @samp{2 .. 3} as the closed interval @samp{[2 .. 3]}, and
14882 writes any kind of interval as @samp{2 .. 3}. This means you cannot
14883 see the difference between an open and a closed interval while in
14884 Maple display mode.
14886 Maple writes complex numbers as @samp{3 + 4*I}. Its special constants
14887 are @code{Pi}, @code{E}, @code{I}, and @code{infinity} (all three of
14888 @code{inf}, @code{uinf}, and @code{nan} display as @code{infinity}).
14889 Floating-point numbers are written @samp{1.23*10.^3}.
14891 Among things not currently handled by Calc's Maple mode are the
14892 various quote symbols, procedures and functional operators, and
14893 inert (@samp{&}) operators.
14895 @node Compositions, Syntax Tables, Maple Language Mode, Language Modes
14896 @subsection Compositions
14899 @cindex Compositions
14900 There are several @dfn{composition functions} which allow you to get
14901 displays in a variety of formats similar to those in Big language
14902 mode. Most of these functions do not evaluate to anything; they are
14903 placeholders which are left in symbolic form by Calc's evaluator but
14904 are recognized by Calc's display formatting routines.
14906 Two of these, @code{string} and @code{bstring}, are described elsewhere.
14907 @xref{Strings}. For example, @samp{string("ABC")} is displayed as
14908 @samp{ABC}. When viewed on the stack it will be indistinguishable from
14909 the variable @code{ABC}, but internally it will be stored as
14910 @samp{string([65, 66, 67])} and can still be manipulated this way; for
14911 example, the selection and vector commands @kbd{j 1 v v j u} would
14912 select the vector portion of this object and reverse the elements, then
14913 deselect to reveal a string whose characters had been reversed.
14915 The composition functions do the same thing in all language modes
14916 (although their components will of course be formatted in the current
14917 language mode). The one exception is Unformatted mode (@kbd{d U}),
14918 which does not give the composition functions any special treatment.
14919 The functions are discussed here because of their relationship to
14920 the language modes.
14923 * Composition Basics::
14924 * Horizontal Compositions::
14925 * Vertical Compositions::
14926 * Other Compositions::
14927 * Information about Compositions::
14928 * User-Defined Compositions::
14931 @node Composition Basics, Horizontal Compositions, Compositions, Compositions
14932 @subsubsection Composition Basics
14935 Compositions are generally formed by stacking formulas together
14936 horizontally or vertically in various ways. Those formulas are
14937 themselves compositions. @TeX{} users will find this analogous
14938 to @TeX{}'s ``boxes.'' Each multi-line composition has a
14939 @dfn{baseline}; horizontal compositions use the baselines to
14940 decide how formulas should be positioned relative to one another.
14941 For example, in the Big mode formula
14953 the second term of the sum is four lines tall and has line three as
14954 its baseline. Thus when the term is combined with 17, line three
14955 is placed on the same level as the baseline of 17.
14961 Another important composition concept is @dfn{precedence}. This is
14962 an integer that represents the binding strength of various operators.
14963 For example, @samp{*} has higher precedence (195) than @samp{+} (180),
14964 which means that @samp{(a * b) + c} will be formatted without the
14965 parentheses, but @samp{a * (b + c)} will keep the parentheses.
14967 The operator table used by normal and Big language modes has the
14968 following precedences:
14971 _ 1200 @r{(subscripts)}
14972 % 1100 @r{(as in n}%@r{)}
14973 - 1000 @r{(as in }-@r{n)}
14974 ! 1000 @r{(as in }!@r{n)}
14977 !! 210 @r{(as in n}!!@r{)}
14978 ! 210 @r{(as in n}!@r{)}
14980 * 195 @r{(or implicit multiplication)}
14982 + - 180 @r{(as in a}+@r{b)}
14984 < = 160 @r{(and other relations)}
14996 The general rule is that if an operator with precedence @expr{n}
14997 occurs as an argument to an operator with precedence @expr{m}, then
14998 the argument is enclosed in parentheses if @expr{n < m}. Top-level
14999 expressions and expressions which are function arguments, vector
15000 components, etc., are formatted with precedence zero (so that they
15001 normally never get additional parentheses).
15003 For binary left-associative operators like @samp{+}, the righthand
15004 argument is actually formatted with one-higher precedence than shown
15005 in the table. This makes sure @samp{(a + b) + c} omits the parentheses,
15006 but the unnatural form @samp{a + (b + c)} keeps its parentheses.
15007 Right-associative operators like @samp{^} format the lefthand argument
15008 with one-higher precedence.
15014 The @code{cprec} function formats an expression with an arbitrary
15015 precedence. For example, @samp{cprec(abc, 185)} will combine into
15016 sums and products as follows: @samp{7 + abc}, @samp{7 (abc)} (because
15017 this @code{cprec} form has higher precedence than addition, but lower
15018 precedence than multiplication).
15024 A final composition issue is @dfn{line breaking}. Calc uses two
15025 different strategies for ``flat'' and ``non-flat'' compositions.
15026 A non-flat composition is anything that appears on multiple lines
15027 (not counting line breaking). Examples would be matrices and Big
15028 mode powers and quotients. Non-flat compositions are displayed
15029 exactly as specified. If they come out wider than the current
15030 window, you must use horizontal scrolling (@kbd{<} and @kbd{>}) to
15033 Flat compositions, on the other hand, will be broken across several
15034 lines if they are too wide to fit the window. Certain points in a
15035 composition are noted internally as @dfn{break points}. Calc's
15036 general strategy is to fill each line as much as possible, then to
15037 move down to the next line starting at the first break point that
15038 didn't fit. However, the line breaker understands the hierarchical
15039 structure of formulas. It will not break an ``inner'' formula if
15040 it can use an earlier break point from an ``outer'' formula instead.
15041 For example, a vector of sums might be formatted as:
15045 [ a + b + c, d + e + f,
15046 g + h + i, j + k + l, m ]
15051 If the @samp{m} can fit, then so, it seems, could the @samp{g}.
15052 But Calc prefers to break at the comma since the comma is part
15053 of a ``more outer'' formula. Calc would break at a plus sign
15054 only if it had to, say, if the very first sum in the vector had
15055 itself been too large to fit.
15057 Of the composition functions described below, only @code{choriz}
15058 generates break points. The @code{bstring} function (@pxref{Strings})
15059 also generates breakable items: A break point is added after every
15060 space (or group of spaces) except for spaces at the very beginning or
15063 Composition functions themselves count as levels in the formula
15064 hierarchy, so a @code{choriz} that is a component of a larger
15065 @code{choriz} will be less likely to be broken. As a special case,
15066 if a @code{bstring} occurs as a component of a @code{choriz} or
15067 @code{choriz}-like object (such as a vector or a list of arguments
15068 in a function call), then the break points in that @code{bstring}
15069 will be on the same level as the break points of the surrounding
15072 @node Horizontal Compositions, Vertical Compositions, Composition Basics, Compositions
15073 @subsubsection Horizontal Compositions
15080 The @code{choriz} function takes a vector of objects and composes
15081 them horizontally. For example, @samp{choriz([17, a b/c, d])} formats
15082 as @w{@samp{17a b / cd}} in Normal language mode, or as
15093 in Big language mode. This is actually one case of the general
15094 function @samp{choriz(@var{vec}, @var{sep}, @var{prec})}, where
15095 either or both of @var{sep} and @var{prec} may be omitted.
15096 @var{Prec} gives the @dfn{precedence} to use when formatting
15097 each of the components of @var{vec}. The default precedence is
15098 the precedence from the surrounding environment.
15100 @var{Sep} is a string (i.e., a vector of character codes as might
15101 be entered with @code{" "} notation) which should separate components
15102 of the composition. Also, if @var{sep} is given, the line breaker
15103 will allow lines to be broken after each occurrence of @var{sep}.
15104 If @var{sep} is omitted, the composition will not be breakable
15105 (unless any of its component compositions are breakable).
15107 For example, @samp{2 choriz([a, b c, d = e], " + ", 180)} is
15108 formatted as @samp{2 a + b c + (d = e)}. To get the @code{choriz}
15109 to have precedence 180 ``outwards'' as well as ``inwards,''
15110 enclose it in a @code{cprec} form: @samp{2 cprec(choriz(...), 180)}
15111 formats as @samp{2 (a + b c + (d = e))}.
15113 The baseline of a horizontal composition is the same as the
15114 baselines of the component compositions, which are all aligned.
15116 @node Vertical Compositions, Other Compositions, Horizontal Compositions, Compositions
15117 @subsubsection Vertical Compositions
15124 The @code{cvert} function makes a vertical composition. Each
15125 component of the vector is centered in a column. The baseline of
15126 the result is by default the top line of the resulting composition.
15127 For example, @samp{f(cvert([a, bb, ccc]), cvert([a^2 + 1, b^2]))}
15128 formats in Big mode as
15143 There are several special composition functions that work only as
15144 components of a vertical composition. The @code{cbase} function
15145 controls the baseline of the vertical composition; the baseline
15146 will be the same as the baseline of whatever component is enclosed
15147 in @code{cbase}. Thus @samp{f(cvert([a, cbase(bb), ccc]),
15148 cvert([a^2 + 1, cbase(b^2)]))} displays as
15168 There are also @code{ctbase} and @code{cbbase} functions which
15169 make the baseline of the vertical composition equal to the top
15170 or bottom line (rather than the baseline) of that component.
15171 Thus @samp{cvert([cbase(a / b)]) + cvert([ctbase(a / b)]) +
15172 cvert([cbbase(a / b)])} gives
15184 There should be only one @code{cbase}, @code{ctbase}, or @code{cbbase}
15185 function in a given vertical composition. These functions can also
15186 be written with no arguments: @samp{ctbase()} is a zero-height object
15187 which means the baseline is the top line of the following item, and
15188 @samp{cbbase()} means the baseline is the bottom line of the preceding
15195 The @code{crule} function builds a ``rule,'' or horizontal line,
15196 across a vertical composition. By itself @samp{crule()} uses @samp{-}
15197 characters to build the rule. You can specify any other character,
15198 e.g., @samp{crule("=")}. The argument must be a character code or
15199 vector of exactly one character code. It is repeated to match the
15200 width of the widest item in the stack. For example, a quotient
15201 with a thick line is @samp{cvert([a + 1, cbase(crule("=")), b^2])}:
15220 Finally, the functions @code{clvert} and @code{crvert} act exactly
15221 like @code{cvert} except that the items are left- or right-justified
15222 in the stack. Thus @samp{clvert([a, bb, ccc]) + crvert([a, bb, ccc])}
15233 Like @code{choriz}, the vertical compositions accept a second argument
15234 which gives the precedence to use when formatting the components.
15235 Vertical compositions do not support separator strings.
15237 @node Other Compositions, Information about Compositions, Vertical Compositions, Compositions
15238 @subsubsection Other Compositions
15245 The @code{csup} function builds a superscripted expression. For
15246 example, @samp{csup(a, b)} looks the same as @samp{a^b} does in Big
15247 language mode. This is essentially a horizontal composition of
15248 @samp{a} and @samp{b}, where @samp{b} is shifted up so that its
15249 bottom line is one above the baseline.
15255 Likewise, the @code{csub} function builds a subscripted expression.
15256 This shifts @samp{b} down so that its top line is one below the
15257 bottom line of @samp{a} (note that this is not quite analogous to
15258 @code{csup}). Other arrangements can be obtained by using
15259 @code{choriz} and @code{cvert} directly.
15265 The @code{cflat} function formats its argument in ``flat'' mode,
15266 as obtained by @samp{d O}, if the current language mode is normal
15267 or Big. It has no effect in other language modes. For example,
15268 @samp{a^(b/c)} is formatted by Big mode like @samp{csup(a, cflat(b/c))}
15269 to improve its readability.
15275 The @code{cspace} function creates horizontal space. For example,
15276 @samp{cspace(4)} is effectively the same as @samp{string(" ")}.
15277 A second string (i.e., vector of characters) argument is repeated
15278 instead of the space character. For example, @samp{cspace(4, "ab")}
15279 looks like @samp{abababab}. If the second argument is not a string,
15280 it is formatted in the normal way and then several copies of that
15281 are composed together: @samp{cspace(4, a^2)} yields
15291 If the number argument is zero, this is a zero-width object.
15297 The @code{cvspace} function creates vertical space, or a vertical
15298 stack of copies of a certain string or formatted object. The
15299 baseline is the center line of the resulting stack. A numerical
15300 argument of zero will produce an object which contributes zero
15301 height if used in a vertical composition.
15311 There are also @code{ctspace} and @code{cbspace} functions which
15312 create vertical space with the baseline the same as the baseline
15313 of the top or bottom copy, respectively, of the second argument.
15314 Thus @samp{cvspace(2, a/b) + ctspace(2, a/b) + cbspace(2, a/b)}
15331 @node Information about Compositions, User-Defined Compositions, Other Compositions, Compositions
15332 @subsubsection Information about Compositions
15335 The functions in this section are actual functions; they compose their
15336 arguments according to the current language and other display modes,
15337 then return a certain measurement of the composition as an integer.
15343 The @code{cwidth} function measures the width, in characters, of a
15344 composition. For example, @samp{cwidth(a + b)} is 5, and
15345 @samp{cwidth(a / b)} is 5 in Normal mode, 1 in Big mode, and 11 in
15346 @TeX{} mode (for @samp{@{a \over b@}}). The argument may involve
15347 the composition functions described in this section.
15353 The @code{cheight} function measures the height of a composition.
15354 This is the total number of lines in the argument's printed form.
15364 The functions @code{cascent} and @code{cdescent} measure the amount
15365 of the height that is above (and including) the baseline, or below
15366 the baseline, respectively. Thus @samp{cascent(@var{x}) + cdescent(@var{x})}
15367 always equals @samp{cheight(@var{x})}. For a one-line formula like
15368 @samp{a + b}, @code{cascent} returns 1 and @code{cdescent} returns 0.
15369 For @samp{a / b} in Big mode, @code{cascent} returns 2 and @code{cdescent}
15370 returns 1. The only formula for which @code{cascent} will return zero
15371 is @samp{cvspace(0)} or equivalents.
15373 @node User-Defined Compositions, , Information about Compositions, Compositions
15374 @subsubsection User-Defined Compositions
15378 @pindex calc-user-define-composition
15379 The @kbd{Z C} (@code{calc-user-define-composition}) command lets you
15380 define the display format for any algebraic function. You provide a
15381 formula containing a certain number of argument variables on the stack.
15382 Any time Calc formats a call to the specified function in the current
15383 language mode and with that number of arguments, Calc effectively
15384 replaces the function call with that formula with the arguments
15387 Calc builds the default argument list by sorting all the variable names
15388 that appear in the formula into alphabetical order. You can edit this
15389 argument list before pressing @key{RET} if you wish. Any variables in
15390 the formula that do not appear in the argument list will be displayed
15391 literally; any arguments that do not appear in the formula will not
15392 affect the display at all.
15394 You can define formats for built-in functions, for functions you have
15395 defined with @kbd{Z F} (@pxref{Algebraic Definitions}), or for functions
15396 which have no definitions but are being used as purely syntactic objects.
15397 You can define different formats for each language mode, and for each
15398 number of arguments, using a succession of @kbd{Z C} commands. When
15399 Calc formats a function call, it first searches for a format defined
15400 for the current language mode (and number of arguments); if there is
15401 none, it uses the format defined for the Normal language mode. If
15402 neither format exists, Calc uses its built-in standard format for that
15403 function (usually just @samp{@var{func}(@var{args})}).
15405 If you execute @kbd{Z C} with the number 0 on the stack instead of a
15406 formula, any defined formats for the function in the current language
15407 mode will be removed. The function will revert to its standard format.
15409 For example, the default format for the binomial coefficient function
15410 @samp{choose(n, m)} in the Big language mode is
15421 You might prefer the notation,
15431 To define this notation, first make sure you are in Big mode,
15432 then put the formula
15435 choriz([cvert([cvspace(1), n]), C, cvert([cvspace(1), m])])
15439 on the stack and type @kbd{Z C}. Answer the first prompt with
15440 @code{choose}. The second prompt will be the default argument list
15441 of @samp{(C m n)}. Edit this list to be @samp{(n m)} and press
15442 @key{RET}. Now, try it out: For example, turn simplification
15443 off with @kbd{m O} and enter @samp{choose(a,b) + choose(7,3)}
15444 as an algebraic entry.
15453 As another example, let's define the usual notation for Stirling
15454 numbers of the first kind, @samp{stir1(n, m)}. This is just like
15455 the regular format for binomial coefficients but with square brackets
15456 instead of parentheses.
15459 choriz([string("["), cvert([n, cbase(cvspace(1)), m]), string("]")])
15462 Now type @kbd{Z C stir1 @key{RET}}, edit the argument list to
15463 @samp{(n m)}, and type @key{RET}.
15465 The formula provided to @kbd{Z C} usually will involve composition
15466 functions, but it doesn't have to. Putting the formula @samp{a + b + c}
15467 onto the stack and typing @kbd{Z C foo @key{RET} @key{RET}} would define
15468 the function @samp{foo(x,y,z)} to display like @samp{x + y + z}.
15469 This ``sum'' will act exactly like a real sum for all formatting
15470 purposes (it will be parenthesized the same, and so on). However
15471 it will be computationally unrelated to a sum. For example, the
15472 formula @samp{2 * foo(1, 2, 3)} will display as @samp{2 (1 + 2 + 3)}.
15473 Operator precedences have caused the ``sum'' to be written in
15474 parentheses, but the arguments have not actually been summed.
15475 (Generally a display format like this would be undesirable, since
15476 it can easily be confused with a real sum.)
15478 The special function @code{eval} can be used inside a @kbd{Z C}
15479 composition formula to cause all or part of the formula to be
15480 evaluated at display time. For example, if the formula is
15481 @samp{a + eval(b + c)}, then @samp{foo(1, 2, 3)} will be displayed
15482 as @samp{1 + 5}. Evaluation will use the default simplifications,
15483 regardless of the current simplification mode. There are also
15484 @code{evalsimp} and @code{evalextsimp} which simplify as if by
15485 @kbd{a s} and @kbd{a e} (respectively). Note that these ``functions''
15486 operate only in the context of composition formulas (and also in
15487 rewrite rules, where they serve a similar purpose; @pxref{Rewrite
15488 Rules}). On the stack, a call to @code{eval} will be left in
15491 It is not a good idea to use @code{eval} except as a last resort.
15492 It can cause the display of formulas to be extremely slow. For
15493 example, while @samp{eval(a + b)} might seem quite fast and simple,
15494 there are several situations where it could be slow. For example,
15495 @samp{a} and/or @samp{b} could be polar complex numbers, in which
15496 case doing the sum requires trigonometry. Or, @samp{a} could be
15497 the factorial @samp{fact(100)} which is unevaluated because you
15498 have typed @kbd{m O}; @code{eval} will evaluate it anyway to
15499 produce a large, unwieldy integer.
15501 You can save your display formats permanently using the @kbd{Z P}
15502 command (@pxref{Creating User Keys}).
15504 @node Syntax Tables, , Compositions, Language Modes
15505 @subsection Syntax Tables
15508 @cindex Syntax tables
15509 @cindex Parsing formulas, customized
15510 Syntax tables do for input what compositions do for output: They
15511 allow you to teach custom notations to Calc's formula parser.
15512 Calc keeps a separate syntax table for each language mode.
15514 (Note that the Calc ``syntax tables'' discussed here are completely
15515 unrelated to the syntax tables described in the Emacs manual.)
15518 @pindex calc-edit-user-syntax
15519 The @kbd{Z S} (@code{calc-edit-user-syntax}) command edits the
15520 syntax table for the current language mode. If you want your
15521 syntax to work in any language, define it in the Normal language
15522 mode. Type @kbd{C-c C-c} to finish editing the syntax table, or
15523 @kbd{C-x k} to cancel the edit. The @kbd{m m} command saves all
15524 the syntax tables along with the other mode settings;
15525 @pxref{General Mode Commands}.
15528 * Syntax Table Basics::
15529 * Precedence in Syntax Tables::
15530 * Advanced Syntax Patterns::
15531 * Conditional Syntax Rules::
15534 @node Syntax Table Basics, Precedence in Syntax Tables, Syntax Tables, Syntax Tables
15535 @subsubsection Syntax Table Basics
15538 @dfn{Parsing} is the process of converting a raw string of characters,
15539 such as you would type in during algebraic entry, into a Calc formula.
15540 Calc's parser works in two stages. First, the input is broken down
15541 into @dfn{tokens}, such as words, numbers, and punctuation symbols
15542 like @samp{+}, @samp{:=}, and @samp{+/-}. Space between tokens is
15543 ignored (except when it serves to separate adjacent words). Next,
15544 the parser matches this string of tokens against various built-in
15545 syntactic patterns, such as ``an expression followed by @samp{+}
15546 followed by another expression'' or ``a name followed by @samp{(},
15547 zero or more expressions separated by commas, and @samp{)}.''
15549 A @dfn{syntax table} is a list of user-defined @dfn{syntax rules},
15550 which allow you to specify new patterns to define your own
15551 favorite input notations. Calc's parser always checks the syntax
15552 table for the current language mode, then the table for the Normal
15553 language mode, before it uses its built-in rules to parse an
15554 algebraic formula you have entered. Each syntax rule should go on
15555 its own line; it consists of a @dfn{pattern}, a @samp{:=} symbol,
15556 and a Calc formula with an optional @dfn{condition}. (Syntax rules
15557 resemble algebraic rewrite rules, but the notation for patterns is
15558 completely different.)
15560 A syntax pattern is a list of tokens, separated by spaces.
15561 Except for a few special symbols, tokens in syntax patterns are
15562 matched literally, from left to right. For example, the rule,
15569 would cause Calc to parse the formula @samp{4+foo()*5} as if it
15570 were @samp{4+(2+3)*5}. Notice that the parentheses were written
15571 as two separate tokens in the rule. As a result, the rule works
15572 for both @samp{foo()} and @w{@samp{foo ( )}}. If we had written
15573 the rule as @samp{foo () := 2+3}, then Calc would treat @samp{()}
15574 as a single, indivisible token, so that @w{@samp{foo( )}} would
15575 not be recognized by the rule. (It would be parsed as a regular
15576 zero-argument function call instead.) In fact, this rule would
15577 also make trouble for the rest of Calc's parser: An unrelated
15578 formula like @samp{bar()} would now be tokenized into @samp{bar ()}
15579 instead of @samp{bar ( )}, so that the standard parser for function
15580 calls would no longer recognize it!
15582 While it is possible to make a token with a mixture of letters
15583 and punctuation symbols, this is not recommended. It is better to
15584 break it into several tokens, as we did with @samp{foo()} above.
15586 The symbol @samp{#} in a syntax pattern matches any Calc expression.
15587 On the righthand side, the things that matched the @samp{#}s can
15588 be referred to as @samp{#1}, @samp{#2}, and so on (where @samp{#1}
15589 matches the leftmost @samp{#} in the pattern). For example, these
15590 rules match a user-defined function, prefix operator, infix operator,
15591 and postfix operator, respectively:
15594 foo ( # ) := myfunc(#1)
15595 foo # := myprefix(#1)
15596 # foo # := myinfix(#1,#2)
15597 # foo := mypostfix(#1)
15600 Thus @samp{foo(3)} will parse as @samp{myfunc(3)}, and @samp{2+3 foo}
15601 will parse as @samp{mypostfix(2+3)}.
15603 It is important to write the first two rules in the order shown,
15604 because Calc tries rules in order from first to last. If the
15605 pattern @samp{foo #} came first, it would match anything that could
15606 match the @samp{foo ( # )} rule, since an expression in parentheses
15607 is itself a valid expression. Thus the @w{@samp{foo ( # )}} rule would
15608 never get to match anything. Likewise, the last two rules must be
15609 written in the order shown or else @samp{3 foo 4} will be parsed as
15610 @samp{mypostfix(3) * 4}. (Of course, the best way to avoid these
15611 ambiguities is not to use the same symbol in more than one way at
15612 the same time! In case you're not convinced, try the following
15613 exercise: How will the above rules parse the input @samp{foo(3,4)},
15614 if at all? Work it out for yourself, then try it in Calc and see.)
15616 Calc is quite flexible about what sorts of patterns are allowed.
15617 The only rule is that every pattern must begin with a literal
15618 token (like @samp{foo} in the first two patterns above), or with
15619 a @samp{#} followed by a literal token (as in the last two
15620 patterns). After that, any mixture is allowed, although putting
15621 two @samp{#}s in a row will not be very useful since two
15622 expressions with nothing between them will be parsed as one
15623 expression that uses implicit multiplication.
15625 As a more practical example, Maple uses the notation
15626 @samp{sum(a(i), i=1..10)} for sums, which Calc's Maple mode doesn't
15627 recognize at present. To handle this syntax, we simply add the
15631 sum ( # , # = # .. # ) := sum(#1,#2,#3,#4)
15635 to the Maple mode syntax table. As another example, C mode can't
15636 read assignment operators like @samp{++} and @samp{*=}. We can
15637 define these operators quite easily:
15640 # *= # := muleq(#1,#2)
15641 # ++ := postinc(#1)
15646 To complete the job, we would use corresponding composition functions
15647 and @kbd{Z C} to cause these functions to display in their respective
15648 Maple and C notations. (Note that the C example ignores issues of
15649 operator precedence, which are discussed in the next section.)
15651 You can enclose any token in quotes to prevent its usual
15652 interpretation in syntax patterns:
15655 # ":=" # := becomes(#1,#2)
15658 Quotes also allow you to include spaces in a token, although once
15659 again it is generally better to use two tokens than one token with
15660 an embedded space. To include an actual quotation mark in a quoted
15661 token, precede it with a backslash. (This also works to include
15662 backslashes in tokens.)
15665 # "bad token" # "/\"\\" # := silly(#1,#2,#3)
15669 This will parse @samp{3 bad token 4 /"\ 5} to @samp{silly(3,4,5)}.
15671 The token @kbd{#} has a predefined meaning in Calc's formula parser;
15672 it is not valid to use @samp{"#"} in a syntax rule. However, longer
15673 tokens that include the @samp{#} character are allowed. Also, while
15674 @samp{"$"} and @samp{"\""} are allowed as tokens, their presence in
15675 the syntax table will prevent those characters from working in their
15676 usual ways (referring to stack entries and quoting strings,
15679 Finally, the notation @samp{%%} anywhere in a syntax table causes
15680 the rest of the line to be ignored as a comment.
15682 @node Precedence in Syntax Tables, Advanced Syntax Patterns, Syntax Table Basics, Syntax Tables
15683 @subsubsection Precedence
15686 Different operators are generally assigned different @dfn{precedences}.
15687 By default, an operator defined by a rule like
15690 # foo # := foo(#1,#2)
15694 will have an extremely low precedence, so that @samp{2*3+4 foo 5 == 6}
15695 will be parsed as @samp{(2*3+4) foo (5 == 6)}. To change the
15696 precedence of an operator, use the notation @samp{#/@var{p}} in
15697 place of @samp{#}, where @var{p} is an integer precedence level.
15698 For example, 185 lies between the precedences for @samp{+} and
15699 @samp{*}, so if we change this rule to
15702 #/185 foo #/186 := foo(#1,#2)
15706 then @samp{2+3 foo 4*5} will be parsed as @samp{2+(3 foo (4*5))}.
15707 Also, because we've given the righthand expression slightly higher
15708 precedence, our new operator will be left-associative:
15709 @samp{1 foo 2 foo 3} will be parsed as @samp{(1 foo 2) foo 3}.
15710 By raising the precedence of the lefthand expression instead, we
15711 can create a right-associative operator.
15713 @xref{Composition Basics}, for a table of precedences of the
15714 standard Calc operators. For the precedences of operators in other
15715 language modes, look in the Calc source file @file{calc-lang.el}.
15717 @node Advanced Syntax Patterns, Conditional Syntax Rules, Precedence in Syntax Tables, Syntax Tables
15718 @subsubsection Advanced Syntax Patterns
15721 To match a function with a variable number of arguments, you could
15725 foo ( # ) := myfunc(#1)
15726 foo ( # , # ) := myfunc(#1,#2)
15727 foo ( # , # , # ) := myfunc(#1,#2,#3)
15731 but this isn't very elegant. To match variable numbers of items,
15732 Calc uses some notations inspired regular expressions and the
15733 ``extended BNF'' style used by some language designers.
15736 foo ( @{ # @}*, ) := apply(myfunc,#1)
15739 The token @samp{@{} introduces a repeated or optional portion.
15740 One of the three tokens @samp{@}*}, @samp{@}+}, or @samp{@}?}
15741 ends the portion. These will match zero or more, one or more,
15742 or zero or one copies of the enclosed pattern, respectively.
15743 In addition, @samp{@}*} and @samp{@}+} can be followed by a
15744 separator token (with no space in between, as shown above).
15745 Thus @samp{@{ # @}*,} matches nothing, or one expression, or
15746 several expressions separated by commas.
15748 A complete @samp{@{ ... @}} item matches as a vector of the
15749 items that matched inside it. For example, the above rule will
15750 match @samp{foo(1,2,3)} to get @samp{apply(myfunc,[1,2,3])}.
15751 The Calc @code{apply} function takes a function name and a vector
15752 of arguments and builds a call to the function with those
15753 arguments, so the net result is the formula @samp{myfunc(1,2,3)}.
15755 If the body of a @samp{@{ ... @}} contains several @samp{#}s
15756 (or nested @samp{@{ ... @}} constructs), then the items will be
15757 strung together into the resulting vector. If the body
15758 does not contain anything but literal tokens, the result will
15759 always be an empty vector.
15762 foo ( @{ # , # @}+, ) := bar(#1)
15763 foo ( @{ @{ # @}*, @}*; ) := matrix(#1)
15767 will parse @samp{foo(1, 2, 3, 4)} as @samp{bar([1, 2, 3, 4])}, and
15768 @samp{foo(1, 2; 3, 4)} as @samp{matrix([[1, 2], [3, 4]])}. Also, after
15769 some thought it's easy to see how this pair of rules will parse
15770 @samp{foo(1, 2, 3)} as @samp{matrix([[1, 2, 3]])}, since the first
15771 rule will only match an even number of arguments. The rule
15774 foo ( # @{ , # , # @}? ) := bar(#1,#2)
15778 will parse @samp{foo(2,3,4)} as @samp{bar(2,[3,4])}, and
15779 @samp{foo(2)} as @samp{bar(2,[])}.
15781 The notation @samp{@{ ... @}?.} (note the trailing period) works
15782 just the same as regular @samp{@{ ... @}?}, except that it does not
15783 count as an argument; the following two rules are equivalent:
15786 foo ( # , @{ also @}? # ) := bar(#1,#3)
15787 foo ( # , @{ also @}?. # ) := bar(#1,#2)
15791 Note that in the first case the optional text counts as @samp{#2},
15792 which will always be an empty vector, but in the second case no
15793 empty vector is produced.
15795 Another variant is @samp{@{ ... @}?$}, which means the body is
15796 optional only at the end of the input formula. All built-in syntax
15797 rules in Calc use this for closing delimiters, so that during
15798 algebraic entry you can type @kbd{[sqrt(2), sqrt(3 @key{RET}}, omitting
15799 the closing parenthesis and bracket. Calc does this automatically
15800 for trailing @samp{)}, @samp{]}, and @samp{>} tokens in syntax
15801 rules, but you can use @samp{@{ ... @}?$} explicitly to get
15802 this effect with any token (such as @samp{"@}"} or @samp{end}).
15803 Like @samp{@{ ... @}?.}, this notation does not count as an
15804 argument. Conversely, you can use quotes, as in @samp{")"}, to
15805 prevent a closing-delimiter token from being automatically treated
15808 Calc's parser does not have full backtracking, which means some
15809 patterns will not work as you might expect:
15812 foo ( @{ # , @}? # , # ) := bar(#1,#2,#3)
15816 Here we are trying to make the first argument optional, so that
15817 @samp{foo(2,3)} parses as @samp{bar([],2,3)}. Unfortunately, Calc
15818 first tries to match @samp{2,} against the optional part of the
15819 pattern, finds a match, and so goes ahead to match the rest of the
15820 pattern. Later on it will fail to match the second comma, but it
15821 doesn't know how to go back and try the other alternative at that
15822 point. One way to get around this would be to use two rules:
15825 foo ( # , # , # ) := bar([#1],#2,#3)
15826 foo ( # , # ) := bar([],#1,#2)
15829 More precisely, when Calc wants to match an optional or repeated
15830 part of a pattern, it scans forward attempting to match that part.
15831 If it reaches the end of the optional part without failing, it
15832 ``finalizes'' its choice and proceeds. If it fails, though, it
15833 backs up and tries the other alternative. Thus Calc has ``partial''
15834 backtracking. A fully backtracking parser would go on to make sure
15835 the rest of the pattern matched before finalizing the choice.
15837 @node Conditional Syntax Rules, , Advanced Syntax Patterns, Syntax Tables
15838 @subsubsection Conditional Syntax Rules
15841 It is possible to attach a @dfn{condition} to a syntax rule. For
15845 foo ( # ) := ifoo(#1) :: integer(#1)
15846 foo ( # ) := gfoo(#1)
15850 will parse @samp{foo(3)} as @samp{ifoo(3)}, but will parse
15851 @samp{foo(3.5)} and @samp{foo(x)} as calls to @code{gfoo}. Any
15852 number of conditions may be attached; all must be true for the
15853 rule to succeed. A condition is ``true'' if it evaluates to a
15854 nonzero number. @xref{Logical Operations}, for a list of Calc
15855 functions like @code{integer} that perform logical tests.
15857 The exact sequence of events is as follows: When Calc tries a
15858 rule, it first matches the pattern as usual. It then substitutes
15859 @samp{#1}, @samp{#2}, etc., in the conditions, if any. Next, the
15860 conditions are simplified and evaluated in order from left to right,
15861 as if by the @w{@kbd{a s}} algebra command (@pxref{Simplifying Formulas}).
15862 Each result is true if it is a nonzero number, or an expression
15863 that can be proven to be nonzero (@pxref{Declarations}). If the
15864 results of all conditions are true, the expression (such as
15865 @samp{ifoo(#1)}) has its @samp{#}s substituted, and that is the
15866 result of the parse. If the result of any condition is false, Calc
15867 goes on to try the next rule in the syntax table.
15869 Syntax rules also support @code{let} conditions, which operate in
15870 exactly the same way as they do in algebraic rewrite rules.
15871 @xref{Other Features of Rewrite Rules}, for details. A @code{let}
15872 condition is always true, but as a side effect it defines a
15873 variable which can be used in later conditions, and also in the
15874 expression after the @samp{:=} sign:
15877 foo ( # ) := hifoo(x) :: let(x := #1 + 0.5) :: dnumint(x)
15881 The @code{dnumint} function tests if a value is numerically an
15882 integer, i.e., either a true integer or an integer-valued float.
15883 This rule will parse @code{foo} with a half-integer argument,
15884 like @samp{foo(3.5)}, to a call like @samp{hifoo(4.)}.
15886 The lefthand side of a syntax rule @code{let} must be a simple
15887 variable, not the arbitrary pattern that is allowed in rewrite
15890 The @code{matches} function is also treated specially in syntax
15891 rule conditions (again, in the same way as in rewrite rules).
15892 @xref{Matching Commands}. If the matching pattern contains
15893 meta-variables, then those meta-variables may be used in later
15894 conditions and in the result expression. The arguments to
15895 @code{matches} are not evaluated in this situation.
15898 sum ( # , # ) := sum(#1,a,b,c) :: matches(#2, a=[b..c])
15902 This is another way to implement the Maple mode @code{sum} notation.
15903 In this approach, we allow @samp{#2} to equal the whole expression
15904 @samp{i=1..10}. Then, we use @code{matches} to break it apart into
15905 its components. If the expression turns out not to match the pattern,
15906 the syntax rule will fail. Note that @kbd{Z S} always uses Calc's
15907 Normal language mode for editing expressions in syntax rules, so we
15908 must use regular Calc notation for the interval @samp{[b..c]} that
15909 will correspond to the Maple mode interval @samp{1..10}.
15911 @node Modes Variable, Calc Mode Line, Language Modes, Mode Settings
15912 @section The @code{Modes} Variable
15916 @pindex calc-get-modes
15917 The @kbd{m g} (@code{calc-get-modes}) command pushes onto the stack
15918 a vector of numbers that describes the various mode settings that
15919 are in effect. With a numeric prefix argument, it pushes only the
15920 @var{n}th mode, i.e., the @var{n}th element of this vector. Keyboard
15921 macros can use the @kbd{m g} command to modify their behavior based
15922 on the current mode settings.
15924 @cindex @code{Modes} variable
15926 The modes vector is also available in the special variable
15927 @code{Modes}. In other words, @kbd{m g} is like @kbd{s r Modes @key{RET}}.
15928 It will not work to store into this variable; in fact, if you do,
15929 @code{Modes} will cease to track the current modes. (The @kbd{m g}
15930 command will continue to work, however.)
15932 In general, each number in this vector is suitable as a numeric
15933 prefix argument to the associated mode-setting command. (Recall
15934 that the @kbd{~} key takes a number from the stack and gives it as
15935 a numeric prefix to the next command.)
15937 The elements of the modes vector are as follows:
15941 Current precision. Default is 12; associated command is @kbd{p}.
15944 Binary word size. Default is 32; associated command is @kbd{b w}.
15947 Stack size (not counting the value about to be pushed by @kbd{m g}).
15948 This is zero if @kbd{m g} is executed with an empty stack.
15951 Number radix. Default is 10; command is @kbd{d r}.
15954 Floating-point format. This is the number of digits, plus the
15955 constant 0 for normal notation, 10000 for scientific notation,
15956 20000 for engineering notation, or 30000 for fixed-point notation.
15957 These codes are acceptable as prefix arguments to the @kbd{d n}
15958 command, but note that this may lose information: For example,
15959 @kbd{d s} and @kbd{C-u 12 d s} have similar (but not quite
15960 identical) effects if the current precision is 12, but they both
15961 produce a code of 10012, which will be treated by @kbd{d n} as
15962 @kbd{C-u 12 d s}. If the precision then changes, the float format
15963 will still be frozen at 12 significant figures.
15966 Angular mode. Default is 1 (degrees). Other values are 2 (radians)
15967 and 3 (HMS). The @kbd{m d} command accepts these prefixes.
15970 Symbolic mode. Value is 0 or 1; default is 0. Command is @kbd{m s}.
15973 Fraction mode. Value is 0 or 1; default is 0. Command is @kbd{m f}.
15976 Polar mode. Value is 0 (rectangular) or 1 (polar); default is 0.
15977 Command is @kbd{m p}.
15980 Matrix/Scalar mode. Default value is @mathit{-1}. Value is 0 for Scalar
15981 mode, @mathit{-2} for Matrix mode, or @var{N} for
15982 @texline @math{N\times N}
15983 @infoline @var{N}x@var{N}
15984 Matrix mode. Command is @kbd{m v}.
15987 Simplification mode. Default is 1. Value is @mathit{-1} for off (@kbd{m O}),
15988 0 for @kbd{m N}, 2 for @kbd{m B}, 3 for @kbd{m A}, 4 for @kbd{m E},
15989 or 5 for @w{@kbd{m U}}. The @kbd{m D} command accepts these prefixes.
15992 Infinite mode. Default is @mathit{-1} (off). Value is 1 if the mode is on,
15993 or 0 if the mode is on with positive zeros. Command is @kbd{m i}.
15996 For example, the sequence @kbd{M-1 m g @key{RET} 2 + ~ p} increases the
15997 precision by two, leaving a copy of the old precision on the stack.
15998 Later, @kbd{~ p} will restore the original precision using that
15999 stack value. (This sequence might be especially useful inside a
16002 As another example, @kbd{M-3 m g 1 - ~ @key{DEL}} deletes all but the
16003 oldest (bottommost) stack entry.
16005 Yet another example: The HP-48 ``round'' command rounds a number
16006 to the current displayed precision. You could roughly emulate this
16007 in Calc with the sequence @kbd{M-5 m g 10000 % ~ c c}. (This
16008 would not work for fixed-point mode, but it wouldn't be hard to
16009 do a full emulation with the help of the @kbd{Z [} and @kbd{Z ]}
16010 programming commands. @xref{Conditionals in Macros}.)
16012 @node Calc Mode Line, , Modes Variable, Mode Settings
16013 @section The Calc Mode Line
16016 @cindex Mode line indicators
16017 This section is a summary of all symbols that can appear on the
16018 Calc mode line, the highlighted bar that appears under the Calc
16019 stack window (or under an editing window in Embedded mode).
16021 The basic mode line format is:
16024 --%%-Calc: 12 Deg @var{other modes} (Calculator)
16027 The @samp{%%} is the Emacs symbol for ``read-only''; it shows that
16028 regular Emacs commands are not allowed to edit the stack buffer
16029 as if it were text.
16031 The word @samp{Calc:} changes to @samp{CalcEmbed:} if Embedded mode
16032 is enabled. The words after this describe the various Calc modes
16033 that are in effect.
16035 The first mode is always the current precision, an integer.
16036 The second mode is always the angular mode, either @code{Deg},
16037 @code{Rad}, or @code{Hms}.
16039 Here is a complete list of the remaining symbols that can appear
16044 Algebraic mode (@kbd{m a}; @pxref{Algebraic Entry}).
16047 Incomplete algebraic mode (@kbd{C-u m a}).
16050 Total algebraic mode (@kbd{m t}).
16053 Symbolic mode (@kbd{m s}; @pxref{Symbolic Mode}).
16056 Matrix mode (@kbd{m v}; @pxref{Matrix Mode}).
16058 @item Matrix@var{n}
16059 Dimensioned Matrix mode (@kbd{C-u @var{n} m v}).
16062 Scalar mode (@kbd{m v}; @pxref{Matrix Mode}).
16065 Polar complex mode (@kbd{m p}; @pxref{Polar Mode}).
16068 Fraction mode (@kbd{m f}; @pxref{Fraction Mode}).
16071 Infinite mode (@kbd{m i}; @pxref{Infinite Mode}).
16074 Positive Infinite mode (@kbd{C-u 0 m i}).
16077 Default simplifications off (@kbd{m O}; @pxref{Simplification Modes}).
16080 Default simplifications for numeric arguments only (@kbd{m N}).
16082 @item BinSimp@var{w}
16083 Binary-integer simplification mode; word size @var{w} (@kbd{m B}, @kbd{b w}).
16086 Algebraic simplification mode (@kbd{m A}).
16089 Extended algebraic simplification mode (@kbd{m E}).
16092 Units simplification mode (@kbd{m U}).
16095 Current radix is 2 (@kbd{d 2}; @pxref{Radix Modes}).
16098 Current radix is 8 (@kbd{d 8}).
16101 Current radix is 16 (@kbd{d 6}).
16104 Current radix is @var{n} (@kbd{d r}).
16107 Leading zeros (@kbd{d z}; @pxref{Radix Modes}).
16110 Big language mode (@kbd{d B}; @pxref{Normal Language Modes}).
16113 One-line normal language mode (@kbd{d O}).
16116 Unformatted language mode (@kbd{d U}).
16119 C language mode (@kbd{d C}; @pxref{C FORTRAN Pascal}).
16122 Pascal language mode (@kbd{d P}).
16125 FORTRAN language mode (@kbd{d F}).
16128 @TeX{} language mode (@kbd{d T}; @pxref{TeX and LaTeX Language Modes}).
16131 La@TeX{} language mode (@kbd{d L}; @pxref{TeX and LaTeX Language Modes}).
16134 @dfn{Eqn} language mode (@kbd{d E}; @pxref{Eqn Language Mode}).
16137 Mathematica language mode (@kbd{d M}; @pxref{Mathematica Language Mode}).
16140 Maple language mode (@kbd{d W}; @pxref{Maple Language Mode}).
16143 Normal float mode with @var{n} digits (@kbd{d n}; @pxref{Float Formats}).
16146 Fixed point mode with @var{n} digits after the point (@kbd{d f}).
16149 Scientific notation mode (@kbd{d s}).
16152 Scientific notation with @var{n} digits (@kbd{d s}).
16155 Engineering notation mode (@kbd{d e}).
16158 Engineering notation with @var{n} digits (@kbd{d e}).
16161 Left-justified display indented by @var{n} (@kbd{d <}; @pxref{Justification}).
16164 Right-justified display (@kbd{d >}).
16167 Right-justified display with width @var{n} (@kbd{d >}).
16170 Centered display (@kbd{d =}).
16172 @item Center@var{n}
16173 Centered display with center column @var{n} (@kbd{d =}).
16176 Line breaking with width @var{n} (@kbd{d b}; @pxref{Normal Language Modes}).
16179 No line breaking (@kbd{d b}).
16182 Selections show deep structure (@kbd{j b}; @pxref{Making Selections}).
16185 Record modes in @file{~/.calc.el} (@kbd{m R}; @pxref{General Mode Commands}).
16188 Record modes in Embedded buffer (@kbd{m R}).
16191 Record modes as editing-only in Embedded buffer (@kbd{m R}).
16194 Record modes as permanent-only in Embedded buffer (@kbd{m R}).
16197 Record modes as global in Embedded buffer (@kbd{m R}).
16200 Automatic recomputation turned off (@kbd{m C}; @pxref{Automatic
16204 GNUPLOT process is alive in background (@pxref{Graphics}).
16207 Top-of-stack has a selection (Embedded only; @pxref{Making Selections}).
16210 The stack display may not be up-to-date (@pxref{Display Modes}).
16213 ``Inverse'' prefix was pressed (@kbd{I}; @pxref{Inverse and Hyperbolic}).
16216 ``Hyperbolic'' prefix was pressed (@kbd{H}).
16219 ``Keep-arguments'' prefix was pressed (@kbd{K}).
16222 Stack is truncated (@kbd{d t}; @pxref{Truncating the Stack}).
16225 In addition, the symbols @code{Active} and @code{~Active} can appear
16226 as minor modes on an Embedded buffer's mode line. @xref{Embedded Mode}.
16228 @node Arithmetic, Scientific Functions, Mode Settings, Top
16229 @chapter Arithmetic Functions
16232 This chapter describes the Calc commands for doing simple calculations
16233 on numbers, such as addition, absolute value, and square roots. These
16234 commands work by removing the top one or two values from the stack,
16235 performing the desired operation, and pushing the result back onto the
16236 stack. If the operation cannot be performed, the result pushed is a
16237 formula instead of a number, such as @samp{2/0} (because division by zero
16238 is invalid) or @samp{sqrt(x)} (because the argument @samp{x} is a formula).
16240 Most of the commands described here can be invoked by a single keystroke.
16241 Some of the more obscure ones are two-letter sequences beginning with
16242 the @kbd{f} (``functions'') prefix key.
16244 @xref{Prefix Arguments}, for a discussion of the effect of numeric
16245 prefix arguments on commands in this chapter which do not otherwise
16246 interpret a prefix argument.
16249 * Basic Arithmetic::
16250 * Integer Truncation::
16251 * Complex Number Functions::
16253 * Date Arithmetic::
16254 * Financial Functions::
16255 * Binary Functions::
16258 @node Basic Arithmetic, Integer Truncation, Arithmetic, Arithmetic
16259 @section Basic Arithmetic
16268 The @kbd{+} (@code{calc-plus}) command adds two numbers. The numbers may
16269 be any of the standard Calc data types. The resulting sum is pushed back
16272 If both arguments of @kbd{+} are vectors or matrices (of matching dimensions),
16273 the result is a vector or matrix sum. If one argument is a vector and the
16274 other a scalar (i.e., a non-vector), the scalar is added to each of the
16275 elements of the vector to form a new vector. If the scalar is not a
16276 number, the operation is left in symbolic form: Suppose you added @samp{x}
16277 to the vector @samp{[1,2]}. You may want the result @samp{[1+x,2+x]}, or
16278 you may plan to substitute a 2-vector for @samp{x} in the future. Since
16279 the Calculator can't tell which interpretation you want, it makes the
16280 safest assumption. @xref{Reducing and Mapping}, for a way to add @samp{x}
16281 to every element of a vector.
16283 If either argument of @kbd{+} is a complex number, the result will in general
16284 be complex. If one argument is in rectangular form and the other polar,
16285 the current Polar mode determines the form of the result. If Symbolic
16286 mode is enabled, the sum may be left as a formula if the necessary
16287 conversions for polar addition are non-trivial.
16289 If both arguments of @kbd{+} are HMS forms, the forms are added according to
16290 the usual conventions of hours-minutes-seconds notation. If one argument
16291 is an HMS form and the other is a number, that number is converted from
16292 degrees or radians (depending on the current Angular mode) to HMS format
16293 and then the two HMS forms are added.
16295 If one argument of @kbd{+} is a date form, the other can be either a
16296 real number, which advances the date by a certain number of days, or
16297 an HMS form, which advances the date by a certain amount of time.
16298 Subtracting two date forms yields the number of days between them.
16299 Adding two date forms is meaningless, but Calc interprets it as the
16300 subtraction of one date form and the negative of the other. (The
16301 negative of a date form can be understood by remembering that dates
16302 are stored as the number of days before or after Jan 1, 1 AD.)
16304 If both arguments of @kbd{+} are error forms, the result is an error form
16305 with an appropriately computed standard deviation. If one argument is an
16306 error form and the other is a number, the number is taken to have zero error.
16307 Error forms may have symbolic formulas as their mean and/or error parts;
16308 adding these will produce a symbolic error form result. However, adding an
16309 error form to a plain symbolic formula (as in @samp{(a +/- b) + c}) will not
16310 work, for the same reasons just mentioned for vectors. Instead you must
16311 write @samp{(a +/- b) + (c +/- 0)}.
16313 If both arguments of @kbd{+} are modulo forms with equal values of @expr{M},
16314 or if one argument is a modulo form and the other a plain number, the
16315 result is a modulo form which represents the sum, modulo @expr{M}, of
16318 If both arguments of @kbd{+} are intervals, the result is an interval
16319 which describes all possible sums of the possible input values. If
16320 one argument is a plain number, it is treated as the interval
16321 @w{@samp{[x ..@: x]}}.
16323 If one argument of @kbd{+} is an infinity and the other is not, the
16324 result is that same infinity. If both arguments are infinite and in
16325 the same direction, the result is the same infinity, but if they are
16326 infinite in different directions the result is @code{nan}.
16334 The @kbd{-} (@code{calc-minus}) command subtracts two values. The top
16335 number on the stack is subtracted from the one behind it, so that the
16336 computation @kbd{5 @key{RET} 2 -} produces 3, not @mathit{-3}. All options
16337 available for @kbd{+} are available for @kbd{-} as well.
16345 The @kbd{*} (@code{calc-times}) command multiplies two numbers. If one
16346 argument is a vector and the other a scalar, the scalar is multiplied by
16347 the elements of the vector to produce a new vector. If both arguments
16348 are vectors, the interpretation depends on the dimensions of the
16349 vectors: If both arguments are matrices, a matrix multiplication is
16350 done. If one argument is a matrix and the other a plain vector, the
16351 vector is interpreted as a row vector or column vector, whichever is
16352 dimensionally correct. If both arguments are plain vectors, the result
16353 is a single scalar number which is the dot product of the two vectors.
16355 If one argument of @kbd{*} is an HMS form and the other a number, the
16356 HMS form is multiplied by that amount. It is an error to multiply two
16357 HMS forms together, or to attempt any multiplication involving date
16358 forms. Error forms, modulo forms, and intervals can be multiplied;
16359 see the comments for addition of those forms. When two error forms
16360 or intervals are multiplied they are considered to be statistically
16361 independent; thus, @samp{[-2 ..@: 3] * [-2 ..@: 3]} is @samp{[-6 ..@: 9]},
16362 whereas @w{@samp{[-2 ..@: 3] ^ 2}} is @samp{[0 ..@: 9]}.
16365 @pindex calc-divide
16370 The @kbd{/} (@code{calc-divide}) command divides two numbers. When
16371 dividing a scalar @expr{B} by a square matrix @expr{A}, the computation
16372 performed is @expr{B} times the inverse of @expr{A}. This also occurs
16373 if @expr{B} is itself a vector or matrix, in which case the effect is
16374 to solve the set of linear equations represented by @expr{B}. If @expr{B}
16375 is a matrix with the same number of rows as @expr{A}, or a plain vector
16376 (which is interpreted here as a column vector), then the equation
16377 @expr{A X = B} is solved for the vector or matrix @expr{X}. Otherwise,
16378 if @expr{B} is a non-square matrix with the same number of @emph{columns}
16379 as @expr{A}, the equation @expr{X A = B} is solved. If you wish a vector
16380 @expr{B} to be interpreted as a row vector to be solved as @expr{X A = B},
16381 make it into a one-row matrix with @kbd{C-u 1 v p} first. To force a
16382 left-handed solution with a square matrix @expr{B}, transpose @expr{A} and
16383 @expr{B} before dividing, then transpose the result.
16385 HMS forms can be divided by real numbers or by other HMS forms. Error
16386 forms can be divided in any combination of ways. Modulo forms where both
16387 values and the modulo are integers can be divided to get an integer modulo
16388 form result. Intervals can be divided; dividing by an interval that
16389 encompasses zero or has zero as a limit will result in an infinite
16398 The @kbd{^} (@code{calc-power}) command raises a number to a power. If
16399 the power is an integer, an exact result is computed using repeated
16400 multiplications. For non-integer powers, Calc uses Newton's method or
16401 logarithms and exponentials. Square matrices can be raised to integer
16402 powers. If either argument is an error (or interval or modulo) form,
16403 the result is also an error (or interval or modulo) form.
16407 If you press the @kbd{I} (inverse) key first, the @kbd{I ^} command
16408 computes an Nth root: @kbd{125 @key{RET} 3 I ^} computes the number 5.
16409 (This is entirely equivalent to @kbd{125 @key{RET} 1:3 ^}.)
16418 The @kbd{\} (@code{calc-idiv}) command divides two numbers on the stack
16419 to produce an integer result. It is equivalent to dividing with
16420 @key{/}, then rounding down with @kbd{F} (@code{calc-floor}), only a bit
16421 more convenient and efficient. Also, since it is an all-integer
16422 operation when the arguments are integers, it avoids problems that
16423 @kbd{/ F} would have with floating-point roundoff.
16431 The @kbd{%} (@code{calc-mod}) command performs a ``modulo'' (or ``remainder'')
16432 operation. Mathematically, @samp{a%b = a - (a\b)*b}, and is defined
16433 for all real numbers @expr{a} and @expr{b} (except @expr{b=0}). For
16434 positive @expr{b}, the result will always be between 0 (inclusive) and
16435 @expr{b} (exclusive). Modulo does not work for HMS forms and error forms.
16436 If @expr{a} is a modulo form, its modulo is changed to @expr{b}, which
16437 must be positive real number.
16442 The @kbd{:} (@code{calc-fdiv}) [@code{fdiv}] command
16443 divides the two integers on the top of the stack to produce a fractional
16444 result. This is a convenient shorthand for enabling Fraction mode (with
16445 @kbd{m f}) temporarily and using @samp{/}. Note that during numeric entry
16446 the @kbd{:} key is interpreted as a fraction separator, so to divide 8 by 6
16447 you would have to type @kbd{8 @key{RET} 6 @key{RET} :}. (Of course, in
16448 this case, it would be much easier simply to enter the fraction directly
16449 as @kbd{8:6 @key{RET}}!)
16452 @pindex calc-change-sign
16453 The @kbd{n} (@code{calc-change-sign}) command negates the number on the top
16454 of the stack. It works on numbers, vectors and matrices, HMS forms, date
16455 forms, error forms, intervals, and modulo forms.
16460 The @kbd{A} (@code{calc-abs}) [@code{abs}] command computes the absolute
16461 value of a number. The result of @code{abs} is always a nonnegative
16462 real number: With a complex argument, it computes the complex magnitude.
16463 With a vector or matrix argument, it computes the Frobenius norm, i.e.,
16464 the square root of the sum of the squares of the absolute values of the
16465 elements. The absolute value of an error form is defined by replacing
16466 the mean part with its absolute value and leaving the error part the same.
16467 The absolute value of a modulo form is undefined. The absolute value of
16468 an interval is defined in the obvious way.
16471 @pindex calc-abssqr
16473 The @kbd{f A} (@code{calc-abssqr}) [@code{abssqr}] command computes the
16474 absolute value squared of a number, vector or matrix, or error form.
16479 The @kbd{f s} (@code{calc-sign}) [@code{sign}] command returns 1 if its
16480 argument is positive, @mathit{-1} if its argument is negative, or 0 if its
16481 argument is zero. In algebraic form, you can also write @samp{sign(a,x)}
16482 which evaluates to @samp{x * sign(a)}, i.e., either @samp{x}, @samp{-x}, or
16483 zero depending on the sign of @samp{a}.
16489 The @kbd{&} (@code{calc-inv}) [@code{inv}] command computes the
16490 reciprocal of a number, i.e., @expr{1 / x}. Operating on a square
16491 matrix, it computes the inverse of that matrix.
16496 The @kbd{Q} (@code{calc-sqrt}) [@code{sqrt}] command computes the square
16497 root of a number. For a negative real argument, the result will be a
16498 complex number whose form is determined by the current Polar mode.
16503 The @kbd{f h} (@code{calc-hypot}) [@code{hypot}] command computes the square
16504 root of the sum of the squares of two numbers. That is, @samp{hypot(a,b)}
16505 is the length of the hypotenuse of a right triangle with sides @expr{a}
16506 and @expr{b}. If the arguments are complex numbers, their squared
16507 magnitudes are used.
16512 The @kbd{f Q} (@code{calc-isqrt}) [@code{isqrt}] command computes the
16513 integer square root of an integer. This is the true square root of the
16514 number, rounded down to an integer. For example, @samp{isqrt(10)}
16515 produces 3. Note that, like @kbd{\} [@code{idiv}], this uses exact
16516 integer arithmetic throughout to avoid roundoff problems. If the input
16517 is a floating-point number or other non-integer value, this is exactly
16518 the same as @samp{floor(sqrt(x))}.
16526 The @kbd{f n} (@code{calc-min}) [@code{min}] and @kbd{f x} (@code{calc-max})
16527 [@code{max}] commands take the minimum or maximum of two real numbers,
16528 respectively. These commands also work on HMS forms, date forms,
16529 intervals, and infinities. (In algebraic expressions, these functions
16530 take any number of arguments and return the maximum or minimum among
16531 all the arguments.)
16535 @pindex calc-mant-part
16537 @pindex calc-xpon-part
16539 The @kbd{f M} (@code{calc-mant-part}) [@code{mant}] function extracts
16540 the ``mantissa'' part @expr{m} of its floating-point argument; @kbd{f X}
16541 (@code{calc-xpon-part}) [@code{xpon}] extracts the ``exponent'' part
16542 @expr{e}. The original number is equal to
16543 @texline @math{m \times 10^e},
16544 @infoline @expr{m * 10^e},
16545 where @expr{m} is in the interval @samp{[1.0 ..@: 10.0)} except that
16546 @expr{m=e=0} if the original number is zero. For integers
16547 and fractions, @code{mant} returns the number unchanged and @code{xpon}
16548 returns zero. The @kbd{v u} (@code{calc-unpack}) command can also be
16549 used to ``unpack'' a floating-point number; this produces an integer
16550 mantissa and exponent, with the constraint that the mantissa is not
16551 a multiple of ten (again except for the @expr{m=e=0} case).
16554 @pindex calc-scale-float
16556 The @kbd{f S} (@code{calc-scale-float}) [@code{scf}] function scales a number
16557 by a given power of ten. Thus, @samp{scf(mant(x), xpon(x)) = x} for any
16558 real @samp{x}. The second argument must be an integer, but the first
16559 may actually be any numeric value. For example, @samp{scf(5,-2) = 0.05}
16560 or @samp{1:20} depending on the current Fraction mode.
16564 @pindex calc-decrement
16565 @pindex calc-increment
16568 The @kbd{f [} (@code{calc-decrement}) [@code{decr}] and @kbd{f ]}
16569 (@code{calc-increment}) [@code{incr}] functions decrease or increase
16570 a number by one unit. For integers, the effect is obvious. For
16571 floating-point numbers, the change is by one unit in the last place.
16572 For example, incrementing @samp{12.3456} when the current precision
16573 is 6 digits yields @samp{12.3457}. If the current precision had been
16574 8 digits, the result would have been @samp{12.345601}. Incrementing
16575 @samp{0.0} produces
16576 @texline @math{10^{-p}},
16577 @infoline @expr{10^-p},
16578 where @expr{p} is the current
16579 precision. These operations are defined only on integers and floats.
16580 With numeric prefix arguments, they change the number by @expr{n} units.
16582 Note that incrementing followed by decrementing, or vice-versa, will
16583 almost but not quite always cancel out. Suppose the precision is
16584 6 digits and the number @samp{9.99999} is on the stack. Incrementing
16585 will produce @samp{10.0000}; decrementing will produce @samp{9.9999}.
16586 One digit has been dropped. This is an unavoidable consequence of the
16587 way floating-point numbers work.
16589 Incrementing a date/time form adjusts it by a certain number of seconds.
16590 Incrementing a pure date form adjusts it by a certain number of days.
16592 @node Integer Truncation, Complex Number Functions, Basic Arithmetic, Arithmetic
16593 @section Integer Truncation
16596 There are four commands for truncating a real number to an integer,
16597 differing mainly in their treatment of negative numbers. All of these
16598 commands have the property that if the argument is an integer, the result
16599 is the same integer. An integer-valued floating-point argument is converted
16602 If you press @kbd{H} (@code{calc-hyperbolic}) first, the result will be
16603 expressed as an integer-valued floating-point number.
16605 @cindex Integer part of a number
16614 The @kbd{F} (@code{calc-floor}) [@code{floor} or @code{ffloor}] command
16615 truncates a real number to the next lower integer, i.e., toward minus
16616 infinity. Thus @kbd{3.6 F} produces 3, but @kbd{_3.6 F} produces
16620 @pindex calc-ceiling
16627 The @kbd{I F} (@code{calc-ceiling}) [@code{ceil} or @code{fceil}]
16628 command truncates toward positive infinity. Thus @kbd{3.6 I F} produces
16629 4, and @kbd{_3.6 I F} produces @mathit{-3}.
16639 The @kbd{R} (@code{calc-round}) [@code{round} or @code{fround}] command
16640 rounds to the nearest integer. When the fractional part is .5 exactly,
16641 this command rounds away from zero. (All other rounding in the
16642 Calculator uses this convention as well.) Thus @kbd{3.5 R} produces 4
16643 but @kbd{3.4 R} produces 3; @kbd{_3.5 R} produces @mathit{-4}.
16653 The @kbd{I R} (@code{calc-trunc}) [@code{trunc} or @code{ftrunc}]
16654 command truncates toward zero. In other words, it ``chops off''
16655 everything after the decimal point. Thus @kbd{3.6 I R} produces 3 and
16656 @kbd{_3.6 I R} produces @mathit{-3}.
16658 These functions may not be applied meaningfully to error forms, but they
16659 do work for intervals. As a convenience, applying @code{floor} to a
16660 modulo form floors the value part of the form. Applied to a vector,
16661 these functions operate on all elements of the vector one by one.
16662 Applied to a date form, they operate on the internal numerical
16663 representation of dates, converting a date/time form into a pure date.
16681 There are two more rounding functions which can only be entered in
16682 algebraic notation. The @code{roundu} function is like @code{round}
16683 except that it rounds up, toward plus infinity, when the fractional
16684 part is .5. This distinction matters only for negative arguments.
16685 Also, @code{rounde} rounds to an even number in the case of a tie,
16686 rounding up or down as necessary. For example, @samp{rounde(3.5)} and
16687 @samp{rounde(4.5)} both return 4, but @samp{rounde(5.5)} returns 6.
16688 The advantage of round-to-even is that the net error due to rounding
16689 after a long calculation tends to cancel out to zero. An important
16690 subtle point here is that the number being fed to @code{rounde} will
16691 already have been rounded to the current precision before @code{rounde}
16692 begins. For example, @samp{rounde(2.500001)} with a current precision
16693 of 6 will incorrectly, or at least surprisingly, yield 2 because the
16694 argument will first have been rounded down to @expr{2.5} (which
16695 @code{rounde} sees as an exact tie between 2 and 3).
16697 Each of these functions, when written in algebraic formulas, allows
16698 a second argument which specifies the number of digits after the
16699 decimal point to keep. For example, @samp{round(123.4567, 2)} will
16700 produce the answer 123.46, and @samp{round(123.4567, -1)} will
16701 produce 120 (i.e., the cutoff is one digit to the @emph{left} of
16702 the decimal point). A second argument of zero is equivalent to
16703 no second argument at all.
16705 @cindex Fractional part of a number
16706 To compute the fractional part of a number (i.e., the amount which, when
16707 added to `@tfn{floor(}@var{n}@tfn{)}', will produce @var{n}) just take @var{n}
16708 modulo 1 using the @code{%} command.
16710 Note also the @kbd{\} (integer quotient), @kbd{f I} (integer logarithm),
16711 and @kbd{f Q} (integer square root) commands, which are analogous to
16712 @kbd{/}, @kbd{B}, and @kbd{Q}, respectively, except that they take integer
16713 arguments and return the result rounded down to an integer.
16715 @node Complex Number Functions, Conversions, Integer Truncation, Arithmetic
16716 @section Complex Number Functions
16722 The @kbd{J} (@code{calc-conj}) [@code{conj}] command computes the
16723 complex conjugate of a number. For complex number @expr{a+bi}, the
16724 complex conjugate is @expr{a-bi}. If the argument is a real number,
16725 this command leaves it the same. If the argument is a vector or matrix,
16726 this command replaces each element by its complex conjugate.
16729 @pindex calc-argument
16731 The @kbd{G} (@code{calc-argument}) [@code{arg}] command computes the
16732 ``argument'' or polar angle of a complex number. For a number in polar
16733 notation, this is simply the second component of the pair
16734 @texline `@tfn{(}@var{r}@tfn{;}@math{\theta}@tfn{)}'.
16735 @infoline `@tfn{(}@var{r}@tfn{;}@var{theta}@tfn{)}'.
16736 The result is expressed according to the current angular mode and will
16737 be in the range @mathit{-180} degrees (exclusive) to @mathit{+180} degrees
16738 (inclusive), or the equivalent range in radians.
16740 @pindex calc-imaginary
16741 The @code{calc-imaginary} command multiplies the number on the
16742 top of the stack by the imaginary number @expr{i = (0,1)}. This
16743 command is not normally bound to a key in Calc, but it is available
16744 on the @key{IMAG} button in Keypad mode.
16749 The @kbd{f r} (@code{calc-re}) [@code{re}] command replaces a complex number
16750 by its real part. This command has no effect on real numbers. (As an
16751 added convenience, @code{re} applied to a modulo form extracts
16757 The @kbd{f i} (@code{calc-im}) [@code{im}] command replaces a complex number
16758 by its imaginary part; real numbers are converted to zero. With a vector
16759 or matrix argument, these functions operate element-wise.
16764 @kindex v p (complex)
16766 The @kbd{v p} (@code{calc-pack}) command can pack the top two numbers on
16767 the stack into a composite object such as a complex number. With
16768 a prefix argument of @mathit{-1}, it produces a rectangular complex number;
16769 with an argument of @mathit{-2}, it produces a polar complex number.
16770 (Also, @pxref{Building Vectors}.)
16775 @kindex v u (complex)
16776 @pindex calc-unpack
16777 The @kbd{v u} (@code{calc-unpack}) command takes the complex number
16778 (or other composite object) on the top of the stack and unpacks it
16779 into its separate components.
16781 @node Conversions, Date Arithmetic, Complex Number Functions, Arithmetic
16782 @section Conversions
16785 The commands described in this section convert numbers from one form
16786 to another; they are two-key sequences beginning with the letter @kbd{c}.
16791 The @kbd{c f} (@code{calc-float}) [@code{pfloat}] command converts the
16792 number on the top of the stack to floating-point form. For example,
16793 @expr{23} is converted to @expr{23.0}, @expr{3:2} is converted to
16794 @expr{1.5}, and @expr{2.3} is left the same. If the value is a composite
16795 object such as a complex number or vector, each of the components is
16796 converted to floating-point. If the value is a formula, all numbers
16797 in the formula are converted to floating-point. Note that depending
16798 on the current floating-point precision, conversion to floating-point
16799 format may lose information.
16801 As a special exception, integers which appear as powers or subscripts
16802 are not floated by @kbd{c f}. If you really want to float a power,
16803 you can use a @kbd{j s} command to select the power followed by @kbd{c f}.
16804 Because @kbd{c f} cannot examine the formula outside of the selection,
16805 it does not notice that the thing being floated is a power.
16806 @xref{Selecting Subformulas}.
16808 The normal @kbd{c f} command is ``pervasive'' in the sense that it
16809 applies to all numbers throughout the formula. The @code{pfloat}
16810 algebraic function never stays around in a formula; @samp{pfloat(a + 1)}
16811 changes to @samp{a + 1.0} as soon as it is evaluated.
16815 With the Hyperbolic flag, @kbd{H c f} [@code{float}] operates
16816 only on the number or vector of numbers at the top level of its
16817 argument. Thus, @samp{float(1)} is 1.0, but @samp{float(a + 1)}
16818 is left unevaluated because its argument is not a number.
16820 You should use @kbd{H c f} if you wish to guarantee that the final
16821 value, once all the variables have been assigned, is a float; you
16822 would use @kbd{c f} if you wish to do the conversion on the numbers
16823 that appear right now.
16826 @pindex calc-fraction
16828 The @kbd{c F} (@code{calc-fraction}) [@code{pfrac}] command converts a
16829 floating-point number into a fractional approximation. By default, it
16830 produces a fraction whose decimal representation is the same as the
16831 input number, to within the current precision. You can also give a
16832 numeric prefix argument to specify a tolerance, either directly, or,
16833 if the prefix argument is zero, by using the number on top of the stack
16834 as the tolerance. If the tolerance is a positive integer, the fraction
16835 is correct to within that many significant figures. If the tolerance is
16836 a non-positive integer, it specifies how many digits fewer than the current
16837 precision to use. If the tolerance is a floating-point number, the
16838 fraction is correct to within that absolute amount.
16842 The @code{pfrac} function is pervasive, like @code{pfloat}.
16843 There is also a non-pervasive version, @kbd{H c F} [@code{frac}],
16844 which is analogous to @kbd{H c f} discussed above.
16847 @pindex calc-to-degrees
16849 The @kbd{c d} (@code{calc-to-degrees}) [@code{deg}] command converts a
16850 number into degrees form. The value on the top of the stack may be an
16851 HMS form (interpreted as degrees-minutes-seconds), or a real number which
16852 will be interpreted in radians regardless of the current angular mode.
16855 @pindex calc-to-radians
16857 The @kbd{c r} (@code{calc-to-radians}) [@code{rad}] command converts an
16858 HMS form or angle in degrees into an angle in radians.
16861 @pindex calc-to-hms
16863 The @kbd{c h} (@code{calc-to-hms}) [@code{hms}] command converts a real
16864 number, interpreted according to the current angular mode, to an HMS
16865 form describing the same angle. In algebraic notation, the @code{hms}
16866 function also accepts three arguments: @samp{hms(@var{h}, @var{m}, @var{s})}.
16867 (The three-argument version is independent of the current angular mode.)
16869 @pindex calc-from-hms
16870 The @code{calc-from-hms} command converts the HMS form on the top of the
16871 stack into a real number according to the current angular mode.
16878 The @kbd{c p} (@code{calc-polar}) command converts the complex number on
16879 the top of the stack from polar to rectangular form, or from rectangular
16880 to polar form, whichever is appropriate. Real numbers are left the same.
16881 This command is equivalent to the @code{rect} or @code{polar}
16882 functions in algebraic formulas, depending on the direction of
16883 conversion. (It uses @code{polar}, except that if the argument is
16884 already a polar complex number, it uses @code{rect} instead. The
16885 @kbd{I c p} command always uses @code{rect}.)
16890 The @kbd{c c} (@code{calc-clean}) [@code{pclean}] command ``cleans'' the
16891 number on the top of the stack. Floating point numbers are re-rounded
16892 according to the current precision. Polar numbers whose angular
16893 components have strayed from the @mathit{-180} to @mathit{+180} degree range
16894 are normalized. (Note that results will be undesirable if the current
16895 angular mode is different from the one under which the number was
16896 produced!) Integers and fractions are generally unaffected by this
16897 operation. Vectors and formulas are cleaned by cleaning each component
16898 number (i.e., pervasively).
16900 If the simplification mode is set below the default level, it is raised
16901 to the default level for the purposes of this command. Thus, @kbd{c c}
16902 applies the default simplifications even if their automatic application
16903 is disabled. @xref{Simplification Modes}.
16905 @cindex Roundoff errors, correcting
16906 A numeric prefix argument to @kbd{c c} sets the floating-point precision
16907 to that value for the duration of the command. A positive prefix (of at
16908 least 3) sets the precision to the specified value; a negative or zero
16909 prefix decreases the precision by the specified amount.
16912 @pindex calc-clean-num
16913 The keystroke sequences @kbd{c 0} through @kbd{c 9} are equivalent
16914 to @kbd{c c} with the corresponding negative prefix argument. If roundoff
16915 errors have changed 2.0 into 1.999999, typing @kbd{c 1} to clip off one
16916 decimal place often conveniently does the trick.
16918 The @kbd{c c} command with a numeric prefix argument, and the @kbd{c 0}
16919 through @kbd{c 9} commands, also ``clip'' very small floating-point
16920 numbers to zero. If the exponent is less than or equal to the negative
16921 of the specified precision, the number is changed to 0.0. For example,
16922 if the current precision is 12, then @kbd{c 2} changes the vector
16923 @samp{[1e-8, 1e-9, 1e-10, 1e-11]} to @samp{[1e-8, 1e-9, 0, 0]}.
16924 Numbers this small generally arise from roundoff noise.
16926 If the numbers you are using really are legitimately this small,
16927 you should avoid using the @kbd{c 0} through @kbd{c 9} commands.
16928 (The plain @kbd{c c} command rounds to the current precision but
16929 does not clip small numbers.)
16931 One more property of @kbd{c 0} through @kbd{c 9}, and of @kbd{c c} with
16932 a prefix argument, is that integer-valued floats are converted to
16933 plain integers, so that @kbd{c 1} on @samp{[1., 1.5, 2., 2.5, 3.]}
16934 produces @samp{[1, 1.5, 2, 2.5, 3]}. This is not done for huge
16935 numbers (@samp{1e100} is technically an integer-valued float, but
16936 you wouldn't want it automatically converted to a 100-digit integer).
16941 With the Hyperbolic flag, @kbd{H c c} and @kbd{H c 0} through @kbd{H c 9}
16942 operate non-pervasively [@code{clean}].
16944 @node Date Arithmetic, Financial Functions, Conversions, Arithmetic
16945 @section Date Arithmetic
16948 @cindex Date arithmetic, additional functions
16949 The commands described in this section perform various conversions
16950 and calculations involving date forms (@pxref{Date Forms}). They
16951 use the @kbd{t} (for time/date) prefix key followed by shifted
16954 The simplest date arithmetic is done using the regular @kbd{+} and @kbd{-}
16955 commands. In particular, adding a number to a date form advances the
16956 date form by a certain number of days; adding an HMS form to a date
16957 form advances the date by a certain amount of time; and subtracting two
16958 date forms produces a difference measured in days. The commands
16959 described here provide additional, more specialized operations on dates.
16961 Many of these commands accept a numeric prefix argument; if you give
16962 plain @kbd{C-u} as the prefix, these commands will instead take the
16963 additional argument from the top of the stack.
16966 * Date Conversions::
16972 @node Date Conversions, Date Functions, Date Arithmetic, Date Arithmetic
16973 @subsection Date Conversions
16979 The @kbd{t D} (@code{calc-date}) [@code{date}] command converts a
16980 date form into a number, measured in days since Jan 1, 1 AD. The
16981 result will be an integer if @var{date} is a pure date form, or a
16982 fraction or float if @var{date} is a date/time form. Or, if its
16983 argument is a number, it converts this number into a date form.
16985 With a numeric prefix argument, @kbd{t D} takes that many objects
16986 (up to six) from the top of the stack and interprets them in one
16987 of the following ways:
16989 The @samp{date(@var{year}, @var{month}, @var{day})} function
16990 builds a pure date form out of the specified year, month, and
16991 day, which must all be integers. @var{Year} is a year number,
16992 such as 1991 (@emph{not} the same as 91!). @var{Month} must be
16993 an integer in the range 1 to 12; @var{day} must be in the range
16994 1 to 31. If the specified month has fewer than 31 days and
16995 @var{day} is too large, the equivalent day in the following
16996 month will be used.
16998 The @samp{date(@var{month}, @var{day})} function builds a
16999 pure date form using the current year, as determined by the
17002 The @samp{date(@var{year}, @var{month}, @var{day}, @var{hms})}
17003 function builds a date/time form using an @var{hms} form.
17005 The @samp{date(@var{year}, @var{month}, @var{day}, @var{hour},
17006 @var{minute}, @var{second})} function builds a date/time form.
17007 @var{hour} should be an integer in the range 0 to 23;
17008 @var{minute} should be an integer in the range 0 to 59;
17009 @var{second} should be any real number in the range @samp{[0 .. 60)}.
17010 The last two arguments default to zero if omitted.
17013 @pindex calc-julian
17015 @cindex Julian day counts, conversions
17016 The @kbd{t J} (@code{calc-julian}) [@code{julian}] command converts
17017 a date form into a Julian day count, which is the number of days
17018 since noon on Jan 1, 4713 BC. A pure date is converted to an integer
17019 Julian count representing noon of that day. A date/time form is
17020 converted to an exact floating-point Julian count, adjusted to
17021 interpret the date form in the current time zone but the Julian
17022 day count in Greenwich Mean Time. A numeric prefix argument allows
17023 you to specify the time zone; @pxref{Time Zones}. Use a prefix of
17024 zero to suppress the time zone adjustment. Note that pure date forms
17025 are never time-zone adjusted.
17027 This command can also do the opposite conversion, from a Julian day
17028 count (either an integer day, or a floating-point day and time in
17029 the GMT zone), into a pure date form or a date/time form in the
17030 current or specified time zone.
17033 @pindex calc-unix-time
17035 @cindex Unix time format, conversions
17036 The @kbd{t U} (@code{calc-unix-time}) [@code{unixtime}] command
17037 converts a date form into a Unix time value, which is the number of
17038 seconds since midnight on Jan 1, 1970, or vice-versa. The numeric result
17039 will be an integer if the current precision is 12 or less; for higher
17040 precisions, the result may be a float with (@var{precision}@minus{}12)
17041 digits after the decimal. Just as for @kbd{t J}, the numeric time
17042 is interpreted in the GMT time zone and the date form is interpreted
17043 in the current or specified zone. Some systems use Unix-like
17044 numbering but with the local time zone; give a prefix of zero to
17045 suppress the adjustment if so.
17048 @pindex calc-convert-time-zones
17050 @cindex Time Zones, converting between
17051 The @kbd{t C} (@code{calc-convert-time-zones}) [@code{tzconv}]
17052 command converts a date form from one time zone to another. You
17053 are prompted for each time zone name in turn; you can answer with
17054 any suitable Calc time zone expression (@pxref{Time Zones}).
17055 If you answer either prompt with a blank line, the local time
17056 zone is used for that prompt. You can also answer the first
17057 prompt with @kbd{$} to take the two time zone names from the
17058 stack (and the date to be converted from the third stack level).
17060 @node Date Functions, Business Days, Date Conversions, Date Arithmetic
17061 @subsection Date Functions
17067 The @kbd{t N} (@code{calc-now}) [@code{now}] command pushes the
17068 current date and time on the stack as a date form. The time is
17069 reported in terms of the specified time zone; with no numeric prefix
17070 argument, @kbd{t N} reports for the current time zone.
17073 @pindex calc-date-part
17074 The @kbd{t P} (@code{calc-date-part}) command extracts one part
17075 of a date form. The prefix argument specifies the part; with no
17076 argument, this command prompts for a part code from 1 to 9.
17077 The various part codes are described in the following paragraphs.
17080 The @kbd{M-1 t P} [@code{year}] function extracts the year number
17081 from a date form as an integer, e.g., 1991. This and the
17082 following functions will also accept a real number for an
17083 argument, which is interpreted as a standard Calc day number.
17084 Note that this function will never return zero, since the year
17085 1 BC immediately precedes the year 1 AD.
17088 The @kbd{M-2 t P} [@code{month}] function extracts the month number
17089 from a date form as an integer in the range 1 to 12.
17092 The @kbd{M-3 t P} [@code{day}] function extracts the day number
17093 from a date form as an integer in the range 1 to 31.
17096 The @kbd{M-4 t P} [@code{hour}] function extracts the hour from
17097 a date form as an integer in the range 0 (midnight) to 23. Note
17098 that 24-hour time is always used. This returns zero for a pure
17099 date form. This function (and the following two) also accept
17100 HMS forms as input.
17103 The @kbd{M-5 t P} [@code{minute}] function extracts the minute
17104 from a date form as an integer in the range 0 to 59.
17107 The @kbd{M-6 t P} [@code{second}] function extracts the second
17108 from a date form. If the current precision is 12 or less,
17109 the result is an integer in the range 0 to 59. For higher
17110 precisions, the result may instead be a floating-point number.
17113 The @kbd{M-7 t P} [@code{weekday}] function extracts the weekday
17114 number from a date form as an integer in the range 0 (Sunday)
17118 The @kbd{M-8 t P} [@code{yearday}] function extracts the day-of-year
17119 number from a date form as an integer in the range 1 (January 1)
17120 to 366 (December 31 of a leap year).
17123 The @kbd{M-9 t P} [@code{time}] function extracts the time portion
17124 of a date form as an HMS form. This returns @samp{0@@ 0' 0"}
17125 for a pure date form.
17128 @pindex calc-new-month
17130 The @kbd{t M} (@code{calc-new-month}) [@code{newmonth}] command
17131 computes a new date form that represents the first day of the month
17132 specified by the input date. The result is always a pure date
17133 form; only the year and month numbers of the input are retained.
17134 With a numeric prefix argument @var{n} in the range from 1 to 31,
17135 @kbd{t M} computes the @var{n}th day of the month. (If @var{n}
17136 is greater than the actual number of days in the month, or if
17137 @var{n} is zero, the last day of the month is used.)
17140 @pindex calc-new-year
17142 The @kbd{t Y} (@code{calc-new-year}) [@code{newyear}] command
17143 computes a new pure date form that represents the first day of
17144 the year specified by the input. The month, day, and time
17145 of the input date form are lost. With a numeric prefix argument
17146 @var{n} in the range from 1 to 366, @kbd{t Y} computes the
17147 @var{n}th day of the year (366 is treated as 365 in non-leap
17148 years). A prefix argument of 0 computes the last day of the
17149 year (December 31). A negative prefix argument from @mathit{-1} to
17150 @mathit{-12} computes the first day of the @var{n}th month of the year.
17153 @pindex calc-new-week
17155 The @kbd{t W} (@code{calc-new-week}) [@code{newweek}] command
17156 computes a new pure date form that represents the Sunday on or before
17157 the input date. With a numeric prefix argument, it can be made to
17158 use any day of the week as the starting day; the argument must be in
17159 the range from 0 (Sunday) to 6 (Saturday). This function always
17160 subtracts between 0 and 6 days from the input date.
17162 Here's an example use of @code{newweek}: Find the date of the next
17163 Wednesday after a given date. Using @kbd{M-3 t W} or @samp{newweek(d, 3)}
17164 will give you the @emph{preceding} Wednesday, so @samp{newweek(d+7, 3)}
17165 will give you the following Wednesday. A further look at the definition
17166 of @code{newweek} shows that if the input date is itself a Wednesday,
17167 this formula will return the Wednesday one week in the future. An
17168 exercise for the reader is to modify this formula to yield the same day
17169 if the input is already a Wednesday. Another interesting exercise is
17170 to preserve the time-of-day portion of the input (@code{newweek} resets
17171 the time to midnight; hint:@: how can @code{newweek} be defined in terms
17172 of the @code{weekday} function?).
17178 The @samp{pwday(@var{date})} function (not on any key) computes the
17179 day-of-month number of the Sunday on or before @var{date}. With
17180 two arguments, @samp{pwday(@var{date}, @var{day})} computes the day
17181 number of the Sunday on or before day number @var{day} of the month
17182 specified by @var{date}. The @var{day} must be in the range from
17183 7 to 31; if the day number is greater than the actual number of days
17184 in the month, the true number of days is used instead. Thus
17185 @samp{pwday(@var{date}, 7)} finds the first Sunday of the month, and
17186 @samp{pwday(@var{date}, 31)} finds the last Sunday of the month.
17187 With a third @var{weekday} argument, @code{pwday} can be made to look
17188 for any day of the week instead of Sunday.
17191 @pindex calc-inc-month
17193 The @kbd{t I} (@code{calc-inc-month}) [@code{incmonth}] command
17194 increases a date form by one month, or by an arbitrary number of
17195 months specified by a numeric prefix argument. The time portion,
17196 if any, of the date form stays the same. The day also stays the
17197 same, except that if the new month has fewer days the day
17198 number may be reduced to lie in the valid range. For example,
17199 @samp{incmonth(<Jan 31, 1991>)} produces @samp{<Feb 28, 1991>}.
17200 Because of this, @kbd{t I t I} and @kbd{M-2 t I} do not always give
17201 the same results (@samp{<Mar 28, 1991>} versus @samp{<Mar 31, 1991>}
17208 The @samp{incyear(@var{date}, @var{step})} function increases
17209 a date form by the specified number of years, which may be
17210 any positive or negative integer. Note that @samp{incyear(d, n)}
17211 is equivalent to @w{@samp{incmonth(d, 12*n)}}, but these do not have
17212 simple equivalents in terms of day arithmetic because
17213 months and years have varying lengths. If the @var{step}
17214 argument is omitted, 1 year is assumed. There is no keyboard
17215 command for this function; use @kbd{C-u 12 t I} instead.
17217 There is no @code{newday} function at all because @kbd{F} [@code{floor}]
17218 serves this purpose. Similarly, instead of @code{incday} and
17219 @code{incweek} simply use @expr{d + n} or @expr{d + 7 n}.
17221 @xref{Basic Arithmetic}, for the @kbd{f ]} [@code{incr}] command
17222 which can adjust a date/time form by a certain number of seconds.
17224 @node Business Days, Time Zones, Date Functions, Date Arithmetic
17225 @subsection Business Days
17228 Often time is measured in ``business days'' or ``working days,''
17229 where weekends and holidays are skipped. Calc's normal date
17230 arithmetic functions use calendar days, so that subtracting two
17231 consecutive Mondays will yield a difference of 7 days. By contrast,
17232 subtracting two consecutive Mondays would yield 5 business days
17233 (assuming two-day weekends and the absence of holidays).
17239 @pindex calc-business-days-plus
17240 @pindex calc-business-days-minus
17241 The @kbd{t +} (@code{calc-business-days-plus}) [@code{badd}]
17242 and @kbd{t -} (@code{calc-business-days-minus}) [@code{bsub}]
17243 commands perform arithmetic using business days. For @kbd{t +},
17244 one argument must be a date form and the other must be a real
17245 number (positive or negative). If the number is not an integer,
17246 then a certain amount of time is added as well as a number of
17247 days; for example, adding 0.5 business days to a time in Friday
17248 evening will produce a time in Monday morning. It is also
17249 possible to add an HMS form; adding @samp{12@@ 0' 0"} also adds
17250 half a business day. For @kbd{t -}, the arguments are either a
17251 date form and a number or HMS form, or two date forms, in which
17252 case the result is the number of business days between the two
17255 @cindex @code{Holidays} variable
17257 By default, Calc considers any day that is not a Saturday or
17258 Sunday to be a business day. You can define any number of
17259 additional holidays by editing the variable @code{Holidays}.
17260 (There is an @w{@kbd{s H}} convenience command for editing this
17261 variable.) Initially, @code{Holidays} contains the vector
17262 @samp{[sat, sun]}. Entries in the @code{Holidays} vector may
17263 be any of the following kinds of objects:
17267 Date forms (pure dates, not date/time forms). These specify
17268 particular days which are to be treated as holidays.
17271 Intervals of date forms. These specify a range of days, all of
17272 which are holidays (e.g., Christmas week). @xref{Interval Forms}.
17275 Nested vectors of date forms. Each date form in the vector is
17276 considered to be a holiday.
17279 Any Calc formula which evaluates to one of the above three things.
17280 If the formula involves the variable @expr{y}, it stands for a
17281 yearly repeating holiday; @expr{y} will take on various year
17282 numbers like 1992. For example, @samp{date(y, 12, 25)} specifies
17283 Christmas day, and @samp{newweek(date(y, 11, 7), 4) + 21} specifies
17284 Thanksgiving (which is held on the fourth Thursday of November).
17285 If the formula involves the variable @expr{m}, that variable
17286 takes on month numbers from 1 to 12: @samp{date(y, m, 15)} is
17287 a holiday that takes place on the 15th of every month.
17290 A weekday name, such as @code{sat} or @code{sun}. This is really
17291 a variable whose name is a three-letter, lower-case day name.
17294 An interval of year numbers (integers). This specifies the span of
17295 years over which this holiday list is to be considered valid. Any
17296 business-day arithmetic that goes outside this range will result
17297 in an error message. Use this if you are including an explicit
17298 list of holidays, rather than a formula to generate them, and you
17299 want to make sure you don't accidentally go beyond the last point
17300 where the holidays you entered are complete. If there is no
17301 limiting interval in the @code{Holidays} vector, the default
17302 @samp{[1 .. 2737]} is used. (This is the absolute range of years
17303 for which Calc's business-day algorithms will operate.)
17306 An interval of HMS forms. This specifies the span of hours that
17307 are to be considered one business day. For example, if this
17308 range is @samp{[9@@ 0' 0" .. 17@@ 0' 0"]} (i.e., 9am to 5pm), then
17309 the business day is only eight hours long, so that @kbd{1.5 t +}
17310 on @samp{<4:00pm Fri Dec 13, 1991>} will add one business day and
17311 four business hours to produce @samp{<12:00pm Tue Dec 17, 1991>}.
17312 Likewise, @kbd{t -} will now express differences in time as
17313 fractions of an eight-hour day. Times before 9am will be treated
17314 as 9am by business date arithmetic, and times at or after 5pm will
17315 be treated as 4:59:59pm. If there is no HMS interval in @code{Holidays},
17316 the full 24-hour day @samp{[0@ 0' 0" .. 24@ 0' 0"]} is assumed.
17317 (Regardless of the type of bounds you specify, the interval is
17318 treated as inclusive on the low end and exclusive on the high end,
17319 so that the work day goes from 9am up to, but not including, 5pm.)
17322 If the @code{Holidays} vector is empty, then @kbd{t +} and
17323 @kbd{t -} will act just like @kbd{+} and @kbd{-} because there will
17324 then be no difference between business days and calendar days.
17326 Calc expands the intervals and formulas you give into a complete
17327 list of holidays for internal use. This is done mainly to make
17328 sure it can detect multiple holidays. (For example,
17329 @samp{<Jan 1, 1989>} is both New Year's Day and a Sunday, but
17330 Calc's algorithms take care to count it only once when figuring
17331 the number of holidays between two dates.)
17333 Since the complete list of holidays for all the years from 1 to
17334 2737 would be huge, Calc actually computes only the part of the
17335 list between the smallest and largest years that have been involved
17336 in business-day calculations so far. Normally, you won't have to
17337 worry about this. Keep in mind, however, that if you do one
17338 calculation for 1992, and another for 1792, even if both involve
17339 only a small range of years, Calc will still work out all the
17340 holidays that fall in that 200-year span.
17342 If you add a (positive) number of days to a date form that falls on a
17343 weekend or holiday, the date form is treated as if it were the most
17344 recent business day. (Thus adding one business day to a Friday,
17345 Saturday, or Sunday will all yield the following Monday.) If you
17346 subtract a number of days from a weekend or holiday, the date is
17347 effectively on the following business day. (So subtracting one business
17348 day from Saturday, Sunday, or Monday yields the preceding Friday.) The
17349 difference between two dates one or both of which fall on holidays
17350 equals the number of actual business days between them. These
17351 conventions are consistent in the sense that, if you add @var{n}
17352 business days to any date, the difference between the result and the
17353 original date will come out to @var{n} business days. (It can't be
17354 completely consistent though; a subtraction followed by an addition
17355 might come out a bit differently, since @kbd{t +} is incapable of
17356 producing a date that falls on a weekend or holiday.)
17362 There is a @code{holiday} function, not on any keys, that takes
17363 any date form and returns 1 if that date falls on a weekend or
17364 holiday, as defined in @code{Holidays}, or 0 if the date is a
17367 @node Time Zones, , Business Days, Date Arithmetic
17368 @subsection Time Zones
17372 @cindex Daylight savings time
17373 Time zones and daylight savings time are a complicated business.
17374 The conversions to and from Julian and Unix-style dates automatically
17375 compute the correct time zone and daylight savings adjustment to use,
17376 provided they can figure out this information. This section describes
17377 Calc's time zone adjustment algorithm in detail, in case you want to
17378 do conversions in different time zones or in case Calc's algorithms
17379 can't determine the right correction to use.
17381 Adjustments for time zones and daylight savings time are done by
17382 @kbd{t U}, @kbd{t J}, @kbd{t N}, and @kbd{t C}, but not by any other
17383 commands. In particular, @samp{<may 1 1991> - <apr 1 1991>} evaluates
17384 to exactly 30 days even though there is a daylight-savings
17385 transition in between. This is also true for Julian pure dates:
17386 @samp{julian(<may 1 1991>) - julian(<apr 1 1991>)}. But Julian
17387 and Unix date/times will adjust for daylight savings time:
17388 @samp{julian(<12am may 1 1991>) - julian(<12am apr 1 1991>)}
17389 evaluates to @samp{29.95834} (that's 29 days and 23 hours)
17390 because one hour was lost when daylight savings commenced on
17393 In brief, the idiom @samp{julian(@var{date1}) - julian(@var{date2})}
17394 computes the actual number of 24-hour periods between two dates, whereas
17395 @samp{@var{date1} - @var{date2}} computes the number of calendar
17396 days between two dates without taking daylight savings into account.
17398 @pindex calc-time-zone
17403 The @code{calc-time-zone} [@code{tzone}] command converts the time
17404 zone specified by its numeric prefix argument into a number of
17405 seconds difference from Greenwich mean time (GMT). If the argument
17406 is a number, the result is simply that value multiplied by 3600.
17407 Typical arguments for North America are 5 (Eastern) or 8 (Pacific). If
17408 Daylight Savings time is in effect, one hour should be subtracted from
17409 the normal difference.
17411 If you give a prefix of plain @kbd{C-u}, @code{calc-time-zone} (like other
17412 date arithmetic commands that include a time zone argument) takes the
17413 zone argument from the top of the stack. (In the case of @kbd{t J}
17414 and @kbd{t U}, the normal argument is then taken from the second-to-top
17415 stack position.) This allows you to give a non-integer time zone
17416 adjustment. The time-zone argument can also be an HMS form, or
17417 it can be a variable which is a time zone name in upper- or lower-case.
17418 For example @samp{tzone(PST) = tzone(8)} and @samp{tzone(pdt) = tzone(7)}
17419 (for Pacific standard and daylight savings times, respectively).
17421 North American and European time zone names are defined as follows;
17422 note that for each time zone there is one name for standard time,
17423 another for daylight savings time, and a third for ``generalized'' time
17424 in which the daylight savings adjustment is computed from context.
17428 YST PST MST CST EST AST NST GMT WET MET MEZ
17429 9 8 7 6 5 4 3.5 0 -1 -2 -2
17431 YDT PDT MDT CDT EDT ADT NDT BST WETDST METDST MESZ
17432 8 7 6 5 4 3 2.5 -1 -2 -3 -3
17434 YGT PGT MGT CGT EGT AGT NGT BGT WEGT MEGT MEGZ
17435 9/8 8/7 7/6 6/5 5/4 4/3 3.5/2.5 0/-1 -1/-2 -2/-3 -2/-3
17439 @vindex math-tzone-names
17440 To define time zone names that do not appear in the above table,
17441 you must modify the Lisp variable @code{math-tzone-names}. This
17442 is a list of lists describing the different time zone names; its
17443 structure is best explained by an example. The three entries for
17444 Pacific Time look like this:
17448 ( ( "PST" 8 0 ) ; Name as an upper-case string, then standard
17449 ( "PDT" 8 -1 ) ; adjustment, then daylight savings adjustment.
17450 ( "PGT" 8 "PST" "PDT" ) ) ; Generalized time zone.
17454 @cindex @code{TimeZone} variable
17456 With no arguments, @code{calc-time-zone} or @samp{tzone()} obtains an
17457 argument from the Calc variable @code{TimeZone} if a value has been
17458 stored for that variable. If not, Calc runs the Unix @samp{date}
17459 command and looks for one of the above time zone names in the output;
17460 if this does not succeed, @samp{tzone()} leaves itself unevaluated.
17461 The time zone name in the @samp{date} output may be followed by a signed
17462 adjustment, e.g., @samp{GMT+5} or @samp{GMT+0500} which specifies a
17463 number of hours and minutes to be added to the base time zone.
17464 Calc stores the time zone it finds into @code{TimeZone} to speed
17465 later calls to @samp{tzone()}.
17467 The special time zone name @code{local} is equivalent to no argument,
17468 i.e., it uses the local time zone as obtained from the @code{date}
17471 If the time zone name found is one of the standard or daylight
17472 savings zone names from the above table, and Calc's internal
17473 daylight savings algorithm says that time and zone are consistent
17474 (e.g., @code{PDT} accompanies a date that Calc's algorithm would also
17475 consider to be daylight savings, or @code{PST} accompanies a date
17476 that Calc would consider to be standard time), then Calc substitutes
17477 the corresponding generalized time zone (like @code{PGT}).
17479 If your system does not have a suitable @samp{date} command, you
17480 may wish to put a @samp{(setq var-TimeZone ...)} in your Emacs
17481 initialization file to set the time zone. (Since you are interacting
17482 with the variable @code{TimeZone} directly from Emacs Lisp, the
17483 @code{var-} prefix needs to be present.) The easiest way to do
17484 this is to edit the @code{TimeZone} variable using Calc's @kbd{s T}
17485 command, then use the @kbd{s p} (@code{calc-permanent-variable})
17486 command to save the value of @code{TimeZone} permanently.
17488 The @kbd{t J} and @code{t U} commands with no numeric prefix
17489 arguments do the same thing as @samp{tzone()}. If the current
17490 time zone is a generalized time zone, e.g., @code{EGT}, Calc
17491 examines the date being converted to tell whether to use standard
17492 or daylight savings time. But if the current time zone is explicit,
17493 e.g., @code{EST} or @code{EDT}, then that adjustment is used exactly
17494 and Calc's daylight savings algorithm is not consulted.
17496 Some places don't follow the usual rules for daylight savings time.
17497 The state of Arizona, for example, does not observe daylight savings
17498 time. If you run Calc during the winter season in Arizona, the
17499 Unix @code{date} command will report @code{MST} time zone, which
17500 Calc will change to @code{MGT}. If you then convert a time that
17501 lies in the summer months, Calc will apply an incorrect daylight
17502 savings time adjustment. To avoid this, set your @code{TimeZone}
17503 variable explicitly to @code{MST} to force the use of standard,
17504 non-daylight-savings time.
17506 @vindex math-daylight-savings-hook
17507 @findex math-std-daylight-savings
17508 By default Calc always considers daylight savings time to begin at
17509 2 a.m.@: on the first Sunday of April, and to end at 2 a.m.@: on the
17510 last Sunday of October. This is the rule that has been in effect
17511 in North America since 1987. If you are in a country that uses
17512 different rules for computing daylight savings time, you have two
17513 choices: Write your own daylight savings hook, or control time
17514 zones explicitly by setting the @code{TimeZone} variable and/or
17515 always giving a time-zone argument for the conversion functions.
17517 The Lisp variable @code{math-daylight-savings-hook} holds the
17518 name of a function that is used to compute the daylight savings
17519 adjustment for a given date. The default is
17520 @code{math-std-daylight-savings}, which computes an adjustment
17521 (either 0 or @mathit{-1}) using the North American rules given above.
17523 The daylight savings hook function is called with four arguments:
17524 The date, as a floating-point number in standard Calc format;
17525 a six-element list of the date decomposed into year, month, day,
17526 hour, minute, and second, respectively; a string which contains
17527 the generalized time zone name in upper-case, e.g., @code{"WEGT"};
17528 and a special adjustment to be applied to the hour value when
17529 converting into a generalized time zone (see below).
17531 @findex math-prev-weekday-in-month
17532 The Lisp function @code{math-prev-weekday-in-month} is useful for
17533 daylight savings computations. This is an internal version of
17534 the user-level @code{pwday} function described in the previous
17535 section. It takes four arguments: The floating-point date value,
17536 the corresponding six-element date list, the day-of-month number,
17537 and the weekday number (0-6).
17539 The default daylight savings hook ignores the time zone name, but a
17540 more sophisticated hook could use different algorithms for different
17541 time zones. It would also be possible to use different algorithms
17542 depending on the year number, but the default hook always uses the
17543 algorithm for 1987 and later. Here is a listing of the default
17544 daylight savings hook:
17547 (defun math-std-daylight-savings (date dt zone bump)
17548 (cond ((< (nth 1 dt) 4) 0)
17550 (let ((sunday (math-prev-weekday-in-month date dt 7 0)))
17551 (cond ((< (nth 2 dt) sunday) 0)
17552 ((= (nth 2 dt) sunday)
17553 (if (>= (nth 3 dt) (+ 3 bump)) -1 0))
17555 ((< (nth 1 dt) 10) -1)
17557 (let ((sunday (math-prev-weekday-in-month date dt 31 0)))
17558 (cond ((< (nth 2 dt) sunday) -1)
17559 ((= (nth 2 dt) sunday)
17560 (if (>= (nth 3 dt) (+ 2 bump)) 0 -1))
17567 The @code{bump} parameter is equal to zero when Calc is converting
17568 from a date form in a generalized time zone into a GMT date value.
17569 It is @mathit{-1} when Calc is converting in the other direction. The
17570 adjustments shown above ensure that the conversion behaves correctly
17571 and reasonably around the 2 a.m.@: transition in each direction.
17573 There is a ``missing'' hour between 2 a.m.@: and 3 a.m.@: at the
17574 beginning of daylight savings time; converting a date/time form that
17575 falls in this hour results in a time value for the following hour,
17576 from 3 a.m.@: to 4 a.m. At the end of daylight savings time, the
17577 hour from 1 a.m.@: to 2 a.m.@: repeats itself; converting a date/time
17578 form that falls in this hour results in a time value for the first
17579 manifestation of that time (@emph{not} the one that occurs one hour later).
17581 If @code{math-daylight-savings-hook} is @code{nil}, then the
17582 daylight savings adjustment is always taken to be zero.
17584 In algebraic formulas, @samp{tzone(@var{zone}, @var{date})}
17585 computes the time zone adjustment for a given zone name at a
17586 given date. The @var{date} is ignored unless @var{zone} is a
17587 generalized time zone. If @var{date} is a date form, the
17588 daylight savings computation is applied to it as it appears.
17589 If @var{date} is a numeric date value, it is adjusted for the
17590 daylight-savings version of @var{zone} before being given to
17591 the daylight savings hook. This odd-sounding rule ensures
17592 that the daylight-savings computation is always done in
17593 local time, not in the GMT time that a numeric @var{date}
17594 is typically represented in.
17600 The @samp{dsadj(@var{date}, @var{zone})} function computes the
17601 daylight savings adjustment that is appropriate for @var{date} in
17602 time zone @var{zone}. If @var{zone} is explicitly in or not in
17603 daylight savings time (e.g., @code{PDT} or @code{PST}) the
17604 @var{date} is ignored. If @var{zone} is a generalized time zone,
17605 the algorithms described above are used. If @var{zone} is omitted,
17606 the computation is done for the current time zone.
17608 @xref{Reporting Bugs}, for the address of Calc's author, if you
17609 should wish to contribute your improved versions of
17610 @code{math-tzone-names} and @code{math-daylight-savings-hook}
17611 to the Calc distribution.
17613 @node Financial Functions, Binary Functions, Date Arithmetic, Arithmetic
17614 @section Financial Functions
17617 Calc's financial or business functions use the @kbd{b} prefix
17618 key followed by a shifted letter. (The @kbd{b} prefix followed by
17619 a lower-case letter is used for operations on binary numbers.)
17621 Note that the rate and the number of intervals given to these
17622 functions must be on the same time scale, e.g., both months or
17623 both years. Mixing an annual interest rate with a time expressed
17624 in months will give you very wrong answers!
17626 It is wise to compute these functions to a higher precision than
17627 you really need, just to make sure your answer is correct to the
17628 last penny; also, you may wish to check the definitions at the end
17629 of this section to make sure the functions have the meaning you expect.
17635 * Related Financial Functions::
17636 * Depreciation Functions::
17637 * Definitions of Financial Functions::
17640 @node Percentages, Future Value, Financial Functions, Financial Functions
17641 @subsection Percentages
17644 @pindex calc-percent
17647 The @kbd{M-%} (@code{calc-percent}) command takes a percentage value,
17648 say 5.4, and converts it to an equivalent actual number. For example,
17649 @kbd{5.4 M-%} enters 0.054 on the stack. (That's the @key{META} or
17650 @key{ESC} key combined with @kbd{%}.)
17652 Actually, @kbd{M-%} creates a formula of the form @samp{5.4%}.
17653 You can enter @samp{5.4%} yourself during algebraic entry. The
17654 @samp{%} operator simply means, ``the preceding value divided by
17655 100.'' The @samp{%} operator has very high precedence, so that
17656 @samp{1+8%} is interpreted as @samp{1+(8%)}, not as @samp{(1+8)%}.
17657 (The @samp{%} operator is just a postfix notation for the
17658 @code{percent} function, just like @samp{20!} is the notation for
17659 @samp{fact(20)}, or twenty-factorial.)
17661 The formula @samp{5.4%} would normally evaluate immediately to
17662 0.054, but the @kbd{M-%} command suppresses evaluation as it puts
17663 the formula onto the stack. However, the next Calc command that
17664 uses the formula @samp{5.4%} will evaluate it as its first step.
17665 The net effect is that you get to look at @samp{5.4%} on the stack,
17666 but Calc commands see it as @samp{0.054}, which is what they expect.
17668 In particular, @samp{5.4%} and @samp{0.054} are suitable values
17669 for the @var{rate} arguments of the various financial functions,
17670 but the number @samp{5.4} is probably @emph{not} suitable---it
17671 represents a rate of 540 percent!
17673 The key sequence @kbd{M-% *} effectively means ``percent-of.''
17674 For example, @kbd{68 @key{RET} 25 M-% *} computes 17, which is 25% of
17675 68 (and also 68% of 25, which comes out to the same thing).
17678 @pindex calc-convert-percent
17679 The @kbd{c %} (@code{calc-convert-percent}) command converts the
17680 value on the top of the stack from numeric to percentage form.
17681 For example, if 0.08 is on the stack, @kbd{c %} converts it to
17682 @samp{8%}. The quantity is the same, it's just represented
17683 differently. (Contrast this with @kbd{M-%}, which would convert
17684 this number to @samp{0.08%}.) The @kbd{=} key is a convenient way
17685 to convert a formula like @samp{8%} back to numeric form, 0.08.
17687 To compute what percentage one quantity is of another quantity,
17688 use @kbd{/ c %}. For example, @w{@kbd{17 @key{RET} 68 / c %}} displays
17692 @pindex calc-percent-change
17694 The @kbd{b %} (@code{calc-percent-change}) [@code{relch}] command
17695 calculates the percentage change from one number to another.
17696 For example, @kbd{40 @key{RET} 50 b %} produces the answer @samp{25%},
17697 since 50 is 25% larger than 40. A negative result represents a
17698 decrease: @kbd{50 @key{RET} 40 b %} produces @samp{-20%}, since 40 is
17699 20% smaller than 50. (The answers are different in magnitude
17700 because, in the first case, we're increasing by 25% of 40, but
17701 in the second case, we're decreasing by 20% of 50.) The effect
17702 of @kbd{40 @key{RET} 50 b %} is to compute @expr{(50-40)/40}, converting
17703 the answer to percentage form as if by @kbd{c %}.
17705 @node Future Value, Present Value, Percentages, Financial Functions
17706 @subsection Future Value
17710 @pindex calc-fin-fv
17712 The @kbd{b F} (@code{calc-fin-fv}) [@code{fv}] command computes
17713 the future value of an investment. It takes three arguments
17714 from the stack: @samp{fv(@var{rate}, @var{n}, @var{payment})}.
17715 If you give payments of @var{payment} every year for @var{n}
17716 years, and the money you have paid earns interest at @var{rate} per
17717 year, then this function tells you what your investment would be
17718 worth at the end of the period. (The actual interval doesn't
17719 have to be years, as long as @var{n} and @var{rate} are expressed
17720 in terms of the same intervals.) This function assumes payments
17721 occur at the @emph{end} of each interval.
17725 The @kbd{I b F} [@code{fvb}] command does the same computation,
17726 but assuming your payments are at the beginning of each interval.
17727 Suppose you plan to deposit $1000 per year in a savings account
17728 earning 5.4% interest, starting right now. How much will be
17729 in the account after five years? @code{fvb(5.4%, 5, 1000) = 5870.73}.
17730 Thus you will have earned $870 worth of interest over the years.
17731 Using the stack, this calculation would have been
17732 @kbd{5.4 M-% 5 @key{RET} 1000 I b F}. Note that the rate is expressed
17733 as a number between 0 and 1, @emph{not} as a percentage.
17737 The @kbd{H b F} [@code{fvl}] command computes the future value
17738 of an initial lump sum investment. Suppose you could deposit
17739 those five thousand dollars in the bank right now; how much would
17740 they be worth in five years? @code{fvl(5.4%, 5, 5000) = 6503.89}.
17742 The algebraic functions @code{fv} and @code{fvb} accept an optional
17743 fourth argument, which is used as an initial lump sum in the sense
17744 of @code{fvl}. In other words, @code{fv(@var{rate}, @var{n},
17745 @var{payment}, @var{initial}) = fv(@var{rate}, @var{n}, @var{payment})
17746 + fvl(@var{rate}, @var{n}, @var{initial})}.
17748 To illustrate the relationships between these functions, we could
17749 do the @code{fvb} calculation ``by hand'' using @code{fvl}. The
17750 final balance will be the sum of the contributions of our five
17751 deposits at various times. The first deposit earns interest for
17752 five years: @code{fvl(5.4%, 5, 1000) = 1300.78}. The second
17753 deposit only earns interest for four years: @code{fvl(5.4%, 4, 1000) =
17754 1234.13}. And so on down to the last deposit, which earns one
17755 year's interest: @code{fvl(5.4%, 1, 1000) = 1054.00}. The sum of
17756 these five values is, sure enough, $5870.73, just as was computed
17757 by @code{fvb} directly.
17759 What does @code{fv(5.4%, 5, 1000) = 5569.96} mean? The payments
17760 are now at the ends of the periods. The end of one year is the same
17761 as the beginning of the next, so what this really means is that we've
17762 lost the payment at year zero (which contributed $1300.78), but we're
17763 now counting the payment at year five (which, since it didn't have
17764 a chance to earn interest, counts as $1000). Indeed, @expr{5569.96 =
17765 5870.73 - 1300.78 + 1000} (give or take a bit of roundoff error).
17767 @node Present Value, Related Financial Functions, Future Value, Financial Functions
17768 @subsection Present Value
17772 @pindex calc-fin-pv
17774 The @kbd{b P} (@code{calc-fin-pv}) [@code{pv}] command computes
17775 the present value of an investment. Like @code{fv}, it takes
17776 three arguments: @code{pv(@var{rate}, @var{n}, @var{payment})}.
17777 It computes the present value of a series of regular payments.
17778 Suppose you have the chance to make an investment that will
17779 pay $2000 per year over the next four years; as you receive
17780 these payments you can put them in the bank at 9% interest.
17781 You want to know whether it is better to make the investment, or
17782 to keep the money in the bank where it earns 9% interest right
17783 from the start. The calculation @code{pv(9%, 4, 2000)} gives the
17784 result 6479.44. If your initial investment must be less than this,
17785 say, $6000, then the investment is worthwhile. But if you had to
17786 put up $7000, then it would be better just to leave it in the bank.
17788 Here is the interpretation of the result of @code{pv}: You are
17789 trying to compare the return from the investment you are
17790 considering, which is @code{fv(9%, 4, 2000) = 9146.26}, with
17791 the return from leaving the money in the bank, which is
17792 @code{fvl(9%, 4, @var{x})} where @var{x} is the amount of money
17793 you would have to put up in advance. The @code{pv} function
17794 finds the break-even point, @expr{x = 6479.44}, at which
17795 @code{fvl(9%, 4, 6479.44)} is also equal to 9146.26. This is
17796 the largest amount you should be willing to invest.
17800 The @kbd{I b P} [@code{pvb}] command solves the same problem,
17801 but with payments occurring at the beginning of each interval.
17802 It has the same relationship to @code{fvb} as @code{pv} has
17803 to @code{fv}. For example @code{pvb(9%, 4, 2000) = 7062.59},
17804 a larger number than @code{pv} produced because we get to start
17805 earning interest on the return from our investment sooner.
17809 The @kbd{H b P} [@code{pvl}] command computes the present value of
17810 an investment that will pay off in one lump sum at the end of the
17811 period. For example, if we get our $8000 all at the end of the
17812 four years, @code{pvl(9%, 4, 8000) = 5667.40}. This is much
17813 less than @code{pv} reported, because we don't earn any interest
17814 on the return from this investment. Note that @code{pvl} and
17815 @code{fvl} are simple inverses: @code{fvl(9%, 4, 5667.40) = 8000}.
17817 You can give an optional fourth lump-sum argument to @code{pv}
17818 and @code{pvb}; this is handled in exactly the same way as the
17819 fourth argument for @code{fv} and @code{fvb}.
17822 @pindex calc-fin-npv
17824 The @kbd{b N} (@code{calc-fin-npv}) [@code{npv}] command computes
17825 the net present value of a series of irregular investments.
17826 The first argument is the interest rate. The second argument is
17827 a vector which represents the expected return from the investment
17828 at the end of each interval. For example, if the rate represents
17829 a yearly interest rate, then the vector elements are the return
17830 from the first year, second year, and so on.
17832 Thus, @code{npv(9%, [2000,2000,2000,2000]) = pv(9%, 4, 2000) = 6479.44}.
17833 Obviously this function is more interesting when the payments are
17836 The @code{npv} function can actually have two or more arguments.
17837 Multiple arguments are interpreted in the same way as for the
17838 vector statistical functions like @code{vsum}.
17839 @xref{Single-Variable Statistics}. Basically, if there are several
17840 payment arguments, each either a vector or a plain number, all these
17841 values are collected left-to-right into the complete list of payments.
17842 A numeric prefix argument on the @kbd{b N} command says how many
17843 payment values or vectors to take from the stack.
17847 The @kbd{I b N} [@code{npvb}] command computes the net present
17848 value where payments occur at the beginning of each interval
17849 rather than at the end.
17851 @node Related Financial Functions, Depreciation Functions, Present Value, Financial Functions
17852 @subsection Related Financial Functions
17855 The functions in this section are basically inverses of the
17856 present value functions with respect to the various arguments.
17859 @pindex calc-fin-pmt
17861 The @kbd{b M} (@code{calc-fin-pmt}) [@code{pmt}] command computes
17862 the amount of periodic payment necessary to amortize a loan.
17863 Thus @code{pmt(@var{rate}, @var{n}, @var{amount})} equals the
17864 value of @var{payment} such that @code{pv(@var{rate}, @var{n},
17865 @var{payment}) = @var{amount}}.
17869 The @kbd{I b M} [@code{pmtb}] command does the same computation
17870 but using @code{pvb} instead of @code{pv}. Like @code{pv} and
17871 @code{pvb}, these functions can also take a fourth argument which
17872 represents an initial lump-sum investment.
17875 The @kbd{H b M} key just invokes the @code{fvl} function, which is
17876 the inverse of @code{pvl}. There is no explicit @code{pmtl} function.
17879 @pindex calc-fin-nper
17881 The @kbd{b #} (@code{calc-fin-nper}) [@code{nper}] command computes
17882 the number of regular payments necessary to amortize a loan.
17883 Thus @code{nper(@var{rate}, @var{payment}, @var{amount})} equals
17884 the value of @var{n} such that @code{pv(@var{rate}, @var{n},
17885 @var{payment}) = @var{amount}}. If @var{payment} is too small
17886 ever to amortize a loan for @var{amount} at interest rate @var{rate},
17887 the @code{nper} function is left in symbolic form.
17891 The @kbd{I b #} [@code{nperb}] command does the same computation
17892 but using @code{pvb} instead of @code{pv}. You can give a fourth
17893 lump-sum argument to these functions, but the computation will be
17894 rather slow in the four-argument case.
17898 The @kbd{H b #} [@code{nperl}] command does the same computation
17899 using @code{pvl}. By exchanging @var{payment} and @var{amount} you
17900 can also get the solution for @code{fvl}. For example,
17901 @code{nperl(8%, 2000, 1000) = 9.006}, so if you place $1000 in a
17902 bank account earning 8%, it will take nine years to grow to $2000.
17905 @pindex calc-fin-rate
17907 The @kbd{b T} (@code{calc-fin-rate}) [@code{rate}] command computes
17908 the rate of return on an investment. This is also an inverse of @code{pv}:
17909 @code{rate(@var{n}, @var{payment}, @var{amount})} computes the value of
17910 @var{rate} such that @code{pv(@var{rate}, @var{n}, @var{payment}) =
17911 @var{amount}}. The result is expressed as a formula like @samp{6.3%}.
17917 The @kbd{I b T} [@code{rateb}] and @kbd{H b T} [@code{ratel}]
17918 commands solve the analogous equations with @code{pvb} or @code{pvl}
17919 in place of @code{pv}. Also, @code{rate} and @code{rateb} can
17920 accept an optional fourth argument just like @code{pv} and @code{pvb}.
17921 To redo the above example from a different perspective,
17922 @code{ratel(9, 2000, 1000) = 8.00597%}, which says you will need an
17923 interest rate of 8% in order to double your account in nine years.
17926 @pindex calc-fin-irr
17928 The @kbd{b I} (@code{calc-fin-irr}) [@code{irr}] command is the
17929 analogous function to @code{rate} but for net present value.
17930 Its argument is a vector of payments. Thus @code{irr(@var{payments})}
17931 computes the @var{rate} such that @code{npv(@var{rate}, @var{payments}) = 0};
17932 this rate is known as the @dfn{internal rate of return}.
17936 The @kbd{I b I} [@code{irrb}] command computes the internal rate of
17937 return assuming payments occur at the beginning of each period.
17939 @node Depreciation Functions, Definitions of Financial Functions, Related Financial Functions, Financial Functions
17940 @subsection Depreciation Functions
17943 The functions in this section calculate @dfn{depreciation}, which is
17944 the amount of value that a possession loses over time. These functions
17945 are characterized by three parameters: @var{cost}, the original cost
17946 of the asset; @var{salvage}, the value the asset will have at the end
17947 of its expected ``useful life''; and @var{life}, the number of years
17948 (or other periods) of the expected useful life.
17950 There are several methods for calculating depreciation that differ in
17951 the way they spread the depreciation over the lifetime of the asset.
17954 @pindex calc-fin-sln
17956 The @kbd{b S} (@code{calc-fin-sln}) [@code{sln}] command computes the
17957 ``straight-line'' depreciation. In this method, the asset depreciates
17958 by the same amount every year (or period). For example,
17959 @samp{sln(12000, 2000, 5)} returns 2000. The asset costs $12000
17960 initially and will be worth $2000 after five years; it loses $2000
17964 @pindex calc-fin-syd
17966 The @kbd{b Y} (@code{calc-fin-syd}) [@code{syd}] command computes the
17967 accelerated ``sum-of-years'-digits'' depreciation. Here the depreciation
17968 is higher during the early years of the asset's life. Since the
17969 depreciation is different each year, @kbd{b Y} takes a fourth @var{period}
17970 parameter which specifies which year is requested, from 1 to @var{life}.
17971 If @var{period} is outside this range, the @code{syd} function will
17975 @pindex calc-fin-ddb
17977 The @kbd{b D} (@code{calc-fin-ddb}) [@code{ddb}] command computes an
17978 accelerated depreciation using the double-declining balance method.
17979 It also takes a fourth @var{period} parameter.
17981 For symmetry, the @code{sln} function will accept a @var{period}
17982 parameter as well, although it will ignore its value except that the
17983 return value will as usual be zero if @var{period} is out of range.
17985 For example, pushing the vector @expr{[1,2,3,4,5]} (perhaps with @kbd{v x 5})
17986 and then mapping @kbd{V M ' [sln(12000,2000,5,$), syd(12000,2000,5,$),
17987 ddb(12000,2000,5,$)] @key{RET}} produces a matrix that allows us to compare
17988 the three depreciation methods:
17992 [ [ 2000, 3333, 4800 ]
17993 [ 2000, 2667, 2880 ]
17994 [ 2000, 2000, 1728 ]
17995 [ 2000, 1333, 592 ]
18001 (Values have been rounded to nearest integers in this figure.)
18002 We see that @code{sln} depreciates by the same amount each year,
18003 @kbd{syd} depreciates more at the beginning and less at the end,
18004 and @kbd{ddb} weights the depreciation even more toward the beginning.
18006 Summing columns with @kbd{V R : +} yields @expr{[10000, 10000, 10000]};
18007 the total depreciation in any method is (by definition) the
18008 difference between the cost and the salvage value.
18010 @node Definitions of Financial Functions, , Depreciation Functions, Financial Functions
18011 @subsection Definitions
18014 For your reference, here are the actual formulas used to compute
18015 Calc's financial functions.
18017 Calc will not evaluate a financial function unless the @var{rate} or
18018 @var{n} argument is known. However, @var{payment} or @var{amount} can
18019 be a variable. Calc expands these functions according to the
18020 formulas below for symbolic arguments only when you use the @kbd{a "}
18021 (@code{calc-expand-formula}) command, or when taking derivatives or
18022 integrals or solving equations involving the functions.
18025 These formulas are shown using the conventions of Big display
18026 mode (@kbd{d B}); for example, the formula for @code{fv} written
18027 linearly is @samp{pmt * ((1 + rate)^n) - 1) / rate}.
18032 fv(rate, n, pmt) = pmt * ---------------
18036 ((1 + rate) - 1) (1 + rate)
18037 fvb(rate, n, pmt) = pmt * ----------------------------
18041 fvl(rate, n, pmt) = pmt * (1 + rate)
18045 pv(rate, n, pmt) = pmt * ----------------
18049 (1 - (1 + rate) ) (1 + rate)
18050 pvb(rate, n, pmt) = pmt * -----------------------------
18054 pvl(rate, n, pmt) = pmt * (1 + rate)
18057 npv(rate, [a, b, c]) = a*(1 + rate) + b*(1 + rate) + c*(1 + rate)
18060 npvb(rate, [a, b, c]) = a + b*(1 + rate) + c*(1 + rate)
18063 (amt - x * (1 + rate) ) * rate
18064 pmt(rate, n, amt, x) = -------------------------------
18069 (amt - x * (1 + rate) ) * rate
18070 pmtb(rate, n, amt, x) = -------------------------------
18072 (1 - (1 + rate) ) (1 + rate)
18075 nper(rate, pmt, amt) = - log(1 - ------------, 1 + rate)
18079 nperb(rate, pmt, amt) = - log(1 - ---------------, 1 + rate)
18083 nperl(rate, pmt, amt) = - log(---, 1 + rate)
18088 ratel(n, pmt, amt) = ------ - 1
18093 sln(cost, salv, life) = -----------
18096 (cost - salv) * (life - per + 1)
18097 syd(cost, salv, life, per) = --------------------------------
18098 life * (life + 1) / 2
18101 ddb(cost, salv, life, per) = --------, book = cost - depreciation so far
18107 $$ \code{fv}(r, n, p) = p { (1 + r)^n - 1 \over r } $$
18108 $$ \code{fvb}(r, n, p) = p { ((1 + r)^n - 1) (1 + r) \over r } $$
18109 $$ \code{fvl}(r, n, p) = p (1 + r)^n $$
18110 $$ \code{pv}(r, n, p) = p { 1 - (1 + r)^{-n} \over r } $$
18111 $$ \code{pvb}(r, n, p) = p { (1 - (1 + r)^{-n}) (1 + r) \over r } $$
18112 $$ \code{pvl}(r, n, p) = p (1 + r)^{-n} $$
18113 $$ \code{npv}(r, [a,b,c]) = a (1 + r)^{-1} + b (1 + r)^{-2} + c (1 + r)^{-3} $$
18114 $$ \code{npvb}(r, [a,b,c]) = a + b (1 + r)^{-1} + c (1 + r)^{-2} $$
18115 $$ \code{pmt}(r, n, a, x) = { (a - x (1 + r)^{-n}) r \over 1 - (1 + r)^{-n} }$$
18116 $$ \code{pmtb}(r, n, a, x) = { (a - x (1 + r)^{-n}) r \over
18117 (1 - (1 + r)^{-n}) (1 + r) } $$
18118 $$ \code{nper}(r, p, a) = -\code{log}(1 - { a r \over p }, 1 + r) $$
18119 $$ \code{nperb}(r, p, a) = -\code{log}(1 - { a r \over p (1 + r) }, 1 + r) $$
18120 $$ \code{nperl}(r, p, a) = -\code{log}({a \over p}, 1 + r) $$
18121 $$ \code{ratel}(n, p, a) = { p^{1/n} \over a^{1/n} } - 1 $$
18122 $$ \code{sln}(c, s, l) = { c - s \over l } $$
18123 $$ \code{syd}(c, s, l, p) = { (c - s) (l - p + 1) \over l (l+1) / 2 } $$
18124 $$ \code{ddb}(c, s, l, p) = { 2 (c - \hbox{depreciation so far}) \over l } $$
18128 In @code{pmt} and @code{pmtb}, @expr{x=0} if omitted.
18130 These functions accept any numeric objects, including error forms,
18131 intervals, and even (though not very usefully) complex numbers. The
18132 above formulas specify exactly the behavior of these functions with
18133 all sorts of inputs.
18135 Note that if the first argument to the @code{log} in @code{nper} is
18136 negative, @code{nper} leaves itself in symbolic form rather than
18137 returning a (financially meaningless) complex number.
18139 @samp{rate(num, pmt, amt)} solves the equation
18140 @samp{pv(rate, num, pmt) = amt} for @samp{rate} using @kbd{H a R}
18141 (@code{calc-find-root}), with the interval @samp{[.01% .. 100%]}
18142 for an initial guess. The @code{rateb} function is the same except
18143 that it uses @code{pvb}. Note that @code{ratel} can be solved
18144 directly; its formula is shown in the above list.
18146 Similarly, @samp{irr(pmts)} solves the equation @samp{npv(rate, pmts) = 0}
18149 If you give a fourth argument to @code{nper} or @code{nperb}, Calc
18150 will also use @kbd{H a R} to solve the equation using an initial
18151 guess interval of @samp{[0 .. 100]}.
18153 A fourth argument to @code{fv} simply sums the two components
18154 calculated from the above formulas for @code{fv} and @code{fvl}.
18155 The same is true of @code{fvb}, @code{pv}, and @code{pvb}.
18157 The @kbd{ddb} function is computed iteratively; the ``book'' value
18158 starts out equal to @var{cost}, and decreases according to the above
18159 formula for the specified number of periods. If the book value
18160 would decrease below @var{salvage}, it only decreases to @var{salvage}
18161 and the depreciation is zero for all subsequent periods. The @code{ddb}
18162 function returns the amount the book value decreased in the specified
18165 @node Binary Functions, , Financial Functions, Arithmetic
18166 @section Binary Number Functions
18169 The commands in this chapter all use two-letter sequences beginning with
18170 the @kbd{b} prefix.
18172 @cindex Binary numbers
18173 The ``binary'' operations actually work regardless of the currently
18174 displayed radix, although their results make the most sense in a radix
18175 like 2, 8, or 16 (as obtained by the @kbd{d 2}, @kbd{d 8}, or @w{@kbd{d 6}}
18176 commands, respectively). You may also wish to enable display of leading
18177 zeros with @kbd{d z}. @xref{Radix Modes}.
18179 @cindex Word size for binary operations
18180 The Calculator maintains a current @dfn{word size} @expr{w}, an
18181 arbitrary positive or negative integer. For a positive word size, all
18182 of the binary operations described here operate modulo @expr{2^w}. In
18183 particular, negative arguments are converted to positive integers modulo
18184 @expr{2^w} by all binary functions.
18186 If the word size is negative, binary operations produce 2's complement
18188 @texline @math{-2^{-w-1}}
18189 @infoline @expr{-(2^(-w-1))}
18191 @texline @math{2^{-w-1}-1}
18192 @infoline @expr{2^(-w-1)-1}
18193 inclusive. Either mode accepts inputs in any range; the sign of
18194 @expr{w} affects only the results produced.
18199 The @kbd{b c} (@code{calc-clip})
18200 [@code{clip}] command can be used to clip a number by reducing it modulo
18201 @expr{2^w}. The commands described in this chapter automatically clip
18202 their results to the current word size. Note that other operations like
18203 addition do not use the current word size, since integer addition
18204 generally is not ``binary.'' (However, @pxref{Simplification Modes},
18205 @code{calc-bin-simplify-mode}.) For example, with a word size of 8
18206 bits @kbd{b c} converts a number to the range 0 to 255; with a word
18207 size of @mathit{-8} @kbd{b c} converts to the range @mathit{-128} to 127.
18210 @pindex calc-word-size
18211 The default word size is 32 bits. All operations except the shifts and
18212 rotates allow you to specify a different word size for that one
18213 operation by giving a numeric prefix argument: @kbd{C-u 8 b c} clips the
18214 top of stack to the range 0 to 255 regardless of the current word size.
18215 To set the word size permanently, use @kbd{b w} (@code{calc-word-size}).
18216 This command displays a prompt with the current word size; press @key{RET}
18217 immediately to keep this word size, or type a new word size at the prompt.
18219 When the binary operations are written in symbolic form, they take an
18220 optional second (or third) word-size parameter. When a formula like
18221 @samp{and(a,b)} is finally evaluated, the word size current at that time
18222 will be used, but when @samp{and(a,b,-8)} is evaluated, a word size of
18223 @mathit{-8} will always be used. A symbolic binary function will be left
18224 in symbolic form unless the all of its argument(s) are integers or
18225 integer-valued floats.
18227 If either or both arguments are modulo forms for which @expr{M} is a
18228 power of two, that power of two is taken as the word size unless a
18229 numeric prefix argument overrides it. The current word size is never
18230 consulted when modulo-power-of-two forms are involved.
18235 The @kbd{b a} (@code{calc-and}) [@code{and}] command computes the bitwise
18236 AND of the two numbers on the top of the stack. In other words, for each
18237 of the @expr{w} binary digits of the two numbers (pairwise), the corresponding
18238 bit of the result is 1 if and only if both input bits are 1:
18239 @samp{and(2#1100, 2#1010) = 2#1000}.
18244 The @kbd{b o} (@code{calc-or}) [@code{or}] command computes the bitwise
18245 inclusive OR of two numbers. A bit is 1 if either of the input bits, or
18246 both, are 1: @samp{or(2#1100, 2#1010) = 2#1110}.
18251 The @kbd{b x} (@code{calc-xor}) [@code{xor}] command computes the bitwise
18252 exclusive OR of two numbers. A bit is 1 if exactly one of the input bits
18253 is 1: @samp{xor(2#1100, 2#1010) = 2#0110}.
18258 The @kbd{b d} (@code{calc-diff}) [@code{diff}] command computes the bitwise
18259 difference of two numbers; this is defined by @samp{diff(a,b) = and(a,not(b))},
18260 so that @samp{diff(2#1100, 2#1010) = 2#0100}.
18265 The @kbd{b n} (@code{calc-not}) [@code{not}] command computes the bitwise
18266 NOT of a number. A bit is 1 if the input bit is 0 and vice-versa.
18269 @pindex calc-lshift-binary
18271 The @kbd{b l} (@code{calc-lshift-binary}) [@code{lsh}] command shifts a
18272 number left by one bit, or by the number of bits specified in the numeric
18273 prefix argument. A negative prefix argument performs a logical right shift,
18274 in which zeros are shifted in on the left. In symbolic form, @samp{lsh(a)}
18275 is short for @samp{lsh(a,1)}, which in turn is short for @samp{lsh(a,n,w)}.
18276 Bits shifted ``off the end,'' according to the current word size, are lost.
18292 The @kbd{H b l} command also does a left shift, but it takes two arguments
18293 from the stack (the value to shift, and, at top-of-stack, the number of
18294 bits to shift). This version interprets the prefix argument just like
18295 the regular binary operations, i.e., as a word size. The Hyperbolic flag
18296 has a similar effect on the rest of the binary shift and rotate commands.
18299 @pindex calc-rshift-binary
18301 The @kbd{b r} (@code{calc-rshift-binary}) [@code{rsh}] command shifts a
18302 number right by one bit, or by the number of bits specified in the numeric
18303 prefix argument: @samp{rsh(a,n) = lsh(a,-n)}.
18306 @pindex calc-lshift-arith
18308 The @kbd{b L} (@code{calc-lshift-arith}) [@code{ash}] command shifts a
18309 number left. It is analogous to @code{lsh}, except that if the shift
18310 is rightward (the prefix argument is negative), an arithmetic shift
18311 is performed as described below.
18314 @pindex calc-rshift-arith
18316 The @kbd{b R} (@code{calc-rshift-arith}) [@code{rash}] command performs
18317 an ``arithmetic'' shift to the right, in which the leftmost bit (according
18318 to the current word size) is duplicated rather than shifting in zeros.
18319 This corresponds to dividing by a power of two where the input is interpreted
18320 as a signed, twos-complement number. (The distinction between the @samp{rsh}
18321 and @samp{rash} operations is totally independent from whether the word
18322 size is positive or negative.) With a negative prefix argument, this
18323 performs a standard left shift.
18326 @pindex calc-rotate-binary
18328 The @kbd{b t} (@code{calc-rotate-binary}) [@code{rot}] command rotates a
18329 number one bit to the left. The leftmost bit (according to the current
18330 word size) is dropped off the left and shifted in on the right. With a
18331 numeric prefix argument, the number is rotated that many bits to the left
18334 @xref{Set Operations}, for the @kbd{b p} and @kbd{b u} commands that
18335 pack and unpack binary integers into sets. (For example, @kbd{b u}
18336 unpacks the number @samp{2#11001} to the set of bit-numbers
18337 @samp{[0, 3, 4]}.) Type @kbd{b u V #} to count the number of ``1''
18338 bits in a binary integer.
18340 Another interesting use of the set representation of binary integers
18341 is to reverse the bits in, say, a 32-bit integer. Type @kbd{b u} to
18342 unpack; type @kbd{31 @key{TAB} -} to replace each bit-number in the set
18343 with 31 minus that bit-number; type @kbd{b p} to pack the set back
18344 into a binary integer.
18346 @node Scientific Functions, Matrix Functions, Arithmetic, Top
18347 @chapter Scientific Functions
18350 The functions described here perform trigonometric and other transcendental
18351 calculations. They generally produce floating-point answers correct to the
18352 full current precision. The @kbd{H} (Hyperbolic) and @kbd{I} (Inverse)
18353 flag keys must be used to get some of these functions from the keyboard.
18357 @cindex @code{pi} variable
18360 @cindex @code{e} variable
18363 @cindex @code{gamma} variable
18365 @cindex Gamma constant, Euler's
18366 @cindex Euler's gamma constant
18368 @cindex @code{phi} variable
18369 @cindex Phi, golden ratio
18370 @cindex Golden ratio
18371 One miscellaneous command is shift-@kbd{P} (@code{calc-pi}), which pushes
18372 the value of @cpi{} (at the current precision) onto the stack. With the
18373 Hyperbolic flag, it pushes the value @expr{e}, the base of natural logarithms.
18374 With the Inverse flag, it pushes Euler's constant
18375 @texline @math{\gamma}
18376 @infoline @expr{gamma}
18377 (about 0.5772). With both Inverse and Hyperbolic, it
18378 pushes the ``golden ratio''
18379 @texline @math{\phi}
18380 @infoline @expr{phi}
18381 (about 1.618). (At present, Euler's constant is not available
18382 to unlimited precision; Calc knows only the first 100 digits.)
18383 In Symbolic mode, these commands push the
18384 actual variables @samp{pi}, @samp{e}, @samp{gamma}, and @samp{phi},
18385 respectively, instead of their values; @pxref{Symbolic Mode}.
18395 The @kbd{Q} (@code{calc-sqrt}) [@code{sqrt}] function is described elsewhere;
18396 @pxref{Basic Arithmetic}. With the Inverse flag [@code{sqr}], this command
18397 computes the square of the argument.
18399 @xref{Prefix Arguments}, for a discussion of the effect of numeric
18400 prefix arguments on commands in this chapter which do not otherwise
18401 interpret a prefix argument.
18404 * Logarithmic Functions::
18405 * Trigonometric and Hyperbolic Functions::
18406 * Advanced Math Functions::
18409 * Combinatorial Functions::
18410 * Probability Distribution Functions::
18413 @node Logarithmic Functions, Trigonometric and Hyperbolic Functions, Scientific Functions, Scientific Functions
18414 @section Logarithmic Functions
18424 The shift-@kbd{L} (@code{calc-ln}) [@code{ln}] command computes the natural
18425 logarithm of the real or complex number on the top of the stack. With
18426 the Inverse flag it computes the exponential function instead, although
18427 this is redundant with the @kbd{E} command.
18436 The shift-@kbd{E} (@code{calc-exp}) [@code{exp}] command computes the
18437 exponential, i.e., @expr{e} raised to the power of the number on the stack.
18438 The meanings of the Inverse and Hyperbolic flags follow from those for
18439 the @code{calc-ln} command.
18454 The @kbd{H L} (@code{calc-log10}) [@code{log10}] command computes the common
18455 (base-10) logarithm of a number. (With the Inverse flag [@code{exp10}],
18456 it raises ten to a given power.) Note that the common logarithm of a
18457 complex number is computed by taking the natural logarithm and dividing
18459 @texline @math{\ln10}.
18460 @infoline @expr{ln(10)}.
18467 The @kbd{B} (@code{calc-log}) [@code{log}] command computes a logarithm
18468 to any base. For example, @kbd{1024 @key{RET} 2 B} produces 10, since
18469 @texline @math{2^{10} = 1024}.
18470 @infoline @expr{2^10 = 1024}.
18471 In certain cases like @samp{log(3,9)}, the result
18472 will be either @expr{1:2} or @expr{0.5} depending on the current Fraction
18473 mode setting. With the Inverse flag [@code{alog}], this command is
18474 similar to @kbd{^} except that the order of the arguments is reversed.
18479 The @kbd{f I} (@code{calc-ilog}) [@code{ilog}] command computes the
18480 integer logarithm of a number to any base. The number and the base must
18481 themselves be positive integers. This is the true logarithm, rounded
18482 down to an integer. Thus @kbd{ilog(x,10)} is 3 for all @expr{x} in the
18483 range from 1000 to 9999. If both arguments are positive integers, exact
18484 integer arithmetic is used; otherwise, this is equivalent to
18485 @samp{floor(log(x,b))}.
18490 The @kbd{f E} (@code{calc-expm1}) [@code{expm1}] command computes
18491 @texline @math{e^x - 1},
18492 @infoline @expr{exp(x)-1},
18493 but using an algorithm that produces a more accurate
18494 answer when the result is close to zero, i.e., when
18495 @texline @math{e^x}
18496 @infoline @expr{exp(x)}
18502 The @kbd{f L} (@code{calc-lnp1}) [@code{lnp1}] command computes
18503 @texline @math{\ln(x+1)},
18504 @infoline @expr{ln(x+1)},
18505 producing a more accurate answer when @expr{x} is close to zero.
18507 @node Trigonometric and Hyperbolic Functions, Advanced Math Functions, Logarithmic Functions, Scientific Functions
18508 @section Trigonometric/Hyperbolic Functions
18514 The shift-@kbd{S} (@code{calc-sin}) [@code{sin}] command computes the sine
18515 of an angle or complex number. If the input is an HMS form, it is interpreted
18516 as degrees-minutes-seconds; otherwise, the input is interpreted according
18517 to the current angular mode. It is best to use Radians mode when operating
18518 on complex numbers.
18520 Calc's ``units'' mechanism includes angular units like @code{deg},
18521 @code{rad}, and @code{grad}. While @samp{sin(45 deg)} is not evaluated
18522 all the time, the @kbd{u s} (@code{calc-simplify-units}) command will
18523 simplify @samp{sin(45 deg)} by taking the sine of 45 degrees, regardless
18524 of the current angular mode. @xref{Basic Operations on Units}.
18526 Also, the symbolic variable @code{pi} is not ordinarily recognized in
18527 arguments to trigonometric functions, as in @samp{sin(3 pi / 4)}, but
18528 the @kbd{a s} (@code{calc-simplify}) command recognizes many such
18529 formulas when the current angular mode is Radians @emph{and} Symbolic
18530 mode is enabled; this example would be replaced by @samp{sqrt(2) / 2}.
18531 @xref{Symbolic Mode}. Beware, this simplification occurs even if you
18532 have stored a different value in the variable @samp{pi}; this is one
18533 reason why changing built-in variables is a bad idea. Arguments of
18534 the form @expr{x} plus a multiple of @cpiover{2} are also simplified.
18535 Calc includes similar formulas for @code{cos} and @code{tan}.
18537 The @kbd{a s} command knows all angles which are integer multiples of
18538 @cpiover{12}, @cpiover{10}, or @cpiover{8} radians. In Degrees mode,
18539 analogous simplifications occur for integer multiples of 15 or 18
18540 degrees, and for arguments plus multiples of 90 degrees.
18543 @pindex calc-arcsin
18545 With the Inverse flag, @code{calc-sin} computes an arcsine. This is also
18546 available as the @code{calc-arcsin} command or @code{arcsin} algebraic
18547 function. The returned argument is converted to degrees, radians, or HMS
18548 notation depending on the current angular mode.
18554 @pindex calc-arcsinh
18556 With the Hyperbolic flag, @code{calc-sin} computes the hyperbolic
18557 sine, also available as @code{calc-sinh} [@code{sinh}]. With the
18558 Hyperbolic and Inverse flags, it computes the hyperbolic arcsine
18559 (@code{calc-arcsinh}) [@code{arcsinh}].
18568 @pindex calc-arccos
18586 @pindex calc-arccosh
18604 @pindex calc-arctan
18622 @pindex calc-arctanh
18627 The shift-@kbd{C} (@code{calc-cos}) [@code{cos}] command computes the cosine
18628 of an angle or complex number, and shift-@kbd{T} (@code{calc-tan}) [@code{tan}]
18629 computes the tangent, along with all the various inverse and hyperbolic
18630 variants of these functions.
18633 @pindex calc-arctan2
18635 The @kbd{f T} (@code{calc-arctan2}) [@code{arctan2}] command takes two
18636 numbers from the stack and computes the arc tangent of their ratio. The
18637 result is in the full range from @mathit{-180} (exclusive) to @mathit{+180}
18638 (inclusive) degrees, or the analogous range in radians. A similar
18639 result would be obtained with @kbd{/} followed by @kbd{I T}, but the
18640 value would only be in the range from @mathit{-90} to @mathit{+90} degrees
18641 since the division loses information about the signs of the two
18642 components, and an error might result from an explicit division by zero
18643 which @code{arctan2} would avoid. By (arbitrary) definition,
18644 @samp{arctan2(0,0)=0}.
18646 @pindex calc-sincos
18658 The @code{calc-sincos} [@code{sincos}] command computes the sine and
18659 cosine of a number, returning them as a vector of the form
18660 @samp{[@var{cos}, @var{sin}]}.
18661 With the Inverse flag [@code{arcsincos}], this command takes a two-element
18662 vector as an argument and computes @code{arctan2} of the elements.
18663 (This command does not accept the Hyperbolic flag.)
18677 The remaining trigonometric functions, @code{calc-sec} [@code{sec}],
18678 @code{calc-csc} [@code{csc}] and @code{calc-sec} [@code{sec}], are also
18679 available. With the Hyperbolic flag, these compute their hyperbolic
18680 counterparts, which are also available separately as @code{calc-sech}
18681 [@code{sech}], @code{calc-csch} [@code{csch}] and @code{calc-sech}
18682 [@code{sech}]. (These commmands do not accept the Inverse flag.)
18684 @node Advanced Math Functions, Branch Cuts, Trigonometric and Hyperbolic Functions, Scientific Functions
18685 @section Advanced Mathematical Functions
18688 Calc can compute a variety of less common functions that arise in
18689 various branches of mathematics. All of the functions described in
18690 this section allow arbitrary complex arguments and, except as noted,
18691 will work to arbitrarily large precisions. They can not at present
18692 handle error forms or intervals as arguments.
18694 NOTE: These functions are still experimental. In particular, their
18695 accuracy is not guaranteed in all domains. It is advisable to set the
18696 current precision comfortably higher than you actually need when
18697 using these functions. Also, these functions may be impractically
18698 slow for some values of the arguments.
18703 The @kbd{f g} (@code{calc-gamma}) [@code{gamma}] command computes the Euler
18704 gamma function. For positive integer arguments, this is related to the
18705 factorial function: @samp{gamma(n+1) = fact(n)}. For general complex
18706 arguments the gamma function can be defined by the following definite
18708 @texline @math{\Gamma(a) = \int_0^\infty t^{a-1} e^t dt}.
18709 @infoline @expr{gamma(a) = integ(t^(a-1) exp(t), t, 0, inf)}.
18710 (The actual implementation uses far more efficient computational methods.)
18726 @pindex calc-inc-gamma
18739 The @kbd{f G} (@code{calc-inc-gamma}) [@code{gammaP}] command computes
18740 the incomplete gamma function, denoted @samp{P(a,x)}. This is defined by
18742 @texline @math{P(a,x) = \left( \int_0^x t^{a-1} e^t dt \right) / \Gamma(a)}.
18743 @infoline @expr{gammaP(a,x) = integ(t^(a-1) exp(t), t, 0, x) / gamma(a)}.
18744 This implies that @samp{gammaP(a,inf) = 1} for any @expr{a} (see the
18745 definition of the normal gamma function).
18747 Several other varieties of incomplete gamma function are defined.
18748 The complement of @expr{P(a,x)}, called @expr{Q(a,x) = 1-P(a,x)} by
18749 some authors, is computed by the @kbd{I f G} [@code{gammaQ}] command.
18750 You can think of this as taking the other half of the integral, from
18751 @expr{x} to infinity.
18754 The functions corresponding to the integrals that define @expr{P(a,x)}
18755 and @expr{Q(a,x)} but without the normalizing @expr{1/gamma(a)}
18756 factor are called @expr{g(a,x)} and @expr{G(a,x)}, respectively
18757 (where @expr{g} and @expr{G} represent the lower- and upper-case Greek
18758 letter gamma). You can obtain these using the @kbd{H f G} [@code{gammag}]
18759 and @kbd{H I f G} [@code{gammaG}] commands.
18763 The functions corresponding to the integrals that define $P(a,x)$
18764 and $Q(a,x)$ but without the normalizing $1/\Gamma(a)$
18765 factor are called $\gamma(a,x)$ and $\Gamma(a,x)$, respectively.
18766 You can obtain these using the \kbd{H f G} [\code{gammag}] and
18767 \kbd{I H f G} [\code{gammaG}] commands.
18773 The @kbd{f b} (@code{calc-beta}) [@code{beta}] command computes the
18774 Euler beta function, which is defined in terms of the gamma function as
18775 @texline @math{B(a,b) = \Gamma(a) \Gamma(b) / \Gamma(a+b)},
18776 @infoline @expr{beta(a,b) = gamma(a) gamma(b) / gamma(a+b)},
18778 @texline @math{B(a,b) = \int_0^1 t^{a-1} (1-t)^{b-1} dt}.
18779 @infoline @expr{beta(a,b) = integ(t^(a-1) (1-t)^(b-1), t, 0, 1)}.
18783 @pindex calc-inc-beta
18786 The @kbd{f B} (@code{calc-inc-beta}) [@code{betaI}] command computes
18787 the incomplete beta function @expr{I(x,a,b)}. It is defined by
18788 @texline @math{I(x,a,b) = \left( \int_0^x t^{a-1} (1-t)^{b-1} dt \right) / B(a,b)}.
18789 @infoline @expr{betaI(x,a,b) = integ(t^(a-1) (1-t)^(b-1), t, 0, x) / beta(a,b)}.
18790 Once again, the @kbd{H} (hyperbolic) prefix gives the corresponding
18791 un-normalized version [@code{betaB}].
18798 The @kbd{f e} (@code{calc-erf}) [@code{erf}] command computes the
18800 @texline @math{\hbox{erf}(x) = {2 \over \sqrt{\pi}} \int_0^x e^{-t^2} dt}.
18801 @infoline @expr{erf(x) = 2 integ(exp(-(t^2)), t, 0, x) / sqrt(pi)}.
18802 The complementary error function @kbd{I f e} (@code{calc-erfc}) [@code{erfc}]
18803 is the corresponding integral from @samp{x} to infinity; the sum
18804 @texline @math{\hbox{erf}(x) + \hbox{erfc}(x) = 1}.
18805 @infoline @expr{erf(x) + erfc(x) = 1}.
18809 @pindex calc-bessel-J
18810 @pindex calc-bessel-Y
18813 The @kbd{f j} (@code{calc-bessel-J}) [@code{besJ}] and @kbd{f y}
18814 (@code{calc-bessel-Y}) [@code{besY}] commands compute the Bessel
18815 functions of the first and second kinds, respectively.
18816 In @samp{besJ(n,x)} and @samp{besY(n,x)} the ``order'' parameter
18817 @expr{n} is often an integer, but is not required to be one.
18818 Calc's implementation of the Bessel functions currently limits the
18819 precision to 8 digits, and may not be exact even to that precision.
18822 @node Branch Cuts, Random Numbers, Advanced Math Functions, Scientific Functions
18823 @section Branch Cuts and Principal Values
18826 @cindex Branch cuts
18827 @cindex Principal values
18828 All of the logarithmic, trigonometric, and other scientific functions are
18829 defined for complex numbers as well as for reals.
18830 This section describes the values
18831 returned in cases where the general result is a family of possible values.
18832 Calc follows section 12.5.3 of Steele's @dfn{Common Lisp, the Language},
18833 second edition, in these matters. This section will describe each
18834 function briefly; for a more detailed discussion (including some nifty
18835 diagrams), consult Steele's book.
18837 Note that the branch cuts for @code{arctan} and @code{arctanh} were
18838 changed between the first and second editions of Steele. Versions of
18839 Calc starting with 2.00 follow the second edition.
18841 The new branch cuts exactly match those of the HP-28/48 calculators.
18842 They also match those of Mathematica 1.2, except that Mathematica's
18843 @code{arctan} cut is always in the right half of the complex plane,
18844 and its @code{arctanh} cut is always in the top half of the plane.
18845 Calc's cuts are continuous with quadrants I and III for @code{arctan},
18846 or II and IV for @code{arctanh}.
18848 Note: The current implementations of these functions with complex arguments
18849 are designed with proper behavior around the branch cuts in mind, @emph{not}
18850 efficiency or accuracy. You may need to increase the floating precision
18851 and wait a while to get suitable answers from them.
18853 For @samp{sqrt(a+bi)}: When @expr{a<0} and @expr{b} is small but positive
18854 or zero, the result is close to the @expr{+i} axis. For @expr{b} small and
18855 negative, the result is close to the @expr{-i} axis. The result always lies
18856 in the right half of the complex plane.
18858 For @samp{ln(a+bi)}: The real part is defined as @samp{ln(abs(a+bi))}.
18859 The imaginary part is defined as @samp{arg(a+bi) = arctan2(b,a)}.
18860 Thus the branch cuts for @code{sqrt} and @code{ln} both lie on the
18861 negative real axis.
18863 The following table describes these branch cuts in another way.
18864 If the real and imaginary parts of @expr{z} are as shown, then
18865 the real and imaginary parts of @expr{f(z)} will be as shown.
18866 Here @code{eps} stands for a small positive value; each
18867 occurrence of @code{eps} may stand for a different small value.
18871 ----------------------------------------
18874 -, +eps +eps, + +eps, +
18875 -, -eps +eps, - +eps, -
18878 For @samp{z1^z2}: This is defined by @samp{exp(ln(z1)*z2)}.
18879 One interesting consequence of this is that @samp{(-8)^1:3} does
18880 not evaluate to @mathit{-2} as you might expect, but to the complex
18881 number @expr{(1., 1.732)}. Both of these are valid cube roots
18882 of @mathit{-8} (as is @expr{(1., -1.732)}); Calc chooses a perhaps
18883 less-obvious root for the sake of mathematical consistency.
18885 For @samp{arcsin(z)}: This is defined by @samp{-i*ln(i*z + sqrt(1-z^2))}.
18886 The branch cuts are on the real axis, less than @mathit{-1} and greater than 1.
18888 For @samp{arccos(z)}: This is defined by @samp{-i*ln(z + i*sqrt(1-z^2))},
18889 or equivalently by @samp{pi/2 - arcsin(z)}. The branch cuts are on
18890 the real axis, less than @mathit{-1} and greater than 1.
18892 For @samp{arctan(z)}: This is defined by
18893 @samp{(ln(1+i*z) - ln(1-i*z)) / (2*i)}. The branch cuts are on the
18894 imaginary axis, below @expr{-i} and above @expr{i}.
18896 For @samp{arcsinh(z)}: This is defined by @samp{ln(z + sqrt(1+z^2))}.
18897 The branch cuts are on the imaginary axis, below @expr{-i} and
18900 For @samp{arccosh(z)}: This is defined by
18901 @samp{ln(z + (z+1)*sqrt((z-1)/(z+1)))}. The branch cut is on the
18902 real axis less than 1.
18904 For @samp{arctanh(z)}: This is defined by @samp{(ln(1+z) - ln(1-z)) / 2}.
18905 The branch cuts are on the real axis, less than @mathit{-1} and greater than 1.
18907 The following tables for @code{arcsin}, @code{arccos}, and
18908 @code{arctan} assume the current angular mode is Radians. The
18909 hyperbolic functions operate independently of the angular mode.
18912 z arcsin(z) arccos(z)
18913 -------------------------------------------------------
18914 (-1..1), 0 (-pi/2..pi/2), 0 (0..pi), 0
18915 (-1..1), +eps (-pi/2..pi/2), +eps (0..pi), -eps
18916 (-1..1), -eps (-pi/2..pi/2), -eps (0..pi), +eps
18917 <-1, 0 -pi/2, + pi, -
18918 <-1, +eps -pi/2 + eps, + pi - eps, -
18919 <-1, -eps -pi/2 + eps, - pi - eps, +
18921 >1, +eps pi/2 - eps, + +eps, -
18922 >1, -eps pi/2 - eps, - +eps, +
18926 z arccosh(z) arctanh(z)
18927 -----------------------------------------------------
18928 (-1..1), 0 0, (0..pi) any, 0
18929 (-1..1), +eps +eps, (0..pi) any, +eps
18930 (-1..1), -eps +eps, (-pi..0) any, -eps
18931 <-1, 0 +, pi -, pi/2
18932 <-1, +eps +, pi - eps -, pi/2 - eps
18933 <-1, -eps +, -pi + eps -, -pi/2 + eps
18934 >1, 0 +, 0 +, -pi/2
18935 >1, +eps +, +eps +, pi/2 - eps
18936 >1, -eps +, -eps +, -pi/2 + eps
18940 z arcsinh(z) arctan(z)
18941 -----------------------------------------------------
18942 0, (-1..1) 0, (-pi/2..pi/2) 0, any
18943 0, <-1 -, -pi/2 -pi/2, -
18944 +eps, <-1 +, -pi/2 + eps pi/2 - eps, -
18945 -eps, <-1 -, -pi/2 + eps -pi/2 + eps, -
18946 0, >1 +, pi/2 pi/2, +
18947 +eps, >1 +, pi/2 - eps pi/2 - eps, +
18948 -eps, >1 -, pi/2 - eps -pi/2 + eps, +
18951 Finally, the following identities help to illustrate the relationship
18952 between the complex trigonometric and hyperbolic functions. They
18953 are valid everywhere, including on the branch cuts.
18956 sin(i*z) = i*sinh(z) arcsin(i*z) = i*arcsinh(z)
18957 cos(i*z) = cosh(z) arcsinh(i*z) = i*arcsin(z)
18958 tan(i*z) = i*tanh(z) arctan(i*z) = i*arctanh(z)
18959 sinh(i*z) = i*sin(z) cosh(i*z) = cos(z)
18962 The ``advanced math'' functions (gamma, Bessel, etc.@:) are also defined
18963 for general complex arguments, but their branch cuts and principal values
18964 are not rigorously specified at present.
18966 @node Random Numbers, Combinatorial Functions, Branch Cuts, Scientific Functions
18967 @section Random Numbers
18971 @pindex calc-random
18973 The @kbd{k r} (@code{calc-random}) [@code{random}] command produces
18974 random numbers of various sorts.
18976 Given a positive numeric prefix argument @expr{M}, it produces a random
18977 integer @expr{N} in the range
18978 @texline @math{0 \le N < M}.
18979 @infoline @expr{0 <= N < M}.
18980 Each of the @expr{M} values appears with equal probability.
18982 With no numeric prefix argument, the @kbd{k r} command takes its argument
18983 from the stack instead. Once again, if this is a positive integer @expr{M}
18984 the result is a random integer less than @expr{M}. However, note that
18985 while numeric prefix arguments are limited to six digits or so, an @expr{M}
18986 taken from the stack can be arbitrarily large. If @expr{M} is negative,
18987 the result is a random integer in the range
18988 @texline @math{M < N \le 0}.
18989 @infoline @expr{M < N <= 0}.
18991 If the value on the stack is a floating-point number @expr{M}, the result
18992 is a random floating-point number @expr{N} in the range
18993 @texline @math{0 \le N < M}
18994 @infoline @expr{0 <= N < M}
18996 @texline @math{M < N \le 0},
18997 @infoline @expr{M < N <= 0},
18998 according to the sign of @expr{M}.
19000 If @expr{M} is zero, the result is a Gaussian-distributed random real
19001 number; the distribution has a mean of zero and a standard deviation
19002 of one. The algorithm used generates random numbers in pairs; thus,
19003 every other call to this function will be especially fast.
19005 If @expr{M} is an error form
19006 @texline @math{m} @code{+/-} @math{\sigma}
19007 @infoline @samp{m +/- s}
19009 @texline @math{\sigma}
19011 are both real numbers, the result uses a Gaussian distribution with mean
19012 @var{m} and standard deviation
19013 @texline @math{\sigma}.
19016 If @expr{M} is an interval form, the lower and upper bounds specify the
19017 acceptable limits of the random numbers. If both bounds are integers,
19018 the result is a random integer in the specified range. If either bound
19019 is floating-point, the result is a random real number in the specified
19020 range. If the interval is open at either end, the result will be sure
19021 not to equal that end value. (This makes a big difference for integer
19022 intervals, but for floating-point intervals it's relatively minor:
19023 with a precision of 6, @samp{random([1.0..2.0))} will return any of one
19024 million numbers from 1.00000 to 1.99999; @samp{random([1.0..2.0])} may
19025 additionally return 2.00000, but the probability of this happening is
19028 If @expr{M} is a vector, the result is one element taken at random from
19029 the vector. All elements of the vector are given equal probabilities.
19032 The sequence of numbers produced by @kbd{k r} is completely random by
19033 default, i.e., the sequence is seeded each time you start Calc using
19034 the current time and other information. You can get a reproducible
19035 sequence by storing a particular ``seed value'' in the Calc variable
19036 @code{RandSeed}. Any integer will do for a seed; integers of from 1
19037 to 12 digits are good. If you later store a different integer into
19038 @code{RandSeed}, Calc will switch to a different pseudo-random
19039 sequence. If you ``unstore'' @code{RandSeed}, Calc will re-seed itself
19040 from the current time. If you store the same integer that you used
19041 before back into @code{RandSeed}, you will get the exact same sequence
19042 of random numbers as before.
19044 @pindex calc-rrandom
19045 The @code{calc-rrandom} command (not on any key) produces a random real
19046 number between zero and one. It is equivalent to @samp{random(1.0)}.
19049 @pindex calc-random-again
19050 The @kbd{k a} (@code{calc-random-again}) command produces another random
19051 number, re-using the most recent value of @expr{M}. With a numeric
19052 prefix argument @var{n}, it produces @var{n} more random numbers using
19053 that value of @expr{M}.
19056 @pindex calc-shuffle
19058 The @kbd{k h} (@code{calc-shuffle}) command produces a vector of several
19059 random values with no duplicates. The value on the top of the stack
19060 specifies the set from which the random values are drawn, and may be any
19061 of the @expr{M} formats described above. The numeric prefix argument
19062 gives the length of the desired list. (If you do not provide a numeric
19063 prefix argument, the length of the list is taken from the top of the
19064 stack, and @expr{M} from second-to-top.)
19066 If @expr{M} is a floating-point number, zero, or an error form (so
19067 that the random values are being drawn from the set of real numbers)
19068 there is little practical difference between using @kbd{k h} and using
19069 @kbd{k r} several times. But if the set of possible values consists
19070 of just a few integers, or the elements of a vector, then there is
19071 a very real chance that multiple @kbd{k r}'s will produce the same
19072 number more than once. The @kbd{k h} command produces a vector whose
19073 elements are always distinct. (Actually, there is a slight exception:
19074 If @expr{M} is a vector, no given vector element will be drawn more
19075 than once, but if several elements of @expr{M} are equal, they may
19076 each make it into the result vector.)
19078 One use of @kbd{k h} is to rearrange a list at random. This happens
19079 if the prefix argument is equal to the number of values in the list:
19080 @kbd{[1, 1.5, 2, 2.5, 3] 5 k h} might produce the permuted list
19081 @samp{[2.5, 1, 1.5, 3, 2]}. As a convenient feature, if the argument
19082 @var{n} is negative it is replaced by the size of the set represented
19083 by @expr{M}. Naturally, this is allowed only when @expr{M} specifies
19084 a small discrete set of possibilities.
19086 To do the equivalent of @kbd{k h} but with duplications allowed,
19087 given @expr{M} on the stack and with @var{n} just entered as a numeric
19088 prefix, use @kbd{v b} to build a vector of copies of @expr{M}, then use
19089 @kbd{V M k r} to ``map'' the normal @kbd{k r} function over the
19090 elements of this vector. @xref{Matrix Functions}.
19093 * Random Number Generator:: (Complete description of Calc's algorithm)
19096 @node Random Number Generator, , Random Numbers, Random Numbers
19097 @subsection Random Number Generator
19099 Calc's random number generator uses several methods to ensure that
19100 the numbers it produces are highly random. Knuth's @emph{Art of
19101 Computer Programming}, Volume II, contains a thorough description
19102 of the theory of random number generators and their measurement and
19105 If @code{RandSeed} has no stored value, Calc calls Emacs' built-in
19106 @code{random} function to get a stream of random numbers, which it
19107 then treats in various ways to avoid problems inherent in the simple
19108 random number generators that many systems use to implement @code{random}.
19110 When Calc's random number generator is first invoked, it ``seeds''
19111 the low-level random sequence using the time of day, so that the
19112 random number sequence will be different every time you use Calc.
19114 Since Emacs Lisp doesn't specify the range of values that will be
19115 returned by its @code{random} function, Calc exercises the function
19116 several times to estimate the range. When Calc subsequently uses
19117 the @code{random} function, it takes only 10 bits of the result
19118 near the most-significant end. (It avoids at least the bottom
19119 four bits, preferably more, and also tries to avoid the top two
19120 bits.) This strategy works well with the linear congruential
19121 generators that are typically used to implement @code{random}.
19123 If @code{RandSeed} contains an integer, Calc uses this integer to
19124 seed an ``additive congruential'' method (Knuth's algorithm 3.2.2A,
19126 @texline @math{X_{n-55} - X_{n-24}}.
19127 @infoline @expr{X_n-55 - X_n-24}).
19128 This method expands the seed
19129 value into a large table which is maintained internally; the variable
19130 @code{RandSeed} is changed from, e.g., 42 to the vector @expr{[42]}
19131 to indicate that the seed has been absorbed into this table. When
19132 @code{RandSeed} contains a vector, @kbd{k r} and related commands
19133 continue to use the same internal table as last time. There is no
19134 way to extract the complete state of the random number generator
19135 so that you can restart it from any point; you can only restart it
19136 from the same initial seed value. A simple way to restart from the
19137 same seed is to type @kbd{s r RandSeed} to get the seed vector,
19138 @kbd{v u} to unpack it back into a number, then @kbd{s t RandSeed}
19139 to reseed the generator with that number.
19141 Calc uses a ``shuffling'' method as described in algorithm 3.2.2B
19142 of Knuth. It fills a table with 13 random 10-bit numbers. Then,
19143 to generate a new random number, it uses the previous number to
19144 index into the table, picks the value it finds there as the new
19145 random number, then replaces that table entry with a new value
19146 obtained from a call to the base random number generator (either
19147 the additive congruential generator or the @code{random} function
19148 supplied by the system). If there are any flaws in the base
19149 generator, shuffling will tend to even them out. But if the system
19150 provides an excellent @code{random} function, shuffling will not
19151 damage its randomness.
19153 To create a random integer of a certain number of digits, Calc
19154 builds the integer three decimal digits at a time. For each group
19155 of three digits, Calc calls its 10-bit shuffling random number generator
19156 (which returns a value from 0 to 1023); if the random value is 1000
19157 or more, Calc throws it out and tries again until it gets a suitable
19160 To create a random floating-point number with precision @var{p}, Calc
19161 simply creates a random @var{p}-digit integer and multiplies by
19162 @texline @math{10^{-p}}.
19163 @infoline @expr{10^-p}.
19164 The resulting random numbers should be very clean, but note
19165 that relatively small numbers will have few significant random digits.
19166 In other words, with a precision of 12, you will occasionally get
19167 numbers on the order of
19168 @texline @math{10^{-9}}
19169 @infoline @expr{10^-9}
19171 @texline @math{10^{-10}},
19172 @infoline @expr{10^-10},
19173 but those numbers will only have two or three random digits since they
19174 correspond to small integers times
19175 @texline @math{10^{-12}}.
19176 @infoline @expr{10^-12}.
19178 To create a random integer in the interval @samp{[0 .. @var{m})}, Calc
19179 counts the digits in @var{m}, creates a random integer with three
19180 additional digits, then reduces modulo @var{m}. Unless @var{m} is a
19181 power of ten the resulting values will be very slightly biased toward
19182 the lower numbers, but this bias will be less than 0.1%. (For example,
19183 if @var{m} is 42, Calc will reduce a random integer less than 100000
19184 modulo 42 to get a result less than 42. It is easy to show that the
19185 numbers 40 and 41 will be only 2380/2381 as likely to result from this
19186 modulo operation as numbers 39 and below.) If @var{m} is a power of
19187 ten, however, the numbers should be completely unbiased.
19189 The Gaussian random numbers generated by @samp{random(0.0)} use the
19190 ``polar'' method described in Knuth section 3.4.1C. This method
19191 generates a pair of Gaussian random numbers at a time, so only every
19192 other call to @samp{random(0.0)} will require significant calculations.
19194 @node Combinatorial Functions, Probability Distribution Functions, Random Numbers, Scientific Functions
19195 @section Combinatorial Functions
19198 Commands relating to combinatorics and number theory begin with the
19199 @kbd{k} key prefix.
19204 The @kbd{k g} (@code{calc-gcd}) [@code{gcd}] command computes the
19205 Greatest Common Divisor of two integers. It also accepts fractions;
19206 the GCD of two fractions is defined by taking the GCD of the
19207 numerators, and the LCM of the denominators. This definition is
19208 consistent with the idea that @samp{a / gcd(a,x)} should yield an
19209 integer for any @samp{a} and @samp{x}. For other types of arguments,
19210 the operation is left in symbolic form.
19215 The @kbd{k l} (@code{calc-lcm}) [@code{lcm}] command computes the
19216 Least Common Multiple of two integers or fractions. The product of
19217 the LCM and GCD of two numbers is equal to the product of the
19221 @pindex calc-extended-gcd
19223 The @kbd{k E} (@code{calc-extended-gcd}) [@code{egcd}] command computes
19224 the GCD of two integers @expr{x} and @expr{y} and returns a vector
19225 @expr{[g, a, b]} where
19226 @texline @math{g = \gcd(x,y) = a x + b y}.
19227 @infoline @expr{g = gcd(x,y) = a x + b y}.
19230 @pindex calc-factorial
19236 The @kbd{!} (@code{calc-factorial}) [@code{fact}] command computes the
19237 factorial of the number at the top of the stack. If the number is an
19238 integer, the result is an exact integer. If the number is an
19239 integer-valued float, the result is a floating-point approximation. If
19240 the number is a non-integral real number, the generalized factorial is used,
19241 as defined by the Euler Gamma function. Please note that computation of
19242 large factorials can be slow; using floating-point format will help
19243 since fewer digits must be maintained. The same is true of many of
19244 the commands in this section.
19247 @pindex calc-double-factorial
19253 The @kbd{k d} (@code{calc-double-factorial}) [@code{dfact}] command
19254 computes the ``double factorial'' of an integer. For an even integer,
19255 this is the product of even integers from 2 to @expr{N}. For an odd
19256 integer, this is the product of odd integers from 3 to @expr{N}. If
19257 the argument is an integer-valued float, the result is a floating-point
19258 approximation. This function is undefined for negative even integers.
19259 The notation @expr{N!!} is also recognized for double factorials.
19262 @pindex calc-choose
19264 The @kbd{k c} (@code{calc-choose}) [@code{choose}] command computes the
19265 binomial coefficient @expr{N}-choose-@expr{M}, where @expr{M} is the number
19266 on the top of the stack and @expr{N} is second-to-top. If both arguments
19267 are integers, the result is an exact integer. Otherwise, the result is a
19268 floating-point approximation. The binomial coefficient is defined for all
19270 @texline @math{N! \over M! (N-M)!\,}.
19271 @infoline @expr{N! / M! (N-M)!}.
19277 The @kbd{H k c} (@code{calc-perm}) [@code{perm}] command computes the
19278 number-of-permutations function @expr{N! / (N-M)!}.
19281 The \kbd{H k c} (\code{calc-perm}) [\code{perm}] command computes the
19282 number-of-perm\-utations function $N! \over (N-M)!\,$.
19287 @pindex calc-bernoulli-number
19289 The @kbd{k b} (@code{calc-bernoulli-number}) [@code{bern}] command
19290 computes a given Bernoulli number. The value at the top of the stack
19291 is a nonnegative integer @expr{n} that specifies which Bernoulli number
19292 is desired. The @kbd{H k b} command computes a Bernoulli polynomial,
19293 taking @expr{n} from the second-to-top position and @expr{x} from the
19294 top of the stack. If @expr{x} is a variable or formula the result is
19295 a polynomial in @expr{x}; if @expr{x} is a number the result is a number.
19299 @pindex calc-euler-number
19301 The @kbd{k e} (@code{calc-euler-number}) [@code{euler}] command similarly
19302 computes an Euler number, and @w{@kbd{H k e}} computes an Euler polynomial.
19303 Bernoulli and Euler numbers occur in the Taylor expansions of several
19308 @pindex calc-stirling-number
19311 The @kbd{k s} (@code{calc-stirling-number}) [@code{stir1}] command
19312 computes a Stirling number of the first
19313 @texline kind@tie{}@math{n \brack m},
19315 given two integers @expr{n} and @expr{m} on the stack. The @kbd{H k s}
19316 [@code{stir2}] command computes a Stirling number of the second
19317 @texline kind@tie{}@math{n \brace m}.
19319 These are the number of @expr{m}-cycle permutations of @expr{n} objects,
19320 and the number of ways to partition @expr{n} objects into @expr{m}
19321 non-empty sets, respectively.
19324 @pindex calc-prime-test
19326 The @kbd{k p} (@code{calc-prime-test}) command checks if the integer on
19327 the top of the stack is prime. For integers less than eight million, the
19328 answer is always exact and reasonably fast. For larger integers, a
19329 probabilistic method is used (see Knuth vol. II, section 4.5.4, algorithm P).
19330 The number is first checked against small prime factors (up to 13). Then,
19331 any number of iterations of the algorithm are performed. Each step either
19332 discovers that the number is non-prime, or substantially increases the
19333 certainty that the number is prime. After a few steps, the chance that
19334 a number was mistakenly described as prime will be less than one percent.
19335 (Indeed, this is a worst-case estimate of the probability; in practice
19336 even a single iteration is quite reliable.) After the @kbd{k p} command,
19337 the number will be reported as definitely prime or non-prime if possible,
19338 or otherwise ``probably'' prime with a certain probability of error.
19344 The normal @kbd{k p} command performs one iteration of the primality
19345 test. Pressing @kbd{k p} repeatedly for the same integer will perform
19346 additional iterations. Also, @kbd{k p} with a numeric prefix performs
19347 the specified number of iterations. There is also an algebraic function
19348 @samp{prime(n)} or @samp{prime(n,iters)} which returns 1 if @expr{n}
19349 is (probably) prime and 0 if not.
19352 @pindex calc-prime-factors
19354 The @kbd{k f} (@code{calc-prime-factors}) [@code{prfac}] command
19355 attempts to decompose an integer into its prime factors. For numbers up
19356 to 25 million, the answer is exact although it may take some time. The
19357 result is a vector of the prime factors in increasing order. For larger
19358 inputs, prime factors above 5000 may not be found, in which case the
19359 last number in the vector will be an unfactored integer greater than 25
19360 million (with a warning message). For negative integers, the first
19361 element of the list will be @mathit{-1}. For inputs @mathit{-1}, @mathit{0}, and
19362 @mathit{1}, the result is a list of the same number.
19365 @pindex calc-next-prime
19367 @mindex nextpr@idots
19370 The @kbd{k n} (@code{calc-next-prime}) [@code{nextprime}] command finds
19371 the next prime above a given number. Essentially, it searches by calling
19372 @code{calc-prime-test} on successive integers until it finds one that
19373 passes the test. This is quite fast for integers less than eight million,
19374 but once the probabilistic test comes into play the search may be rather
19375 slow. Ordinarily this command stops for any prime that passes one iteration
19376 of the primality test. With a numeric prefix argument, a number must pass
19377 the specified number of iterations before the search stops. (This only
19378 matters when searching above eight million.) You can always use additional
19379 @kbd{k p} commands to increase your certainty that the number is indeed
19383 @pindex calc-prev-prime
19385 @mindex prevpr@idots
19388 The @kbd{I k n} (@code{calc-prev-prime}) [@code{prevprime}] command
19389 analogously finds the next prime less than a given number.
19392 @pindex calc-totient
19394 The @kbd{k t} (@code{calc-totient}) [@code{totient}] command computes the
19396 @texline function@tie{}@math{\phi(n)},
19397 @infoline function,
19398 the number of integers less than @expr{n} which
19399 are relatively prime to @expr{n}.
19402 @pindex calc-moebius
19404 The @kbd{k m} (@code{calc-moebius}) [@code{moebius}] command computes the
19405 @texline M@"obius @math{\mu}
19406 @infoline Moebius ``mu''
19407 function. If the input number is a product of @expr{k}
19408 distinct factors, this is @expr{(-1)^k}. If the input number has any
19409 duplicate factors (i.e., can be divided by the same prime more than once),
19410 the result is zero.
19412 @node Probability Distribution Functions, , Combinatorial Functions, Scientific Functions
19413 @section Probability Distribution Functions
19416 The functions in this section compute various probability distributions.
19417 For continuous distributions, this is the integral of the probability
19418 density function from @expr{x} to infinity. (These are the ``upper
19419 tail'' distribution functions; there are also corresponding ``lower
19420 tail'' functions which integrate from minus infinity to @expr{x}.)
19421 For discrete distributions, the upper tail function gives the sum
19422 from @expr{x} to infinity; the lower tail function gives the sum
19423 from minus infinity up to, but not including,@w{ }@expr{x}.
19425 To integrate from @expr{x} to @expr{y}, just use the distribution
19426 function twice and subtract. For example, the probability that a
19427 Gaussian random variable with mean 2 and standard deviation 1 will
19428 lie in the range from 2.5 to 2.8 is @samp{utpn(2.5,2,1) - utpn(2.8,2,1)}
19429 (``the probability that it is greater than 2.5, but not greater than 2.8''),
19430 or equivalently @samp{ltpn(2.8,2,1) - ltpn(2.5,2,1)}.
19437 The @kbd{k B} (@code{calc-utpb}) [@code{utpb}] function uses the
19438 binomial distribution. Push the parameters @var{n}, @var{p}, and
19439 then @var{x} onto the stack; the result (@samp{utpb(x,n,p)}) is the
19440 probability that an event will occur @var{x} or more times out
19441 of @var{n} trials, if its probability of occurring in any given
19442 trial is @var{p}. The @kbd{I k B} [@code{ltpb}] function is
19443 the probability that the event will occur fewer than @var{x} times.
19445 The other probability distribution functions similarly take the
19446 form @kbd{k @var{X}} (@code{calc-utp@var{x}}) [@code{utp@var{x}}]
19447 and @kbd{I k @var{X}} [@code{ltp@var{x}}], for various letters
19448 @var{x}. The arguments to the algebraic functions are the value of
19449 the random variable first, then whatever other parameters define the
19450 distribution. Note these are among the few Calc functions where the
19451 order of the arguments in algebraic form differs from the order of
19452 arguments as found on the stack. (The random variable comes last on
19453 the stack, so that you can type, e.g., @kbd{2 @key{RET} 1 @key{RET} 2.5
19454 k N M-@key{RET} @key{DEL} 2.8 k N -}, using @kbd{M-@key{RET} @key{DEL}} to
19455 recover the original arguments but substitute a new value for @expr{x}.)
19468 The @samp{utpc(x,v)} function uses the chi-square distribution with
19469 @texline @math{\nu}
19471 degrees of freedom. It is the probability that a model is
19472 correct if its chi-square statistic is @expr{x}.
19485 The @samp{utpf(F,v1,v2)} function uses the F distribution, used in
19486 various statistical tests. The parameters
19487 @texline @math{\nu_1}
19488 @infoline @expr{v1}
19490 @texline @math{\nu_2}
19491 @infoline @expr{v2}
19492 are the degrees of freedom in the numerator and denominator,
19493 respectively, used in computing the statistic @expr{F}.
19506 The @samp{utpn(x,m,s)} function uses a normal (Gaussian) distribution
19507 with mean @expr{m} and standard deviation
19508 @texline @math{\sigma}.
19509 @infoline @expr{s}.
19510 It is the probability that such a normal-distributed random variable
19511 would exceed @expr{x}.
19524 The @samp{utpp(n,x)} function uses a Poisson distribution with
19525 mean @expr{x}. It is the probability that @expr{n} or more such
19526 Poisson random events will occur.
19539 The @samp{utpt(t,v)} function uses the Student's ``t'' distribution
19541 @texline @math{\nu}
19543 degrees of freedom. It is the probability that a
19544 t-distributed random variable will be greater than @expr{t}.
19545 (Note: This computes the distribution function
19546 @texline @math{A(t|\nu)}
19547 @infoline @expr{A(t|v)}
19549 @texline @math{A(0|\nu) = 1}
19550 @infoline @expr{A(0|v) = 1}
19552 @texline @math{A(\infty|\nu) \to 0}.
19553 @infoline @expr{A(inf|v) -> 0}.
19554 The @code{UTPT} operation on the HP-48 uses a different definition which
19555 returns half of Calc's value: @samp{UTPT(t,v) = .5*utpt(t,v)}.)
19557 While Calc does not provide inverses of the probability distribution
19558 functions, the @kbd{a R} command can be used to solve for the inverse.
19559 Since the distribution functions are monotonic, @kbd{a R} is guaranteed
19560 to be able to find a solution given any initial guess.
19561 @xref{Numerical Solutions}.
19563 @node Matrix Functions, Algebra, Scientific Functions, Top
19564 @chapter Vector/Matrix Functions
19567 Many of the commands described here begin with the @kbd{v} prefix.
19568 (For convenience, the shift-@kbd{V} prefix is equivalent to @kbd{v}.)
19569 The commands usually apply to both plain vectors and matrices; some
19570 apply only to matrices or only to square matrices. If the argument
19571 has the wrong dimensions the operation is left in symbolic form.
19573 Vectors are entered and displayed using @samp{[a,b,c]} notation.
19574 Matrices are vectors of which all elements are vectors of equal length.
19575 (Though none of the standard Calc commands use this concept, a
19576 three-dimensional matrix or rank-3 tensor could be defined as a
19577 vector of matrices, and so on.)
19580 * Packing and Unpacking::
19581 * Building Vectors::
19582 * Extracting Elements::
19583 * Manipulating Vectors::
19584 * Vector and Matrix Arithmetic::
19586 * Statistical Operations::
19587 * Reducing and Mapping::
19588 * Vector and Matrix Formats::
19591 @node Packing and Unpacking, Building Vectors, Matrix Functions, Matrix Functions
19592 @section Packing and Unpacking
19595 Calc's ``pack'' and ``unpack'' commands collect stack entries to build
19596 composite objects such as vectors and complex numbers. They are
19597 described in this chapter because they are most often used to build
19602 The @kbd{v p} (@code{calc-pack}) [@code{pack}] command collects several
19603 elements from the stack into a matrix, complex number, HMS form, error
19604 form, etc. It uses a numeric prefix argument to specify the kind of
19605 object to be built; this argument is referred to as the ``packing mode.''
19606 If the packing mode is a nonnegative integer, a vector of that
19607 length is created. For example, @kbd{C-u 5 v p} will pop the top
19608 five stack elements and push back a single vector of those five
19609 elements. (@kbd{C-u 0 v p} simply creates an empty vector.)
19611 The same effect can be had by pressing @kbd{[} to push an incomplete
19612 vector on the stack, using @key{TAB} (@code{calc-roll-down}) to sneak
19613 the incomplete object up past a certain number of elements, and
19614 then pressing @kbd{]} to complete the vector.
19616 Negative packing modes create other kinds of composite objects:
19620 Two values are collected to build a complex number. For example,
19621 @kbd{5 @key{RET} 7 C-u -1 v p} creates the complex number
19622 @expr{(5, 7)}. The result is always a rectangular complex
19623 number. The two input values must both be real numbers,
19624 i.e., integers, fractions, or floats. If they are not, Calc
19625 will instead build a formula like @samp{a + (0, 1) b}. (The
19626 other packing modes also create a symbolic answer if the
19627 components are not suitable.)
19630 Two values are collected to build a polar complex number.
19631 The first is the magnitude; the second is the phase expressed
19632 in either degrees or radians according to the current angular
19636 Three values are collected into an HMS form. The first
19637 two values (hours and minutes) must be integers or
19638 integer-valued floats. The third value may be any real
19642 Two values are collected into an error form. The inputs
19643 may be real numbers or formulas.
19646 Two values are collected into a modulo form. The inputs
19647 must be real numbers.
19650 Two values are collected into the interval @samp{[a .. b]}.
19651 The inputs may be real numbers, HMS or date forms, or formulas.
19654 Two values are collected into the interval @samp{[a .. b)}.
19657 Two values are collected into the interval @samp{(a .. b]}.
19660 Two values are collected into the interval @samp{(a .. b)}.
19663 Two integer values are collected into a fraction.
19666 Two values are collected into a floating-point number.
19667 The first is the mantissa; the second, which must be an
19668 integer, is the exponent. The result is the mantissa
19669 times ten to the power of the exponent.
19672 This is treated the same as @mathit{-11} by the @kbd{v p} command.
19673 When unpacking, @mathit{-12} specifies that a floating-point mantissa
19677 A real number is converted into a date form.
19680 Three numbers (year, month, day) are packed into a pure date form.
19683 Six numbers are packed into a date/time form.
19686 With any of the two-input negative packing modes, either or both
19687 of the inputs may be vectors. If both are vectors of the same
19688 length, the result is another vector made by packing corresponding
19689 elements of the input vectors. If one input is a vector and the
19690 other is a plain number, the number is packed along with each vector
19691 element to produce a new vector. For example, @kbd{C-u -4 v p}
19692 could be used to convert a vector of numbers and a vector of errors
19693 into a single vector of error forms; @kbd{C-u -5 v p} could convert
19694 a vector of numbers and a single number @var{M} into a vector of
19695 numbers modulo @var{M}.
19697 If you don't give a prefix argument to @kbd{v p}, it takes
19698 the packing mode from the top of the stack. The elements to
19699 be packed then begin at stack level 2. Thus
19700 @kbd{1 @key{RET} 2 @key{RET} 4 n v p} is another way to
19701 enter the error form @samp{1 +/- 2}.
19703 If the packing mode taken from the stack is a vector, the result is a
19704 matrix with the dimensions specified by the elements of the vector,
19705 which must each be integers. For example, if the packing mode is
19706 @samp{[2, 3]}, then six numbers will be taken from the stack and
19707 returned in the form @samp{[@w{[a, b, c]}, [d, e, f]]}.
19709 If any elements of the vector are negative, other kinds of
19710 packing are done at that level as described above. For
19711 example, @samp{[2, 3, -4]} takes 12 objects and creates a
19712 @texline @math{2\times3}
19714 matrix of error forms: @samp{[[a +/- b, c +/- d ... ]]}.
19715 Also, @samp{[-4, -10]} will convert four integers into an
19716 error form consisting of two fractions: @samp{a:b +/- c:d}.
19722 There is an equivalent algebraic function,
19723 @samp{pack(@var{mode}, @var{items})} where @var{mode} is a
19724 packing mode (an integer or a vector of integers) and @var{items}
19725 is a vector of objects to be packed (re-packed, really) according
19726 to that mode. For example, @samp{pack([3, -4], [a,b,c,d,e,f])}
19727 yields @samp{[a +/- b, @w{c +/- d}, e +/- f]}. The function is
19728 left in symbolic form if the packing mode is invalid, or if the
19729 number of data items does not match the number of items required
19733 @pindex calc-unpack
19734 The @kbd{v u} (@code{calc-unpack}) command takes the vector, complex
19735 number, HMS form, or other composite object on the top of the stack and
19736 ``unpacks'' it, pushing each of its elements onto the stack as separate
19737 objects. Thus, it is the ``inverse'' of @kbd{v p}. If the value
19738 at the top of the stack is a formula, @kbd{v u} unpacks it by pushing
19739 each of the arguments of the top-level operator onto the stack.
19741 You can optionally give a numeric prefix argument to @kbd{v u}
19742 to specify an explicit (un)packing mode. If the packing mode is
19743 negative and the input is actually a vector or matrix, the result
19744 will be two or more similar vectors or matrices of the elements.
19745 For example, given the vector @samp{[@w{a +/- b}, c^2, d +/- 7]},
19746 the result of @kbd{C-u -4 v u} will be the two vectors
19747 @samp{[a, c^2, d]} and @w{@samp{[b, 0, 7]}}.
19749 Note that the prefix argument can have an effect even when the input is
19750 not a vector. For example, if the input is the number @mathit{-5}, then
19751 @kbd{c-u -1 v u} yields @mathit{-5} and 0 (the components of @mathit{-5}
19752 when viewed as a rectangular complex number); @kbd{C-u -2 v u} yields 5
19753 and 180 (assuming Degrees mode); and @kbd{C-u -10 v u} yields @mathit{-5}
19754 and 1 (the numerator and denominator of @mathit{-5}, viewed as a rational
19755 number). Plain @kbd{v u} with this input would complain that the input
19756 is not a composite object.
19758 Unpacking mode @mathit{-11} converts a float into an integer mantissa and
19759 an integer exponent, where the mantissa is not divisible by 10
19760 (except that 0.0 is represented by a mantissa and exponent of 0).
19761 Unpacking mode @mathit{-12} converts a float into a floating-point mantissa
19762 and integer exponent, where the mantissa (for non-zero numbers)
19763 is guaranteed to lie in the range [1 .. 10). In both cases,
19764 the mantissa is shifted left or right (and the exponent adjusted
19765 to compensate) in order to satisfy these constraints.
19767 Positive unpacking modes are treated differently than for @kbd{v p}.
19768 A mode of 1 is much like plain @kbd{v u} with no prefix argument,
19769 except that in addition to the components of the input object,
19770 a suitable packing mode to re-pack the object is also pushed.
19771 Thus, @kbd{C-u 1 v u} followed by @kbd{v p} will re-build the
19774 A mode of 2 unpacks two levels of the object; the resulting
19775 re-packing mode will be a vector of length 2. This might be used
19776 to unpack a matrix, say, or a vector of error forms. Higher
19777 unpacking modes unpack the input even more deeply.
19783 There are two algebraic functions analogous to @kbd{v u}.
19784 The @samp{unpack(@var{mode}, @var{item})} function unpacks the
19785 @var{item} using the given @var{mode}, returning the result as
19786 a vector of components. Here the @var{mode} must be an
19787 integer, not a vector. For example, @samp{unpack(-4, a +/- b)}
19788 returns @samp{[a, b]}, as does @samp{unpack(1, a +/- b)}.
19794 The @code{unpackt} function is like @code{unpack} but instead
19795 of returning a simple vector of items, it returns a vector of
19796 two things: The mode, and the vector of items. For example,
19797 @samp{unpackt(1, 2:3 +/- 1:4)} returns @samp{[-4, [2:3, 1:4]]},
19798 and @samp{unpackt(2, 2:3 +/- 1:4)} returns @samp{[[-4, -10], [2, 3, 1, 4]]}.
19799 The identity for re-building the original object is
19800 @samp{apply(pack, unpackt(@var{n}, @var{x})) = @var{x}}. (The
19801 @code{apply} function builds a function call given the function
19802 name and a vector of arguments.)
19804 @cindex Numerator of a fraction, extracting
19805 Subscript notation is a useful way to extract a particular part
19806 of an object. For example, to get the numerator of a rational
19807 number, you can use @samp{unpack(-10, @var{x})_1}.
19809 @node Building Vectors, Extracting Elements, Packing and Unpacking, Matrix Functions
19810 @section Building Vectors
19813 Vectors and matrices can be added,
19814 subtracted, multiplied, and divided; @pxref{Basic Arithmetic}.
19817 @pindex calc-concat
19822 The @kbd{|} (@code{calc-concat}) [@code{vconcat}] command ``concatenates'' two vectors
19823 into one. For example, after @kbd{@w{[ 1 , 2 ]} [ 3 , 4 ] |}, the stack
19824 will contain the single vector @samp{[1, 2, 3, 4]}. If the arguments
19825 are matrices, the rows of the first matrix are concatenated with the
19826 rows of the second. (In other words, two matrices are just two vectors
19827 of row-vectors as far as @kbd{|} is concerned.)
19829 If either argument to @kbd{|} is a scalar (a non-vector), it is treated
19830 like a one-element vector for purposes of concatenation: @kbd{1 [ 2 , 3 ] |}
19831 produces the vector @samp{[1, 2, 3]}. Likewise, if one argument is a
19832 matrix and the other is a plain vector, the vector is treated as a
19837 The @kbd{H |} (@code{calc-append}) [@code{append}] command concatenates
19838 two vectors without any special cases. Both inputs must be vectors.
19839 Whether or not they are matrices is not taken into account. If either
19840 argument is a scalar, the @code{append} function is left in symbolic form.
19841 See also @code{cons} and @code{rcons} below.
19845 The @kbd{I |} and @kbd{H I |} commands are similar, but they use their
19846 two stack arguments in the opposite order. Thus @kbd{I |} is equivalent
19847 to @kbd{@key{TAB} |}, but possibly more convenient and also a bit faster.
19852 The @kbd{v d} (@code{calc-diag}) [@code{diag}] function builds a diagonal
19853 square matrix. The optional numeric prefix gives the number of rows
19854 and columns in the matrix. If the value at the top of the stack is a
19855 vector, the elements of the vector are used as the diagonal elements; the
19856 prefix, if specified, must match the size of the vector. If the value on
19857 the stack is a scalar, it is used for each element on the diagonal, and
19858 the prefix argument is required.
19860 To build a constant square matrix, e.g., a
19861 @texline @math{3\times3}
19863 matrix filled with ones, use @kbd{0 M-3 v d 1 +}, i.e., build a zero
19864 matrix first and then add a constant value to that matrix. (Another
19865 alternative would be to use @kbd{v b} and @kbd{v a}; see below.)
19870 The @kbd{v i} (@code{calc-ident}) [@code{idn}] function builds an identity
19871 matrix of the specified size. It is a convenient form of @kbd{v d}
19872 where the diagonal element is always one. If no prefix argument is given,
19873 this command prompts for one.
19875 In algebraic notation, @samp{idn(a,n)} acts much like @samp{diag(a,n)},
19876 except that @expr{a} is required to be a scalar (non-vector) quantity.
19877 If @expr{n} is omitted, @samp{idn(a)} represents @expr{a} times an
19878 identity matrix of unknown size. Calc can operate algebraically on
19879 such generic identity matrices, and if one is combined with a matrix
19880 whose size is known, it is converted automatically to an identity
19881 matrix of a suitable matching size. The @kbd{v i} command with an
19882 argument of zero creates a generic identity matrix, @samp{idn(1)}.
19883 Note that in dimensioned Matrix mode (@pxref{Matrix Mode}), generic
19884 identity matrices are immediately expanded to the current default
19890 The @kbd{v x} (@code{calc-index}) [@code{index}] function builds a vector
19891 of consecutive integers from 1 to @var{n}, where @var{n} is the numeric
19892 prefix argument. If you do not provide a prefix argument, you will be
19893 prompted to enter a suitable number. If @var{n} is negative, the result
19894 is a vector of negative integers from @var{n} to @mathit{-1}.
19896 With a prefix argument of just @kbd{C-u}, the @kbd{v x} command takes
19897 three values from the stack: @var{n}, @var{start}, and @var{incr} (with
19898 @var{incr} at top-of-stack). Counting starts at @var{start} and increases
19899 by @var{incr} for successive vector elements. If @var{start} or @var{n}
19900 is in floating-point format, the resulting vector elements will also be
19901 floats. Note that @var{start} and @var{incr} may in fact be any kind
19902 of numbers or formulas.
19904 When @var{start} and @var{incr} are specified, a negative @var{n} has a
19905 different interpretation: It causes a geometric instead of arithmetic
19906 sequence to be generated. For example, @samp{index(-3, a, b)} produces
19907 @samp{[a, a b, a b^2]}. If you omit @var{incr} in the algebraic form,
19908 @samp{index(@var{n}, @var{start})}, the default value for @var{incr}
19909 is one for positive @var{n} or two for negative @var{n}.
19912 @pindex calc-build-vector
19914 The @kbd{v b} (@code{calc-build-vector}) [@code{cvec}] function builds a
19915 vector of @var{n} copies of the value on the top of the stack, where @var{n}
19916 is the numeric prefix argument. In algebraic formulas, @samp{cvec(x,n,m)}
19917 can also be used to build an @var{n}-by-@var{m} matrix of copies of @var{x}.
19918 (Interactively, just use @kbd{v b} twice: once to build a row, then again
19919 to build a matrix of copies of that row.)
19927 The @kbd{v h} (@code{calc-head}) [@code{head}] function returns the first
19928 element of a vector. The @kbd{I v h} (@code{calc-tail}) [@code{tail}]
19929 function returns the vector with its first element removed. In both
19930 cases, the argument must be a non-empty vector.
19935 The @kbd{v k} (@code{calc-cons}) [@code{cons}] function takes a value @var{h}
19936 and a vector @var{t} from the stack, and produces the vector whose head is
19937 @var{h} and whose tail is @var{t}. This is similar to @kbd{|}, except
19938 if @var{h} is itself a vector, @kbd{|} will concatenate the two vectors
19939 whereas @code{cons} will insert @var{h} at the front of the vector @var{t}.
19959 Each of these three functions also accepts the Hyperbolic flag [@code{rhead},
19960 @code{rtail}, @code{rcons}] in which case @var{t} instead represents
19961 the @emph{last} single element of the vector, with @var{h}
19962 representing the remainder of the vector. Thus the vector
19963 @samp{[a, b, c, d] = cons(a, [b, c, d]) = rcons([a, b, c], d)}.
19964 Also, @samp{head([a, b, c, d]) = a}, @samp{tail([a, b, c, d]) = [b, c, d]},
19965 @samp{rhead([a, b, c, d]) = [a, b, c]}, and @samp{rtail([a, b, c, d]) = d}.
19967 @node Extracting Elements, Manipulating Vectors, Building Vectors, Matrix Functions
19968 @section Extracting Vector Elements
19974 The @kbd{v r} (@code{calc-mrow}) [@code{mrow}] command extracts one row of
19975 the matrix on the top of the stack, or one element of the plain vector on
19976 the top of the stack. The row or element is specified by the numeric
19977 prefix argument; the default is to prompt for the row or element number.
19978 The matrix or vector is replaced by the specified row or element in the
19979 form of a vector or scalar, respectively.
19981 @cindex Permutations, applying
19982 With a prefix argument of @kbd{C-u} only, @kbd{v r} takes the index of
19983 the element or row from the top of the stack, and the vector or matrix
19984 from the second-to-top position. If the index is itself a vector of
19985 integers, the result is a vector of the corresponding elements of the
19986 input vector, or a matrix of the corresponding rows of the input matrix.
19987 This command can be used to obtain any permutation of a vector.
19989 With @kbd{C-u}, if the index is an interval form with integer components,
19990 it is interpreted as a range of indices and the corresponding subvector or
19991 submatrix is returned.
19993 @cindex Subscript notation
19995 @pindex calc-subscript
19998 Subscript notation in algebraic formulas (@samp{a_b}) stands for the
19999 Calc function @code{subscr}, which is synonymous with @code{mrow}.
20000 Thus, @samp{[x, y, z]_k} produces @expr{x}, @expr{y}, or @expr{z} if
20001 @expr{k} is one, two, or three, respectively. A double subscript
20002 (@samp{M_i_j}, equivalent to @samp{subscr(subscr(M, i), j)}) will
20003 access the element at row @expr{i}, column @expr{j} of a matrix.
20004 The @kbd{a _} (@code{calc-subscript}) command creates a subscript
20005 formula @samp{a_b} out of two stack entries. (It is on the @kbd{a}
20006 ``algebra'' prefix because subscripted variables are often used
20007 purely as an algebraic notation.)
20010 Given a negative prefix argument, @kbd{v r} instead deletes one row or
20011 element from the matrix or vector on the top of the stack. Thus
20012 @kbd{C-u 2 v r} replaces a matrix with its second row, but @kbd{C-u -2 v r}
20013 replaces the matrix with the same matrix with its second row removed.
20014 In algebraic form this function is called @code{mrrow}.
20017 Given a prefix argument of zero, @kbd{v r} extracts the diagonal elements
20018 of a square matrix in the form of a vector. In algebraic form this
20019 function is called @code{getdiag}.
20025 The @kbd{v c} (@code{calc-mcol}) [@code{mcol} or @code{mrcol}] command is
20026 the analogous operation on columns of a matrix. Given a plain vector
20027 it extracts (or removes) one element, just like @kbd{v r}. If the
20028 index in @kbd{C-u v c} is an interval or vector and the argument is a
20029 matrix, the result is a submatrix with only the specified columns
20030 retained (and possibly permuted in the case of a vector index).
20032 To extract a matrix element at a given row and column, use @kbd{v r} to
20033 extract the row as a vector, then @kbd{v c} to extract the column element
20034 from that vector. In algebraic formulas, it is often more convenient to
20035 use subscript notation: @samp{m_i_j} gives row @expr{i}, column @expr{j}
20036 of matrix @expr{m}.
20039 @pindex calc-subvector
20041 The @kbd{v s} (@code{calc-subvector}) [@code{subvec}] command extracts
20042 a subvector of a vector. The arguments are the vector, the starting
20043 index, and the ending index, with the ending index in the top-of-stack
20044 position. The starting index indicates the first element of the vector
20045 to take. The ending index indicates the first element @emph{past} the
20046 range to be taken. Thus, @samp{subvec([a, b, c, d, e], 2, 4)} produces
20047 the subvector @samp{[b, c]}. You could get the same result using
20048 @samp{mrow([a, b, c, d, e], @w{[2 .. 4)})}.
20050 If either the start or the end index is zero or negative, it is
20051 interpreted as relative to the end of the vector. Thus
20052 @samp{subvec([a, b, c, d, e], 2, -2)} also produces @samp{[b, c]}. In
20053 the algebraic form, the end index can be omitted in which case it
20054 is taken as zero, i.e., elements from the starting element to the
20055 end of the vector are used. The infinity symbol, @code{inf}, also
20056 has this effect when used as the ending index.
20060 With the Inverse flag, @kbd{I v s} [@code{rsubvec}] removes a subvector
20061 from a vector. The arguments are interpreted the same as for the
20062 normal @kbd{v s} command. Thus, @samp{rsubvec([a, b, c, d, e], 2, 4)}
20063 produces @samp{[a, d, e]}. It is always true that @code{subvec} and
20064 @code{rsubvec} return complementary parts of the input vector.
20066 @xref{Selecting Subformulas}, for an alternative way to operate on
20067 vectors one element at a time.
20069 @node Manipulating Vectors, Vector and Matrix Arithmetic, Extracting Elements, Matrix Functions
20070 @section Manipulating Vectors
20074 @pindex calc-vlength
20076 The @kbd{v l} (@code{calc-vlength}) [@code{vlen}] command computes the
20077 length of a vector. The length of a non-vector is considered to be zero.
20078 Note that matrices are just vectors of vectors for the purposes of this
20083 With the Hyperbolic flag, @kbd{H v l} [@code{mdims}] computes a vector
20084 of the dimensions of a vector, matrix, or higher-order object. For
20085 example, @samp{mdims([[a,b,c],[d,e,f]])} returns @samp{[2, 3]} since
20087 @texline @math{2\times3}
20092 @pindex calc-vector-find
20094 The @kbd{v f} (@code{calc-vector-find}) [@code{find}] command searches
20095 along a vector for the first element equal to a given target. The target
20096 is on the top of the stack; the vector is in the second-to-top position.
20097 If a match is found, the result is the index of the matching element.
20098 Otherwise, the result is zero. The numeric prefix argument, if given,
20099 allows you to select any starting index for the search.
20102 @pindex calc-arrange-vector
20104 @cindex Arranging a matrix
20105 @cindex Reshaping a matrix
20106 @cindex Flattening a matrix
20107 The @kbd{v a} (@code{calc-arrange-vector}) [@code{arrange}] command
20108 rearranges a vector to have a certain number of columns and rows. The
20109 numeric prefix argument specifies the number of columns; if you do not
20110 provide an argument, you will be prompted for the number of columns.
20111 The vector or matrix on the top of the stack is @dfn{flattened} into a
20112 plain vector. If the number of columns is nonzero, this vector is
20113 then formed into a matrix by taking successive groups of @var{n} elements.
20114 If the number of columns does not evenly divide the number of elements
20115 in the vector, the last row will be short and the result will not be
20116 suitable for use as a matrix. For example, with the matrix
20117 @samp{[[1, 2], @w{[3, 4]}]} on the stack, @kbd{v a 4} produces
20118 @samp{[[1, 2, 3, 4]]} (a
20119 @texline @math{1\times4}
20121 matrix), @kbd{v a 1} produces @samp{[[1], [2], [3], [4]]} (a
20122 @texline @math{4\times1}
20124 matrix), @kbd{v a 2} produces @samp{[[1, 2], [3, 4]]} (the original
20125 @texline @math{2\times2}
20127 matrix), @w{@kbd{v a 3}} produces @samp{[[1, 2, 3], [4]]} (not a
20128 matrix), and @kbd{v a 0} produces the flattened list
20129 @samp{[1, 2, @w{3, 4}]}.
20131 @cindex Sorting data
20137 The @kbd{V S} (@code{calc-sort}) [@code{sort}] command sorts the elements of
20138 a vector into increasing order. Real numbers, real infinities, and
20139 constant interval forms come first in this ordering; next come other
20140 kinds of numbers, then variables (in alphabetical order), then finally
20141 come formulas and other kinds of objects; these are sorted according
20142 to a kind of lexicographic ordering with the useful property that
20143 one vector is less or greater than another if the first corresponding
20144 unequal elements are less or greater, respectively. Since quoted strings
20145 are stored by Calc internally as vectors of ASCII character codes
20146 (@pxref{Strings}), this means vectors of strings are also sorted into
20147 alphabetical order by this command.
20149 The @kbd{I V S} [@code{rsort}] command sorts a vector into decreasing order.
20151 @cindex Permutation, inverse of
20152 @cindex Inverse of permutation
20153 @cindex Index tables
20154 @cindex Rank tables
20160 The @kbd{V G} (@code{calc-grade}) [@code{grade}, @code{rgrade}] command
20161 produces an index table or permutation vector which, if applied to the
20162 input vector (as the index of @kbd{C-u v r}, say), would sort the vector.
20163 A permutation vector is just a vector of integers from 1 to @var{n}, where
20164 each integer occurs exactly once. One application of this is to sort a
20165 matrix of data rows using one column as the sort key; extract that column,
20166 grade it with @kbd{V G}, then use the result to reorder the original matrix
20167 with @kbd{C-u v r}. Another interesting property of the @code{V G} command
20168 is that, if the input is itself a permutation vector, the result will
20169 be the inverse of the permutation. The inverse of an index table is
20170 a rank table, whose @var{k}th element says where the @var{k}th original
20171 vector element will rest when the vector is sorted. To get a rank
20172 table, just use @kbd{V G V G}.
20174 With the Inverse flag, @kbd{I V G} produces an index table that would
20175 sort the input into decreasing order. Note that @kbd{V S} and @kbd{V G}
20176 use a ``stable'' sorting algorithm, i.e., any two elements which are equal
20177 will not be moved out of their original order. Generally there is no way
20178 to tell with @kbd{V S}, since two elements which are equal look the same,
20179 but with @kbd{V G} this can be an important issue. In the matrix-of-rows
20180 example, suppose you have names and telephone numbers as two columns and
20181 you wish to sort by phone number primarily, and by name when the numbers
20182 are equal. You can sort the data matrix by names first, and then again
20183 by phone numbers. Because the sort is stable, any two rows with equal
20184 phone numbers will remain sorted by name even after the second sort.
20188 @pindex calc-histogram
20190 @mindex histo@idots
20193 The @kbd{V H} (@code{calc-histogram}) [@code{histogram}] command builds a
20194 histogram of a vector of numbers. Vector elements are assumed to be
20195 integers or real numbers in the range [0..@var{n}) for some ``number of
20196 bins'' @var{n}, which is the numeric prefix argument given to the
20197 command. The result is a vector of @var{n} counts of how many times
20198 each value appeared in the original vector. Non-integers in the input
20199 are rounded down to integers. Any vector elements outside the specified
20200 range are ignored. (You can tell if elements have been ignored by noting
20201 that the counts in the result vector don't add up to the length of the
20205 With the Hyperbolic flag, @kbd{H V H} pulls two vectors from the stack.
20206 The second-to-top vector is the list of numbers as before. The top
20207 vector is an equal-sized list of ``weights'' to attach to the elements
20208 of the data vector. For example, if the first data element is 4.2 and
20209 the first weight is 10, then 10 will be added to bin 4 of the result
20210 vector. Without the hyperbolic flag, every element has a weight of one.
20213 @pindex calc-transpose
20215 The @kbd{v t} (@code{calc-transpose}) [@code{trn}] command computes
20216 the transpose of the matrix at the top of the stack. If the argument
20217 is a plain vector, it is treated as a row vector and transposed into
20218 a one-column matrix.
20221 @pindex calc-reverse-vector
20223 The @kbd{v v} (@code{calc-reverse-vector}) [@code{rev}] command reverses
20224 a vector end-for-end. Given a matrix, it reverses the order of the rows.
20225 (To reverse the columns instead, just use @kbd{v t v v v t}. The same
20226 principle can be used to apply other vector commands to the columns of
20230 @pindex calc-mask-vector
20232 The @kbd{v m} (@code{calc-mask-vector}) [@code{vmask}] command uses
20233 one vector as a mask to extract elements of another vector. The mask
20234 is in the second-to-top position; the target vector is on the top of
20235 the stack. These vectors must have the same length. The result is
20236 the same as the target vector, but with all elements which correspond
20237 to zeros in the mask vector deleted. Thus, for example,
20238 @samp{vmask([1, 0, 1, 0, 1], [a, b, c, d, e])} produces @samp{[a, c, e]}.
20239 @xref{Logical Operations}.
20242 @pindex calc-expand-vector
20244 The @kbd{v e} (@code{calc-expand-vector}) [@code{vexp}] command
20245 expands a vector according to another mask vector. The result is a
20246 vector the same length as the mask, but with nonzero elements replaced
20247 by successive elements from the target vector. The length of the target
20248 vector is normally the number of nonzero elements in the mask. If the
20249 target vector is longer, its last few elements are lost. If the target
20250 vector is shorter, the last few nonzero mask elements are left
20251 unreplaced in the result. Thus @samp{vexp([2, 0, 3, 0, 7], [a, b])}
20252 produces @samp{[a, 0, b, 0, 7]}.
20255 With the Hyperbolic flag, @kbd{H v e} takes a filler value from the
20256 top of the stack; the mask and target vectors come from the third and
20257 second elements of the stack. This filler is used where the mask is
20258 zero: @samp{vexp([2, 0, 3, 0, 7], [a, b], z)} produces
20259 @samp{[a, z, c, z, 7]}. If the filler value is itself a vector,
20260 then successive values are taken from it, so that the effect is to
20261 interleave two vectors according to the mask:
20262 @samp{vexp([2, 0, 3, 7, 0, 0], [a, b], [x, y])} produces
20263 @samp{[a, x, b, 7, y, 0]}.
20265 Another variation on the masking idea is to combine @samp{[a, b, c, d, e]}
20266 with the mask @samp{[1, 0, 1, 0, 1]} to produce @samp{[a, 0, c, 0, e]}.
20267 You can accomplish this with @kbd{V M a &}, mapping the logical ``and''
20268 operation across the two vectors. @xref{Logical Operations}. Note that
20269 the @code{? :} operation also discussed there allows other types of
20270 masking using vectors.
20272 @node Vector and Matrix Arithmetic, Set Operations, Manipulating Vectors, Matrix Functions
20273 @section Vector and Matrix Arithmetic
20276 Basic arithmetic operations like addition and multiplication are defined
20277 for vectors and matrices as well as for numbers. Division of matrices, in
20278 the sense of multiplying by the inverse, is supported. (Division by a
20279 matrix actually uses LU-decomposition for greater accuracy and speed.)
20280 @xref{Basic Arithmetic}.
20282 The following functions are applied element-wise if their arguments are
20283 vectors or matrices: @code{change-sign}, @code{conj}, @code{arg},
20284 @code{re}, @code{im}, @code{polar}, @code{rect}, @code{clean},
20285 @code{float}, @code{frac}. @xref{Function Index}.
20288 @pindex calc-conj-transpose
20290 The @kbd{V J} (@code{calc-conj-transpose}) [@code{ctrn}] command computes
20291 the conjugate transpose of its argument, i.e., @samp{conj(trn(x))}.
20296 @kindex A (vectors)
20297 @pindex calc-abs (vectors)
20301 @tindex abs (vectors)
20302 The @kbd{A} (@code{calc-abs}) [@code{abs}] command computes the
20303 Frobenius norm of a vector or matrix argument. This is the square
20304 root of the sum of the squares of the absolute values of the
20305 elements of the vector or matrix. If the vector is interpreted as
20306 a point in two- or three-dimensional space, this is the distance
20307 from that point to the origin.
20312 The @kbd{v n} (@code{calc-rnorm}) [@code{rnorm}] command computes
20313 the row norm, or infinity-norm, of a vector or matrix. For a plain
20314 vector, this is the maximum of the absolute values of the elements.
20315 For a matrix, this is the maximum of the row-absolute-value-sums,
20316 i.e., of the sums of the absolute values of the elements along the
20322 The @kbd{V N} (@code{calc-cnorm}) [@code{cnorm}] command computes
20323 the column norm, or one-norm, of a vector or matrix. For a plain
20324 vector, this is the sum of the absolute values of the elements.
20325 For a matrix, this is the maximum of the column-absolute-value-sums.
20326 General @expr{k}-norms for @expr{k} other than one or infinity are
20332 The @kbd{V C} (@code{calc-cross}) [@code{cross}] command computes the
20333 right-handed cross product of two vectors, each of which must have
20334 exactly three elements.
20339 @kindex & (matrices)
20340 @pindex calc-inv (matrices)
20344 @tindex inv (matrices)
20345 The @kbd{&} (@code{calc-inv}) [@code{inv}] command computes the
20346 inverse of a square matrix. If the matrix is singular, the inverse
20347 operation is left in symbolic form. Matrix inverses are recorded so
20348 that once an inverse (or determinant) of a particular matrix has been
20349 computed, the inverse and determinant of the matrix can be recomputed
20350 quickly in the future.
20352 If the argument to @kbd{&} is a plain number @expr{x}, this
20353 command simply computes @expr{1/x}. This is okay, because the
20354 @samp{/} operator also does a matrix inversion when dividing one
20360 The @kbd{V D} (@code{calc-mdet}) [@code{det}] command computes the
20361 determinant of a square matrix.
20366 The @kbd{V L} (@code{calc-mlud}) [@code{lud}] command computes the
20367 LU decomposition of a matrix. The result is a list of three matrices
20368 which, when multiplied together left-to-right, form the original matrix.
20369 The first is a permutation matrix that arises from pivoting in the
20370 algorithm, the second is lower-triangular with ones on the diagonal,
20371 and the third is upper-triangular.
20374 @pindex calc-mtrace
20376 The @kbd{V T} (@code{calc-mtrace}) [@code{tr}] command computes the
20377 trace of a square matrix. This is defined as the sum of the diagonal
20378 elements of the matrix.
20380 @node Set Operations, Statistical Operations, Vector and Matrix Arithmetic, Matrix Functions
20381 @section Set Operations using Vectors
20384 @cindex Sets, as vectors
20385 Calc includes several commands which interpret vectors as @dfn{sets} of
20386 objects. A set is a collection of objects; any given object can appear
20387 only once in the set. Calc stores sets as vectors of objects in
20388 sorted order. Objects in a Calc set can be any of the usual things,
20389 such as numbers, variables, or formulas. Two set elements are considered
20390 equal if they are identical, except that numerically equal numbers like
20391 the integer 4 and the float 4.0 are considered equal even though they
20392 are not ``identical.'' Variables are treated like plain symbols without
20393 attached values by the set operations; subtracting the set @samp{[b]}
20394 from @samp{[a, b]} always yields the set @samp{[a]} even though if
20395 the variables @samp{a} and @samp{b} both equaled 17, you might
20396 expect the answer @samp{[]}.
20398 If a set contains interval forms, then it is assumed to be a set of
20399 real numbers. In this case, all set operations require the elements
20400 of the set to be only things that are allowed in intervals: Real
20401 numbers, plus and minus infinity, HMS forms, and date forms. If
20402 there are variables or other non-real objects present in a real set,
20403 all set operations on it will be left in unevaluated form.
20405 If the input to a set operation is a plain number or interval form
20406 @var{a}, it is treated like the one-element vector @samp{[@var{a}]}.
20407 The result is always a vector, except that if the set consists of a
20408 single interval, the interval itself is returned instead.
20410 @xref{Logical Operations}, for the @code{in} function which tests if
20411 a certain value is a member of a given set. To test if the set @expr{A}
20412 is a subset of the set @expr{B}, use @samp{vdiff(A, B) = []}.
20415 @pindex calc-remove-duplicates
20417 The @kbd{V +} (@code{calc-remove-duplicates}) [@code{rdup}] command
20418 converts an arbitrary vector into set notation. It works by sorting
20419 the vector as if by @kbd{V S}, then removing duplicates. (For example,
20420 @kbd{[a, 5, 4, a, 4.0]} is sorted to @samp{[4, 4.0, 5, a, a]} and then
20421 reduced to @samp{[4, 5, a]}). Overlapping intervals are merged as
20422 necessary. You rarely need to use @kbd{V +} explicitly, since all the
20423 other set-based commands apply @kbd{V +} to their inputs before using
20427 @pindex calc-set-union
20429 The @kbd{V V} (@code{calc-set-union}) [@code{vunion}] command computes
20430 the union of two sets. An object is in the union of two sets if and
20431 only if it is in either (or both) of the input sets. (You could
20432 accomplish the same thing by concatenating the sets with @kbd{|},
20433 then using @kbd{V +}.)
20436 @pindex calc-set-intersect
20438 The @kbd{V ^} (@code{calc-set-intersect}) [@code{vint}] command computes
20439 the intersection of two sets. An object is in the intersection if
20440 and only if it is in both of the input sets. Thus if the input
20441 sets are disjoint, i.e., if they share no common elements, the result
20442 will be the empty vector @samp{[]}. Note that the characters @kbd{V}
20443 and @kbd{^} were chosen to be close to the conventional mathematical
20445 @texline union@tie{}(@math{A \cup B})
20448 @texline intersection@tie{}(@math{A \cap B}).
20449 @infoline intersection.
20452 @pindex calc-set-difference
20454 The @kbd{V -} (@code{calc-set-difference}) [@code{vdiff}] command computes
20455 the difference between two sets. An object is in the difference
20456 @expr{A - B} if and only if it is in @expr{A} but not in @expr{B}.
20457 Thus subtracting @samp{[y,z]} from a set will remove the elements
20458 @samp{y} and @samp{z} if they are present. You can also think of this
20459 as a general @dfn{set complement} operator; if @expr{A} is the set of
20460 all possible values, then @expr{A - B} is the ``complement'' of @expr{B}.
20461 Obviously this is only practical if the set of all possible values in
20462 your problem is small enough to list in a Calc vector (or simple
20463 enough to express in a few intervals).
20466 @pindex calc-set-xor
20468 The @kbd{V X} (@code{calc-set-xor}) [@code{vxor}] command computes
20469 the ``exclusive-or,'' or ``symmetric difference'' of two sets.
20470 An object is in the symmetric difference of two sets if and only
20471 if it is in one, but @emph{not} both, of the sets. Objects that
20472 occur in both sets ``cancel out.''
20475 @pindex calc-set-complement
20477 The @kbd{V ~} (@code{calc-set-complement}) [@code{vcompl}] command
20478 computes the complement of a set with respect to the real numbers.
20479 Thus @samp{vcompl(x)} is equivalent to @samp{vdiff([-inf .. inf], x)}.
20480 For example, @samp{vcompl([2, (3 .. 4]])} evaluates to
20481 @samp{[[-inf .. 2), (2 .. 3], (4 .. inf]]}.
20484 @pindex calc-set-floor
20486 The @kbd{V F} (@code{calc-set-floor}) [@code{vfloor}] command
20487 reinterprets a set as a set of integers. Any non-integer values,
20488 and intervals that do not enclose any integers, are removed. Open
20489 intervals are converted to equivalent closed intervals. Successive
20490 integers are converted into intervals of integers. For example, the
20491 complement of the set @samp{[2, 6, 7, 8]} is messy, but if you wanted
20492 the complement with respect to the set of integers you could type
20493 @kbd{V ~ V F} to get @samp{[[-inf .. 1], [3 .. 5], [9 .. inf]]}.
20496 @pindex calc-set-enumerate
20498 The @kbd{V E} (@code{calc-set-enumerate}) [@code{venum}] command
20499 converts a set of integers into an explicit vector. Intervals in
20500 the set are expanded out to lists of all integers encompassed by
20501 the intervals. This only works for finite sets (i.e., sets which
20502 do not involve @samp{-inf} or @samp{inf}).
20505 @pindex calc-set-span
20507 The @kbd{V :} (@code{calc-set-span}) [@code{vspan}] command converts any
20508 set of reals into an interval form that encompasses all its elements.
20509 The lower limit will be the smallest element in the set; the upper
20510 limit will be the largest element. For an empty set, @samp{vspan([])}
20511 returns the empty interval @w{@samp{[0 .. 0)}}.
20514 @pindex calc-set-cardinality
20516 The @kbd{V #} (@code{calc-set-cardinality}) [@code{vcard}] command counts
20517 the number of integers in a set. The result is the length of the vector
20518 that would be produced by @kbd{V E}, although the computation is much
20519 more efficient than actually producing that vector.
20521 @cindex Sets, as binary numbers
20522 Another representation for sets that may be more appropriate in some
20523 cases is binary numbers. If you are dealing with sets of integers
20524 in the range 0 to 49, you can use a 50-bit binary number where a
20525 particular bit is 1 if the corresponding element is in the set.
20526 @xref{Binary Functions}, for a list of commands that operate on
20527 binary numbers. Note that many of the above set operations have
20528 direct equivalents in binary arithmetic: @kbd{b o} (@code{calc-or}),
20529 @kbd{b a} (@code{calc-and}), @kbd{b d} (@code{calc-diff}),
20530 @kbd{b x} (@code{calc-xor}), and @kbd{b n} (@code{calc-not}),
20531 respectively. You can use whatever representation for sets is most
20536 @pindex calc-pack-bits
20537 @pindex calc-unpack-bits
20540 The @kbd{b u} (@code{calc-unpack-bits}) [@code{vunpack}] command
20541 converts an integer that represents a set in binary into a set
20542 in vector/interval notation. For example, @samp{vunpack(67)}
20543 returns @samp{[[0 .. 1], 6]}. If the input is negative, the set
20544 it represents is semi-infinite: @samp{vunpack(-4) = [2 .. inf)}.
20545 Use @kbd{V E} afterwards to expand intervals to individual
20546 values if you wish. Note that this command uses the @kbd{b}
20547 (binary) prefix key.
20549 The @kbd{b p} (@code{calc-pack-bits}) [@code{vpack}] command
20550 converts the other way, from a vector or interval representing
20551 a set of nonnegative integers into a binary integer describing
20552 the same set. The set may include positive infinity, but must
20553 not include any negative numbers. The input is interpreted as a
20554 set of integers in the sense of @kbd{V F} (@code{vfloor}). Beware
20555 that a simple input like @samp{[100]} can result in a huge integer
20557 @texline (@math{2^{100}}, a 31-digit integer, in this case).
20558 @infoline (@expr{2^100}, a 31-digit integer, in this case).
20560 @node Statistical Operations, Reducing and Mapping, Set Operations, Matrix Functions
20561 @section Statistical Operations on Vectors
20564 @cindex Statistical functions
20565 The commands in this section take vectors as arguments and compute
20566 various statistical measures on the data stored in the vectors. The
20567 references used in the definitions of these functions are Bevington's
20568 @emph{Data Reduction and Error Analysis for the Physical Sciences},
20569 and @emph{Numerical Recipes} by Press, Flannery, Teukolsky and
20572 The statistical commands use the @kbd{u} prefix key followed by
20573 a shifted letter or other character.
20575 @xref{Manipulating Vectors}, for a description of @kbd{V H}
20576 (@code{calc-histogram}).
20578 @xref{Curve Fitting}, for the @kbd{a F} command for doing
20579 least-squares fits to statistical data.
20581 @xref{Probability Distribution Functions}, for several common
20582 probability distribution functions.
20585 * Single-Variable Statistics::
20586 * Paired-Sample Statistics::
20589 @node Single-Variable Statistics, Paired-Sample Statistics, Statistical Operations, Statistical Operations
20590 @subsection Single-Variable Statistics
20593 These functions do various statistical computations on single
20594 vectors. Given a numeric prefix argument, they actually pop
20595 @var{n} objects from the stack and combine them into a data
20596 vector. Each object may be either a number or a vector; if a
20597 vector, any sub-vectors inside it are ``flattened'' as if by
20598 @kbd{v a 0}; @pxref{Manipulating Vectors}. By default one object
20599 is popped, which (in order to be useful) is usually a vector.
20601 If an argument is a variable name, and the value stored in that
20602 variable is a vector, then the stored vector is used. This method
20603 has the advantage that if your data vector is large, you can avoid
20604 the slow process of manipulating it directly on the stack.
20606 These functions are left in symbolic form if any of their arguments
20607 are not numbers or vectors, e.g., if an argument is a formula, or
20608 a non-vector variable. However, formulas embedded within vector
20609 arguments are accepted; the result is a symbolic representation
20610 of the computation, based on the assumption that the formula does
20611 not itself represent a vector. All varieties of numbers such as
20612 error forms and interval forms are acceptable.
20614 Some of the functions in this section also accept a single error form
20615 or interval as an argument. They then describe a property of the
20616 normal or uniform (respectively) statistical distribution described
20617 by the argument. The arguments are interpreted in the same way as
20618 the @var{M} argument of the random number function @kbd{k r}. In
20619 particular, an interval with integer limits is considered an integer
20620 distribution, so that @samp{[2 .. 6)} is the same as @samp{[2 .. 5]}.
20621 An interval with at least one floating-point limit is a continuous
20622 distribution: @samp{[2.0 .. 6.0)} is @emph{not} the same as
20623 @samp{[2.0 .. 5.0]}!
20626 @pindex calc-vector-count
20628 The @kbd{u #} (@code{calc-vector-count}) [@code{vcount}] command
20629 computes the number of data values represented by the inputs.
20630 For example, @samp{vcount(1, [2, 3], [[4, 5], [], x, y])} returns 7.
20631 If the argument is a single vector with no sub-vectors, this
20632 simply computes the length of the vector.
20636 @pindex calc-vector-sum
20637 @pindex calc-vector-prod
20640 @cindex Summations (statistical)
20641 The @kbd{u +} (@code{calc-vector-sum}) [@code{vsum}] command
20642 computes the sum of the data values. The @kbd{u *}
20643 (@code{calc-vector-prod}) [@code{vprod}] command computes the
20644 product of the data values. If the input is a single flat vector,
20645 these are the same as @kbd{V R +} and @kbd{V R *}
20646 (@pxref{Reducing and Mapping}).
20650 @pindex calc-vector-max
20651 @pindex calc-vector-min
20654 The @kbd{u X} (@code{calc-vector-max}) [@code{vmax}] command
20655 computes the maximum of the data values, and the @kbd{u N}
20656 (@code{calc-vector-min}) [@code{vmin}] command computes the minimum.
20657 If the argument is an interval, this finds the minimum or maximum
20658 value in the interval. (Note that @samp{vmax([2..6)) = 5} as
20659 described above.) If the argument is an error form, this returns
20660 plus or minus infinity.
20663 @pindex calc-vector-mean
20665 @cindex Mean of data values
20666 The @kbd{u M} (@code{calc-vector-mean}) [@code{vmean}] command
20667 computes the average (arithmetic mean) of the data values.
20668 If the inputs are error forms
20669 @texline @math{x \pm \sigma},
20670 @infoline @samp{x +/- s},
20671 this is the weighted mean of the @expr{x} values with weights
20672 @texline @math{1 /\sigma^2}.
20673 @infoline @expr{1 / s^2}.
20676 $$ \mu = { \displaystyle \sum { x_i \over \sigma_i^2 } \over
20677 \displaystyle \sum { 1 \over \sigma_i^2 } } $$
20679 If the inputs are not error forms, this is simply the sum of the
20680 values divided by the count of the values.
20682 Note that a plain number can be considered an error form with
20684 @texline @math{\sigma = 0}.
20685 @infoline @expr{s = 0}.
20686 If the input to @kbd{u M} is a mixture of
20687 plain numbers and error forms, the result is the mean of the
20688 plain numbers, ignoring all values with non-zero errors. (By the
20689 above definitions it's clear that a plain number effectively
20690 has an infinite weight, next to which an error form with a finite
20691 weight is completely negligible.)
20693 This function also works for distributions (error forms or
20694 intervals). The mean of an error form `@var{a} @tfn{+/-} @var{b}' is simply
20695 @expr{a}. The mean of an interval is the mean of the minimum
20696 and maximum values of the interval.
20699 @pindex calc-vector-mean-error
20701 The @kbd{I u M} (@code{calc-vector-mean-error}) [@code{vmeane}]
20702 command computes the mean of the data points expressed as an
20703 error form. This includes the estimated error associated with
20704 the mean. If the inputs are error forms, the error is the square
20705 root of the reciprocal of the sum of the reciprocals of the squares
20706 of the input errors. (I.e., the variance is the reciprocal of the
20707 sum of the reciprocals of the variances.)
20710 $$ \sigma_\mu^2 = {1 \over \displaystyle \sum {1 \over \sigma_i^2}} $$
20712 If the inputs are plain
20713 numbers, the error is equal to the standard deviation of the values
20714 divided by the square root of the number of values. (This works
20715 out to be equivalent to calculating the standard deviation and
20716 then assuming each value's error is equal to this standard
20720 $$ \sigma_\mu^2 = {\sigma^2 \over N} $$
20724 @pindex calc-vector-median
20726 @cindex Median of data values
20727 The @kbd{H u M} (@code{calc-vector-median}) [@code{vmedian}]
20728 command computes the median of the data values. The values are
20729 first sorted into numerical order; the median is the middle
20730 value after sorting. (If the number of data values is even,
20731 the median is taken to be the average of the two middle values.)
20732 The median function is different from the other functions in
20733 this section in that the arguments must all be real numbers;
20734 variables are not accepted even when nested inside vectors.
20735 (Otherwise it is not possible to sort the data values.) If
20736 any of the input values are error forms, their error parts are
20739 The median function also accepts distributions. For both normal
20740 (error form) and uniform (interval) distributions, the median is
20741 the same as the mean.
20744 @pindex calc-vector-harmonic-mean
20746 @cindex Harmonic mean
20747 The @kbd{H I u M} (@code{calc-vector-harmonic-mean}) [@code{vhmean}]
20748 command computes the harmonic mean of the data values. This is
20749 defined as the reciprocal of the arithmetic mean of the reciprocals
20753 $$ { N \over \displaystyle \sum {1 \over x_i} } $$
20757 @pindex calc-vector-geometric-mean
20759 @cindex Geometric mean
20760 The @kbd{u G} (@code{calc-vector-geometric-mean}) [@code{vgmean}]
20761 command computes the geometric mean of the data values. This
20762 is the @var{n}th root of the product of the values. This is also
20763 equal to the @code{exp} of the arithmetic mean of the logarithms
20764 of the data values.
20767 $$ \exp \left ( \sum { \ln x_i } \right ) =
20768 \left ( \prod { x_i } \right)^{1 / N} $$
20773 The @kbd{H u G} [@code{agmean}] command computes the ``arithmetic-geometric
20774 mean'' of two numbers taken from the stack. This is computed by
20775 replacing the two numbers with their arithmetic mean and geometric
20776 mean, then repeating until the two values converge.
20779 $$ a_{i+1} = { a_i + b_i \over 2 } , \qquad b_{i+1} = \sqrt{a_i b_i} $$
20782 @cindex Root-mean-square
20783 Another commonly used mean, the RMS (root-mean-square), can be computed
20784 for a vector of numbers simply by using the @kbd{A} command.
20787 @pindex calc-vector-sdev
20789 @cindex Standard deviation
20790 @cindex Sample statistics
20791 The @kbd{u S} (@code{calc-vector-sdev}) [@code{vsdev}] command
20792 computes the standard
20793 @texline deviation@tie{}@math{\sigma}
20794 @infoline deviation
20795 of the data values. If the values are error forms, the errors are used
20796 as weights just as for @kbd{u M}. This is the @emph{sample} standard
20797 deviation, whose value is the square root of the sum of the squares of
20798 the differences between the values and the mean of the @expr{N} values,
20799 divided by @expr{N-1}.
20802 $$ \sigma^2 = {1 \over N - 1} \sum (x_i - \mu)^2 $$
20805 This function also applies to distributions. The standard deviation
20806 of a single error form is simply the error part. The standard deviation
20807 of a continuous interval happens to equal the difference between the
20809 @texline @math{\sqrt{12}}.
20810 @infoline @expr{sqrt(12)}.
20811 The standard deviation of an integer interval is the same as the
20812 standard deviation of a vector of those integers.
20815 @pindex calc-vector-pop-sdev
20817 @cindex Population statistics
20818 The @kbd{I u S} (@code{calc-vector-pop-sdev}) [@code{vpsdev}]
20819 command computes the @emph{population} standard deviation.
20820 It is defined by the same formula as above but dividing
20821 by @expr{N} instead of by @expr{N-1}. The population standard
20822 deviation is used when the input represents the entire set of
20823 data values in the distribution; the sample standard deviation
20824 is used when the input represents a sample of the set of all
20825 data values, so that the mean computed from the input is itself
20826 only an estimate of the true mean.
20829 $$ \sigma^2 = {1 \over N} \sum (x_i - \mu)^2 $$
20832 For error forms and continuous intervals, @code{vpsdev} works
20833 exactly like @code{vsdev}. For integer intervals, it computes the
20834 population standard deviation of the equivalent vector of integers.
20838 @pindex calc-vector-variance
20839 @pindex calc-vector-pop-variance
20842 @cindex Variance of data values
20843 The @kbd{H u S} (@code{calc-vector-variance}) [@code{vvar}] and
20844 @kbd{H I u S} (@code{calc-vector-pop-variance}) [@code{vpvar}]
20845 commands compute the variance of the data values. The variance
20847 @texline square@tie{}@math{\sigma^2}
20849 of the standard deviation, i.e., the sum of the
20850 squares of the deviations of the data values from the mean.
20851 (This definition also applies when the argument is a distribution.)
20857 The @code{vflat} algebraic function returns a vector of its
20858 arguments, interpreted in the same way as the other functions
20859 in this section. For example, @samp{vflat(1, [2, [3, 4]], 5)}
20860 returns @samp{[1, 2, 3, 4, 5]}.
20862 @node Paired-Sample Statistics, , Single-Variable Statistics, Statistical Operations
20863 @subsection Paired-Sample Statistics
20866 The functions in this section take two arguments, which must be
20867 vectors of equal size. The vectors are each flattened in the same
20868 way as by the single-variable statistical functions. Given a numeric
20869 prefix argument of 1, these functions instead take one object from
20870 the stack, which must be an
20871 @texline @math{N\times2}
20873 matrix of data values. Once again, variable names can be used in place
20874 of actual vectors and matrices.
20877 @pindex calc-vector-covariance
20880 The @kbd{u C} (@code{calc-vector-covariance}) [@code{vcov}] command
20881 computes the sample covariance of two vectors. The covariance
20882 of vectors @var{x} and @var{y} is the sum of the products of the
20883 differences between the elements of @var{x} and the mean of @var{x}
20884 times the differences between the corresponding elements of @var{y}
20885 and the mean of @var{y}, all divided by @expr{N-1}. Note that
20886 the variance of a vector is just the covariance of the vector
20887 with itself. Once again, if the inputs are error forms the
20888 errors are used as weight factors. If both @var{x} and @var{y}
20889 are composed of error forms, the error for a given data point
20890 is taken as the square root of the sum of the squares of the two
20894 $$ \sigma_{x\!y}^2 = {1 \over N-1} \sum (x_i - \mu_x) (y_i - \mu_y) $$
20895 $$ \sigma_{x\!y}^2 =
20896 {\displaystyle {1 \over N-1}
20897 \sum {(x_i - \mu_x) (y_i - \mu_y) \over \sigma_i^2}
20898 \over \displaystyle {1 \over N} \sum {1 \over \sigma_i^2}}
20903 @pindex calc-vector-pop-covariance
20905 The @kbd{I u C} (@code{calc-vector-pop-covariance}) [@code{vpcov}]
20906 command computes the population covariance, which is the same as the
20907 sample covariance computed by @kbd{u C} except dividing by @expr{N}
20908 instead of @expr{N-1}.
20911 @pindex calc-vector-correlation
20913 @cindex Correlation coefficient
20914 @cindex Linear correlation
20915 The @kbd{H u C} (@code{calc-vector-correlation}) [@code{vcorr}]
20916 command computes the linear correlation coefficient of two vectors.
20917 This is defined by the covariance of the vectors divided by the
20918 product of their standard deviations. (There is no difference
20919 between sample or population statistics here.)
20922 $$ r_{x\!y} = { \sigma_{x\!y}^2 \over \sigma_x^2 \sigma_y^2 } $$
20925 @node Reducing and Mapping, Vector and Matrix Formats, Statistical Operations, Matrix Functions
20926 @section Reducing and Mapping Vectors
20929 The commands in this section allow for more general operations on the
20930 elements of vectors.
20935 The simplest of these operations is @kbd{V A} (@code{calc-apply})
20936 [@code{apply}], which applies a given operator to the elements of a vector.
20937 For example, applying the hypothetical function @code{f} to the vector
20938 @w{@samp{[1, 2, 3]}} would produce the function call @samp{f(1, 2, 3)}.
20939 Applying the @code{+} function to the vector @samp{[a, b]} gives
20940 @samp{a + b}. Applying @code{+} to the vector @samp{[a, b, c]} is an
20941 error, since the @code{+} function expects exactly two arguments.
20943 While @kbd{V A} is useful in some cases, you will usually find that either
20944 @kbd{V R} or @kbd{V M}, described below, is closer to what you want.
20947 * Specifying Operators::
20950 * Nesting and Fixed Points::
20951 * Generalized Products::
20954 @node Specifying Operators, Mapping, Reducing and Mapping, Reducing and Mapping
20955 @subsection Specifying Operators
20958 Commands in this section (like @kbd{V A}) prompt you to press the key
20959 corresponding to the desired operator. Press @kbd{?} for a partial
20960 list of the available operators. Generally, an operator is any key or
20961 sequence of keys that would normally take one or more arguments from
20962 the stack and replace them with a result. For example, @kbd{V A H C}
20963 uses the hyperbolic cosine operator, @code{cosh}. (Since @code{cosh}
20964 expects one argument, @kbd{V A H C} requires a vector with a single
20965 element as its argument.)
20967 You can press @kbd{x} at the operator prompt to select any algebraic
20968 function by name to use as the operator. This includes functions you
20969 have defined yourself using the @kbd{Z F} command. (@xref{Algebraic
20970 Definitions}.) If you give a name for which no function has been
20971 defined, the result is left in symbolic form, as in @samp{f(1, 2, 3)}.
20972 Calc will prompt for the number of arguments the function takes if it
20973 can't figure it out on its own (say, because you named a function that
20974 is currently undefined). It is also possible to type a digit key before
20975 the function name to specify the number of arguments, e.g.,
20976 @kbd{V M 3 x f @key{RET}} calls @code{f} with three arguments even if it
20977 looks like it ought to have only two. This technique may be necessary
20978 if the function allows a variable number of arguments. For example,
20979 the @kbd{v e} [@code{vexp}] function accepts two or three arguments;
20980 if you want to map with the three-argument version, you will have to
20981 type @kbd{V M 3 v e}.
20983 It is also possible to apply any formula to a vector by treating that
20984 formula as a function. When prompted for the operator to use, press
20985 @kbd{'} (the apostrophe) and type your formula as an algebraic entry.
20986 You will then be prompted for the argument list, which defaults to a
20987 list of all variables that appear in the formula, sorted into alphabetic
20988 order. For example, suppose you enter the formula @w{@samp{x + 2y^x}}.
20989 The default argument list would be @samp{(x y)}, which means that if
20990 this function is applied to the arguments @samp{[3, 10]} the result will
20991 be @samp{3 + 2*10^3}. (If you plan to use a certain formula in this
20992 way often, you might consider defining it as a function with @kbd{Z F}.)
20994 Another way to specify the arguments to the formula you enter is with
20995 @kbd{$}, @kbd{$$}, and so on. For example, @kbd{V A ' $$ + 2$^$$}
20996 has the same effect as the previous example. The argument list is
20997 automatically taken to be @samp{($$ $)}. (The order of the arguments
20998 may seem backwards, but it is analogous to the way normal algebraic
20999 entry interacts with the stack.)
21001 If you press @kbd{$} at the operator prompt, the effect is similar to
21002 the apostrophe except that the relevant formula is taken from top-of-stack
21003 instead. The actual vector arguments of the @kbd{V A $} or related command
21004 then start at the second-to-top stack position. You will still be
21005 prompted for an argument list.
21007 @cindex Nameless functions
21008 @cindex Generic functions
21009 A function can be written without a name using the notation @samp{<#1 - #2>},
21010 which means ``a function of two arguments that computes the first
21011 argument minus the second argument.'' The symbols @samp{#1} and @samp{#2}
21012 are placeholders for the arguments. You can use any names for these
21013 placeholders if you wish, by including an argument list followed by a
21014 colon: @samp{<x, y : x - y>}. When you type @kbd{V A ' $$ + 2$^$$ @key{RET}},
21015 Calc builds the nameless function @samp{<#1 + 2 #2^#1>} as the function
21016 to map across the vectors. When you type @kbd{V A ' x + 2y^x @key{RET} @key{RET}},
21017 Calc builds the nameless function @w{@samp{<x, y : x + 2 y^x>}}. In both
21018 cases, Calc also writes the nameless function to the Trail so that you
21019 can get it back later if you wish.
21021 If there is only one argument, you can write @samp{#} in place of @samp{#1}.
21022 (Note that @samp{< >} notation is also used for date forms. Calc tells
21023 that @samp{<@var{stuff}>} is a nameless function by the presence of
21024 @samp{#} signs inside @var{stuff}, or by the fact that @var{stuff}
21025 begins with a list of variables followed by a colon.)
21027 You can type a nameless function directly to @kbd{V A '}, or put one on
21028 the stack and use it with @w{@kbd{V A $}}. Calc will not prompt for an
21029 argument list in this case, since the nameless function specifies the
21030 argument list as well as the function itself. In @kbd{V A '}, you can
21031 omit the @samp{< >} marks if you use @samp{#} notation for the arguments,
21032 so that @kbd{V A ' #1+#2 @key{RET}} is the same as @kbd{V A ' <#1+#2> @key{RET}},
21033 which in turn is the same as @kbd{V A ' $$+$ @key{RET}}.
21035 @cindex Lambda expressions
21040 The internal format for @samp{<x, y : x + y>} is @samp{lambda(x, y, x + y)}.
21041 (The word @code{lambda} derives from Lisp notation and the theory of
21042 functions.) The internal format for @samp{<#1 + #2>} is @samp{lambda(ArgA,
21043 ArgB, ArgA + ArgB)}. Note that there is no actual Calc function called
21044 @code{lambda}; the whole point is that the @code{lambda} expression is
21045 used in its symbolic form, not evaluated for an answer until it is applied
21046 to specific arguments by a command like @kbd{V A} or @kbd{V M}.
21048 (Actually, @code{lambda} does have one special property: Its arguments
21049 are never evaluated; for example, putting @samp{<(2/3) #>} on the stack
21050 will not simplify the @samp{2/3} until the nameless function is actually
21079 As usual, commands like @kbd{V A} have algebraic function name equivalents.
21080 For example, @kbd{V A k g} with an argument of @samp{v} is equivalent to
21081 @samp{apply(gcd, v)}. The first argument specifies the operator name,
21082 and is either a variable whose name is the same as the function name,
21083 or a nameless function like @samp{<#^3+1>}. Operators that are normally
21084 written as algebraic symbols have the names @code{add}, @code{sub},
21085 @code{mul}, @code{div}, @code{pow}, @code{neg}, @code{mod}, and
21092 The @code{call} function builds a function call out of several arguments:
21093 @samp{call(gcd, x, y)} is the same as @samp{apply(gcd, [x, y])}, which
21094 in turn is the same as @samp{gcd(x, y)}. The first argument of @code{call},
21095 like the other functions described here, may be either a variable naming a
21096 function, or a nameless function (@samp{call(<#1+2#2>, x, y)} is the same
21099 (Experts will notice that it's not quite proper to use a variable to name
21100 a function, since the name @code{gcd} corresponds to the Lisp variable
21101 @code{var-gcd} but to the Lisp function @code{calcFunc-gcd}. Calc
21102 automatically makes this translation, so you don't have to worry
21105 @node Mapping, Reducing, Specifying Operators, Reducing and Mapping
21106 @subsection Mapping
21112 The @kbd{V M} (@code{calc-map}) [@code{map}] command applies a given
21113 operator elementwise to one or more vectors. For example, mapping
21114 @code{A} [@code{abs}] produces a vector of the absolute values of the
21115 elements in the input vector. Mapping @code{+} pops two vectors from
21116 the stack, which must be of equal length, and produces a vector of the
21117 pairwise sums of the elements. If either argument is a non-vector, it
21118 is duplicated for each element of the other vector. For example,
21119 @kbd{[1,2,3] 2 V M ^} squares the elements of the specified vector.
21120 With the 2 listed first, it would have computed a vector of powers of
21121 two. Mapping a user-defined function pops as many arguments from the
21122 stack as the function requires. If you give an undefined name, you will
21123 be prompted for the number of arguments to use.
21125 If any argument to @kbd{V M} is a matrix, the operator is normally mapped
21126 across all elements of the matrix. For example, given the matrix
21127 @expr{[[1, -2, 3], [-4, 5, -6]]}, @kbd{V M A} takes six absolute values to
21129 @texline @math{3\times2}
21131 matrix, @expr{[[1, 2, 3], [4, 5, 6]]}.
21134 The command @kbd{V M _} [@code{mapr}] (i.e., type an underscore at the
21135 operator prompt) maps by rows instead. For example, @kbd{V M _ A} views
21136 the above matrix as a vector of two 3-element row vectors. It produces
21137 a new vector which contains the absolute values of those row vectors,
21138 namely @expr{[3.74, 8.77]}. (Recall, the absolute value of a vector is
21139 defined as the square root of the sum of the squares of the elements.)
21140 Some operators accept vectors and return new vectors; for example,
21141 @kbd{v v} reverses a vector, so @kbd{V M _ v v} would reverse each row
21142 of the matrix to get a new matrix, @expr{[[3, -2, 1], [-6, 5, -4]]}.
21144 Sometimes a vector of vectors (representing, say, strings, sets, or lists)
21145 happens to look like a matrix. If so, remember to use @kbd{V M _} if you
21146 want to map a function across the whole strings or sets rather than across
21147 their individual elements.
21150 The command @kbd{V M :} [@code{mapc}] maps by columns. Basically, it
21151 transposes the input matrix, maps by rows, and then, if the result is a
21152 matrix, transposes again. For example, @kbd{V M : A} takes the absolute
21153 values of the three columns of the matrix, treating each as a 2-vector,
21154 and @kbd{V M : v v} reverses the columns to get the matrix
21155 @expr{[[-4, 5, -6], [1, -2, 3]]}.
21157 (The symbols @kbd{_} and @kbd{:} were chosen because they had row-like
21158 and column-like appearances, and were not already taken by useful
21159 operators. Also, they appear shifted on most keyboards so they are easy
21160 to type after @kbd{V M}.)
21162 The @kbd{_} and @kbd{:} modifiers have no effect on arguments that are
21163 not matrices (so if none of the arguments are matrices, they have no
21164 effect at all). If some of the arguments are matrices and others are
21165 plain numbers, the plain numbers are held constant for all rows of the
21166 matrix (so that @kbd{2 V M _ ^} squares every row of a matrix; squaring
21167 a vector takes a dot product of the vector with itself).
21169 If some of the arguments are vectors with the same lengths as the
21170 rows (for @kbd{V M _}) or columns (for @kbd{V M :}) of the matrix
21171 arguments, those vectors are also held constant for every row or
21174 Sometimes it is useful to specify another mapping command as the operator
21175 to use with @kbd{V M}. For example, @kbd{V M _ V A +} applies @kbd{V A +}
21176 to each row of the input matrix, which in turn adds the two values on that
21177 row. If you give another vector-operator command as the operator for
21178 @kbd{V M}, it automatically uses map-by-rows mode if you don't specify
21179 otherwise; thus @kbd{V M V A +} is equivalent to @kbd{V M _ V A +}. (If
21180 you really want to map-by-elements another mapping command, you can use
21181 a triple-nested mapping command: @kbd{V M V M V A +} means to map
21182 @kbd{V M V A +} over the rows of the matrix; in turn, @kbd{V A +} is
21183 mapped over the elements of each row.)
21187 Previous versions of Calc had ``map across'' and ``map down'' modes
21188 that are now considered obsolete; the old ``map across'' is now simply
21189 @kbd{V M V A}, and ``map down'' is now @kbd{V M : V A}. The algebraic
21190 functions @code{mapa} and @code{mapd} are still supported, though.
21191 Note also that, while the old mapping modes were persistent (once you
21192 set the mode, it would apply to later mapping commands until you reset
21193 it), the new @kbd{:} and @kbd{_} modifiers apply only to the current
21194 mapping command. The default @kbd{V M} always means map-by-elements.
21196 @xref{Algebraic Manipulation}, for the @kbd{a M} command, which is like
21197 @kbd{V M} but for equations and inequalities instead of vectors.
21198 @xref{Storing Variables}, for the @kbd{s m} command which modifies a
21199 variable's stored value using a @kbd{V M}-like operator.
21201 @node Reducing, Nesting and Fixed Points, Mapping, Reducing and Mapping
21202 @subsection Reducing
21206 @pindex calc-reduce
21208 The @kbd{V R} (@code{calc-reduce}) [@code{reduce}] command applies a given
21209 binary operator across all the elements of a vector. A binary operator is
21210 a function such as @code{+} or @code{max} which takes two arguments. For
21211 example, reducing @code{+} over a vector computes the sum of the elements
21212 of the vector. Reducing @code{-} computes the first element minus each of
21213 the remaining elements. Reducing @code{max} computes the maximum element
21214 and so on. In general, reducing @code{f} over the vector @samp{[a, b, c, d]}
21215 produces @samp{f(f(f(a, b), c), d)}.
21219 The @kbd{I V R} [@code{rreduce}] command is similar to @kbd{V R} except
21220 that works from right to left through the vector. For example, plain
21221 @kbd{V R -} on the vector @samp{[a, b, c, d]} produces @samp{a - b - c - d}
21222 but @kbd{I V R -} on the same vector produces @samp{a - (b - (c - d))},
21223 or @samp{a - b + c - d}. This ``alternating sum'' occurs frequently
21224 in power series expansions.
21228 The @kbd{V U} (@code{calc-accumulate}) [@code{accum}] command does an
21229 accumulation operation. Here Calc does the corresponding reduction
21230 operation, but instead of producing only the final result, it produces
21231 a vector of all the intermediate results. Accumulating @code{+} over
21232 the vector @samp{[a, b, c, d]} produces the vector
21233 @samp{[a, a + b, a + b + c, a + b + c + d]}.
21237 The @kbd{I V U} [@code{raccum}] command does a right-to-left accumulation.
21238 For example, @kbd{I V U -} on the vector @samp{[a, b, c, d]} produces the
21239 vector @samp{[a - b + c - d, b - c + d, c - d, d]}.
21245 As for @kbd{V M}, @kbd{V R} normally reduces a matrix elementwise. For
21246 example, given the matrix @expr{[[a, b, c], [d, e, f]]}, @kbd{V R +} will
21247 compute @expr{a + b + c + d + e + f}. You can type @kbd{V R _} or
21248 @kbd{V R :} to modify this behavior. The @kbd{V R _} [@code{reducea}]
21249 command reduces ``across'' the matrix; it reduces each row of the matrix
21250 as a vector, then collects the results. Thus @kbd{V R _ +} of this
21251 matrix would produce @expr{[a + b + c, d + e + f]}. Similarly, @kbd{V R :}
21252 [@code{reduced}] reduces down; @kbd{V R : +} would produce @expr{[a + d,
21257 There is a third ``by rows'' mode for reduction that is occasionally
21258 useful; @kbd{V R =} [@code{reducer}] simply reduces the operator over
21259 the rows of the matrix themselves. Thus @kbd{V R = +} on the above
21260 matrix would get the same result as @kbd{V R : +}, since adding two
21261 row vectors is equivalent to adding their elements. But @kbd{V R = *}
21262 would multiply the two rows (to get a single number, their dot product),
21263 while @kbd{V R : *} would produce a vector of the products of the columns.
21265 These three matrix reduction modes work with @kbd{V R} and @kbd{I V R},
21266 but they are not currently supported with @kbd{V U} or @kbd{I V U}.
21270 The obsolete reduce-by-columns function, @code{reducec}, is still
21271 supported but there is no way to get it through the @kbd{V R} command.
21273 The commands @kbd{M-# :} and @kbd{M-# _} are equivalent to typing
21274 @kbd{M-# r} to grab a rectangle of data into Calc, and then typing
21275 @kbd{V R : +} or @kbd{V R _ +}, respectively, to sum the columns or
21276 rows of the matrix. @xref{Grabbing From Buffers}.
21278 @node Nesting and Fixed Points, Generalized Products, Reducing, Reducing and Mapping
21279 @subsection Nesting and Fixed Points
21284 The @kbd{H V R} [@code{nest}] command applies a function to a given
21285 argument repeatedly. It takes two values, @samp{a} and @samp{n}, from
21286 the stack, where @samp{n} must be an integer. It then applies the
21287 function nested @samp{n} times; if the function is @samp{f} and @samp{n}
21288 is 3, the result is @samp{f(f(f(a)))}. The number @samp{n} may be
21289 negative if Calc knows an inverse for the function @samp{f}; for
21290 example, @samp{nest(sin, a, -2)} returns @samp{arcsin(arcsin(a))}.
21294 The @kbd{H V U} [@code{anest}] command is an accumulating version of
21295 @code{nest}: It returns a vector of @samp{n+1} values, e.g.,
21296 @samp{[a, f(a), f(f(a)), f(f(f(a)))]}. If @samp{n} is negative and
21297 @samp{F} is the inverse of @samp{f}, then the result is of the
21298 form @samp{[a, F(a), F(F(a)), F(F(F(a)))]}.
21302 @cindex Fixed points
21303 The @kbd{H I V R} [@code{fixp}] command is like @kbd{H V R}, except
21304 that it takes only an @samp{a} value from the stack; the function is
21305 applied until it reaches a ``fixed point,'' i.e., until the result
21310 The @kbd{H I V U} [@code{afixp}] command is an accumulating @code{fixp}.
21311 The first element of the return vector will be the initial value @samp{a};
21312 the last element will be the final result that would have been returned
21315 For example, 0.739085 is a fixed point of the cosine function (in radians):
21316 @samp{cos(0.739085) = 0.739085}. You can find this value by putting, say,
21317 1.0 on the stack and typing @kbd{H I V U C}. (We use the accumulating
21318 version so we can see the intermediate results: @samp{[1, 0.540302, 0.857553,
21319 0.65329, ...]}. With a precision of six, this command will take 36 steps
21320 to converge to 0.739085.)
21322 Newton's method for finding roots is a classic example of iteration
21323 to a fixed point. To find the square root of five starting with an
21324 initial guess, Newton's method would look for a fixed point of the
21325 function @samp{(x + 5/x) / 2}. Putting a guess of 1 on the stack
21326 and typing @kbd{H I V R ' ($ + 5/$)/2 @key{RET}} quickly yields the result
21327 2.23607. This is equivalent to using the @kbd{a R} (@code{calc-find-root})
21328 command to find a root of the equation @samp{x^2 = 5}.
21330 These examples used numbers for @samp{a} values. Calc keeps applying
21331 the function until two successive results are equal to within the
21332 current precision. For complex numbers, both the real parts and the
21333 imaginary parts must be equal to within the current precision. If
21334 @samp{a} is a formula (say, a variable name), then the function is
21335 applied until two successive results are exactly the same formula.
21336 It is up to you to ensure that the function will eventually converge;
21337 if it doesn't, you may have to press @kbd{C-g} to stop the Calculator.
21339 The algebraic @code{fixp} function takes two optional arguments, @samp{n}
21340 and @samp{tol}. The first is the maximum number of steps to be allowed,
21341 and must be either an integer or the symbol @samp{inf} (infinity, the
21342 default). The second is a convergence tolerance. If a tolerance is
21343 specified, all results during the calculation must be numbers, not
21344 formulas, and the iteration stops when the magnitude of the difference
21345 between two successive results is less than or equal to the tolerance.
21346 (This implies that a tolerance of zero iterates until the results are
21349 Putting it all together, @samp{fixp(<(# + A/#)/2>, B, 20, 1e-10)}
21350 computes the square root of @samp{A} given the initial guess @samp{B},
21351 stopping when the result is correct within the specified tolerance, or
21352 when 20 steps have been taken, whichever is sooner.
21354 @node Generalized Products, , Nesting and Fixed Points, Reducing and Mapping
21355 @subsection Generalized Products
21358 @pindex calc-outer-product
21360 The @kbd{V O} (@code{calc-outer-product}) [@code{outer}] command applies
21361 a given binary operator to all possible pairs of elements from two
21362 vectors, to produce a matrix. For example, @kbd{V O *} with @samp{[a, b]}
21363 and @samp{[x, y, z]} on the stack produces a multiplication table:
21364 @samp{[[a x, a y, a z], [b x, b y, b z]]}. Element @var{r},@var{c} of
21365 the result matrix is obtained by applying the operator to element @var{r}
21366 of the lefthand vector and element @var{c} of the righthand vector.
21369 @pindex calc-inner-product
21371 The @kbd{V I} (@code{calc-inner-product}) [@code{inner}] command computes
21372 the generalized inner product of two vectors or matrices, given a
21373 ``multiplicative'' operator and an ``additive'' operator. These can each
21374 actually be any binary operators; if they are @samp{*} and @samp{+},
21375 respectively, the result is a standard matrix multiplication. Element
21376 @var{r},@var{c} of the result matrix is obtained by mapping the
21377 multiplicative operator across row @var{r} of the lefthand matrix and
21378 column @var{c} of the righthand matrix, and then reducing with the additive
21379 operator. Just as for the standard @kbd{*} command, this can also do a
21380 vector-matrix or matrix-vector inner product, or a vector-vector
21381 generalized dot product.
21383 Since @kbd{V I} requires two operators, it prompts twice. In each case,
21384 you can use any of the usual methods for entering the operator. If you
21385 use @kbd{$} twice to take both operator formulas from the stack, the
21386 first (multiplicative) operator is taken from the top of the stack
21387 and the second (additive) operator is taken from second-to-top.
21389 @node Vector and Matrix Formats, , Reducing and Mapping, Matrix Functions
21390 @section Vector and Matrix Display Formats
21393 Commands for controlling vector and matrix display use the @kbd{v} prefix
21394 instead of the usual @kbd{d} prefix. But they are display modes; in
21395 particular, they are influenced by the @kbd{I} and @kbd{H} prefix keys
21396 in the same way (@pxref{Display Modes}). Matrix display is also
21397 influenced by the @kbd{d O} (@code{calc-flat-language}) mode;
21398 @pxref{Normal Language Modes}.
21401 @pindex calc-matrix-left-justify
21403 @pindex calc-matrix-center-justify
21405 @pindex calc-matrix-right-justify
21406 The commands @kbd{v <} (@code{calc-matrix-left-justify}), @kbd{v >}
21407 (@code{calc-matrix-right-justify}), and @w{@kbd{v =}}
21408 (@code{calc-matrix-center-justify}) control whether matrix elements
21409 are justified to the left, right, or center of their columns.
21412 @pindex calc-vector-brackets
21414 @pindex calc-vector-braces
21416 @pindex calc-vector-parens
21417 The @kbd{v [} (@code{calc-vector-brackets}) command turns the square
21418 brackets that surround vectors and matrices displayed in the stack on
21419 and off. The @kbd{v @{} (@code{calc-vector-braces}) and @kbd{v (}
21420 (@code{calc-vector-parens}) commands use curly braces or parentheses,
21421 respectively, instead of square brackets. For example, @kbd{v @{} might
21422 be used in preparation for yanking a matrix into a buffer running
21423 Mathematica. (In fact, the Mathematica language mode uses this mode;
21424 @pxref{Mathematica Language Mode}.) Note that, regardless of the
21425 display mode, either brackets or braces may be used to enter vectors,
21426 and parentheses may never be used for this purpose.
21429 @pindex calc-matrix-brackets
21430 The @kbd{v ]} (@code{calc-matrix-brackets}) command controls the
21431 ``big'' style display of matrices. It prompts for a string of code
21432 letters; currently implemented letters are @code{R}, which enables
21433 brackets on each row of the matrix; @code{O}, which enables outer
21434 brackets in opposite corners of the matrix; and @code{C}, which
21435 enables commas or semicolons at the ends of all rows but the last.
21436 The default format is @samp{RO}. (Before Calc 2.00, the format
21437 was fixed at @samp{ROC}.) Here are some example matrices:
21441 [ [ 123, 0, 0 ] [ [ 123, 0, 0 ],
21442 [ 0, 123, 0 ] [ 0, 123, 0 ],
21443 [ 0, 0, 123 ] ] [ 0, 0, 123 ] ]
21452 [ 123, 0, 0 [ 123, 0, 0 ;
21453 0, 123, 0 0, 123, 0 ;
21454 0, 0, 123 ] 0, 0, 123 ]
21463 [ 123, 0, 0 ] 123, 0, 0
21464 [ 0, 123, 0 ] 0, 123, 0
21465 [ 0, 0, 123 ] 0, 0, 123
21472 Note that of the formats shown here, @samp{RO}, @samp{ROC}, and
21473 @samp{OC} are all recognized as matrices during reading, while
21474 the others are useful for display only.
21477 @pindex calc-vector-commas
21478 The @kbd{v ,} (@code{calc-vector-commas}) command turns commas on and
21479 off in vector and matrix display.
21481 In vectors of length one, and in all vectors when commas have been
21482 turned off, Calc adds extra parentheses around formulas that might
21483 otherwise be ambiguous. For example, @samp{[a b]} could be a vector
21484 of the one formula @samp{a b}, or it could be a vector of two
21485 variables with commas turned off. Calc will display the former
21486 case as @samp{[(a b)]}. You can disable these extra parentheses
21487 (to make the output less cluttered at the expense of allowing some
21488 ambiguity) by adding the letter @code{P} to the control string you
21489 give to @kbd{v ]} (as described above).
21492 @pindex calc-full-vectors
21493 The @kbd{v .} (@code{calc-full-vectors}) command turns abbreviated
21494 display of long vectors on and off. In this mode, vectors of six
21495 or more elements, or matrices of six or more rows or columns, will
21496 be displayed in an abbreviated form that displays only the first
21497 three elements and the last element: @samp{[a, b, c, ..., z]}.
21498 When very large vectors are involved this will substantially
21499 improve Calc's display speed.
21502 @pindex calc-full-trail-vectors
21503 The @kbd{t .} (@code{calc-full-trail-vectors}) command controls a
21504 similar mode for recording vectors in the Trail. If you turn on
21505 this mode, vectors of six or more elements and matrices of six or
21506 more rows or columns will be abbreviated when they are put in the
21507 Trail. The @kbd{t y} (@code{calc-trail-yank}) command will be
21508 unable to recover those vectors. If you are working with very
21509 large vectors, this mode will improve the speed of all operations
21510 that involve the trail.
21513 @pindex calc-break-vectors
21514 The @kbd{v /} (@code{calc-break-vectors}) command turns multi-line
21515 vector display on and off. Normally, matrices are displayed with one
21516 row per line but all other types of vectors are displayed in a single
21517 line. This mode causes all vectors, whether matrices or not, to be
21518 displayed with a single element per line. Sub-vectors within the
21519 vectors will still use the normal linear form.
21521 @node Algebra, Units, Matrix Functions, Top
21525 This section covers the Calc features that help you work with
21526 algebraic formulas. First, the general sub-formula selection
21527 mechanism is described; this works in conjunction with any Calc
21528 commands. Then, commands for specific algebraic operations are
21529 described. Finally, the flexible @dfn{rewrite rule} mechanism
21532 The algebraic commands use the @kbd{a} key prefix; selection
21533 commands use the @kbd{j} (for ``just a letter that wasn't used
21534 for anything else'') prefix.
21536 @xref{Editing Stack Entries}, to see how to manipulate formulas
21537 using regular Emacs editing commands.
21539 When doing algebraic work, you may find several of the Calculator's
21540 modes to be helpful, including Algebraic Simplification mode (@kbd{m A})
21541 or No-Simplification mode (@kbd{m O}),
21542 Algebraic entry mode (@kbd{m a}), Fraction mode (@kbd{m f}), and
21543 Symbolic mode (@kbd{m s}). @xref{Mode Settings}, for discussions
21544 of these modes. You may also wish to select Big display mode (@kbd{d B}).
21545 @xref{Normal Language Modes}.
21548 * Selecting Subformulas::
21549 * Algebraic Manipulation::
21550 * Simplifying Formulas::
21553 * Solving Equations::
21554 * Numerical Solutions::
21557 * Logical Operations::
21561 @node Selecting Subformulas, Algebraic Manipulation, Algebra, Algebra
21562 @section Selecting Sub-Formulas
21566 @cindex Sub-formulas
21567 @cindex Parts of formulas
21568 When working with an algebraic formula it is often necessary to
21569 manipulate a portion of the formula rather than the formula as a
21570 whole. Calc allows you to ``select'' a portion of any formula on
21571 the stack. Commands which would normally operate on that stack
21572 entry will now operate only on the sub-formula, leaving the
21573 surrounding part of the stack entry alone.
21575 One common non-algebraic use for selection involves vectors. To work
21576 on one element of a vector in-place, simply select that element as a
21577 ``sub-formula'' of the vector.
21580 * Making Selections::
21581 * Changing Selections::
21582 * Displaying Selections::
21583 * Operating on Selections::
21584 * Rearranging with Selections::
21587 @node Making Selections, Changing Selections, Selecting Subformulas, Selecting Subformulas
21588 @subsection Making Selections
21592 @pindex calc-select-here
21593 To select a sub-formula, move the Emacs cursor to any character in that
21594 sub-formula, and press @w{@kbd{j s}} (@code{calc-select-here}). Calc will
21595 highlight the smallest portion of the formula that contains that
21596 character. By default the sub-formula is highlighted by blanking out
21597 all of the rest of the formula with dots. Selection works in any
21598 display mode but is perhaps easiest in Big mode (@kbd{d B}).
21599 Suppose you enter the following formula:
21611 (by typing @kbd{' ((a+b)^3 + sqrt(c)) / (2x+1)}). If you move the
21612 cursor to the letter @samp{b} and press @w{@kbd{j s}}, the display changes
21625 Every character not part of the sub-formula @samp{b} has been changed
21626 to a dot. The @samp{*} next to the line number is to remind you that
21627 the formula has a portion of it selected. (In this case, it's very
21628 obvious, but it might not always be. If Embedded mode is enabled,
21629 the word @samp{Sel} also appears in the mode line because the stack
21630 may not be visible. @pxref{Embedded Mode}.)
21632 If you had instead placed the cursor on the parenthesis immediately to
21633 the right of the @samp{b}, the selection would have been:
21645 The portion selected is always large enough to be considered a complete
21646 formula all by itself, so selecting the parenthesis selects the whole
21647 formula that it encloses. Putting the cursor on the @samp{+} sign
21648 would have had the same effect.
21650 (Strictly speaking, the Emacs cursor is really the manifestation of
21651 the Emacs ``point,'' which is a position @emph{between} two characters
21652 in the buffer. So purists would say that Calc selects the smallest
21653 sub-formula which contains the character to the right of ``point.'')
21655 If you supply a numeric prefix argument @var{n}, the selection is
21656 expanded to the @var{n}th enclosing sub-formula. Thus, positioning
21657 the cursor on the @samp{b} and typing @kbd{C-u 1 j s} will select
21658 @samp{a + b}; typing @kbd{C-u 2 j s} will select @samp{(a + b)^3},
21661 If the cursor is not on any part of the formula, or if you give a
21662 numeric prefix that is too large, the entire formula is selected.
21664 If the cursor is on the @samp{.} line that marks the top of the stack
21665 (i.e., its normal ``rest position''), this command selects the entire
21666 formula at stack level 1. Most selection commands similarly operate
21667 on the formula at the top of the stack if you haven't positioned the
21668 cursor on any stack entry.
21671 @pindex calc-select-additional
21672 The @kbd{j a} (@code{calc-select-additional}) command enlarges the
21673 current selection to encompass the cursor. To select the smallest
21674 sub-formula defined by two different points, move to the first and
21675 press @kbd{j s}, then move to the other and press @kbd{j a}. This
21676 is roughly analogous to using @kbd{C-@@} (@code{set-mark-command}) to
21677 select the two ends of a region of text during normal Emacs editing.
21680 @pindex calc-select-once
21681 The @kbd{j o} (@code{calc-select-once}) command selects a formula in
21682 exactly the same way as @kbd{j s}, except that the selection will
21683 last only as long as the next command that uses it. For example,
21684 @kbd{j o 1 +} is a handy way to add one to the sub-formula indicated
21687 (A somewhat more precise definition: The @kbd{j o} command sets a flag
21688 such that the next command involving selected stack entries will clear
21689 the selections on those stack entries afterwards. All other selection
21690 commands except @kbd{j a} and @kbd{j O} clear this flag.)
21694 @pindex calc-select-here-maybe
21695 @pindex calc-select-once-maybe
21696 The @kbd{j S} (@code{calc-select-here-maybe}) and @kbd{j O}
21697 (@code{calc-select-once-maybe}) commands are equivalent to @kbd{j s}
21698 and @kbd{j o}, respectively, except that if the formula already
21699 has a selection they have no effect. This is analogous to the
21700 behavior of some commands such as @kbd{j r} (@code{calc-rewrite-selection};
21701 @pxref{Selections with Rewrite Rules}) and is mainly intended to be
21702 used in keyboard macros that implement your own selection-oriented
21705 Selection of sub-formulas normally treats associative terms like
21706 @samp{a + b - c + d} and @samp{x * y * z} as single levels of the formula.
21707 If you place the cursor anywhere inside @samp{a + b - c + d} except
21708 on one of the variable names and use @kbd{j s}, you will select the
21709 entire four-term sum.
21712 @pindex calc-break-selections
21713 The @kbd{j b} (@code{calc-break-selections}) command controls a mode
21714 in which the ``deep structure'' of these associative formulas shows
21715 through. Calc actually stores the above formulas as @samp{((a + b) - c) + d}
21716 and @samp{x * (y * z)}. (Note that for certain obscure reasons, Calc
21717 treats multiplication as right-associative.) Once you have enabled
21718 @kbd{j b} mode, selecting with the cursor on the @samp{-} sign would
21719 only select the @samp{a + b - c} portion, which makes sense when the
21720 deep structure of the sum is considered. There is no way to select
21721 the @samp{b - c + d} portion; although this might initially look
21722 like just as legitimate a sub-formula as @samp{a + b - c}, the deep
21723 structure shows that it isn't. The @kbd{d U} command can be used
21724 to view the deep structure of any formula (@pxref{Normal Language Modes}).
21726 When @kbd{j b} mode has not been enabled, the deep structure is
21727 generally hidden by the selection commands---what you see is what
21731 @pindex calc-unselect
21732 The @kbd{j u} (@code{calc-unselect}) command unselects the formula
21733 that the cursor is on. If there was no selection in the formula,
21734 this command has no effect. With a numeric prefix argument, it
21735 unselects the @var{n}th stack element rather than using the cursor
21739 @pindex calc-clear-selections
21740 The @kbd{j c} (@code{calc-clear-selections}) command unselects all
21743 @node Changing Selections, Displaying Selections, Making Selections, Selecting Subformulas
21744 @subsection Changing Selections
21748 @pindex calc-select-more
21749 Once you have selected a sub-formula, you can expand it using the
21750 @w{@kbd{j m}} (@code{calc-select-more}) command. If @samp{a + b} is
21751 selected, pressing @w{@kbd{j m}} repeatedly works as follows:
21756 (a + b) . . . (a + b) + V c (a + b) + V c
21757 1* ............... 1* ............... 1* ---------------
21758 . . . . . . . . 2 x + 1
21763 In the last example, the entire formula is selected. This is roughly
21764 the same as having no selection at all, but because there are subtle
21765 differences the @samp{*} character is still there on the line number.
21767 With a numeric prefix argument @var{n}, @kbd{j m} expands @var{n}
21768 times (or until the entire formula is selected). Note that @kbd{j s}
21769 with argument @var{n} is equivalent to plain @kbd{j s} followed by
21770 @kbd{j m} with argument @var{n}. If @w{@kbd{j m}} is used when there
21771 is no current selection, it is equivalent to @w{@kbd{j s}}.
21773 Even though @kbd{j m} does not explicitly use the location of the
21774 cursor within the formula, it nevertheless uses the cursor to determine
21775 which stack element to operate on. As usual, @kbd{j m} when the cursor
21776 is not on any stack element operates on the top stack element.
21779 @pindex calc-select-less
21780 The @kbd{j l} (@code{calc-select-less}) command reduces the current
21781 selection around the cursor position. That is, it selects the
21782 immediate sub-formula of the current selection which contains the
21783 cursor, the opposite of @kbd{j m}. If the cursor is not inside the
21784 current selection, the command de-selects the formula.
21787 @pindex calc-select-part
21788 The @kbd{j 1} through @kbd{j 9} (@code{calc-select-part}) commands
21789 select the @var{n}th sub-formula of the current selection. They are
21790 like @kbd{j l} (@code{calc-select-less}) except they use counting
21791 rather than the cursor position to decide which sub-formula to select.
21792 For example, if the current selection is @kbd{a + b + c} or
21793 @kbd{f(a, b, c)} or @kbd{[a, b, c]}, then @kbd{j 1} selects @samp{a},
21794 @kbd{j 2} selects @samp{b}, and @kbd{j 3} selects @samp{c}; in each of
21795 these cases, @kbd{j 4} through @kbd{j 9} would be errors.
21797 If there is no current selection, @kbd{j 1} through @kbd{j 9} select
21798 the @var{n}th top-level sub-formula. (In other words, they act as if
21799 the entire stack entry were selected first.) To select the @var{n}th
21800 sub-formula where @var{n} is greater than nine, you must instead invoke
21801 @w{@kbd{j 1}} with @var{n} as a numeric prefix argument.
21805 @pindex calc-select-next
21806 @pindex calc-select-previous
21807 The @kbd{j n} (@code{calc-select-next}) and @kbd{j p}
21808 (@code{calc-select-previous}) commands change the current selection
21809 to the next or previous sub-formula at the same level. For example,
21810 if @samp{b} is selected in @w{@samp{2 + a*b*c + x}}, then @kbd{j n}
21811 selects @samp{c}. Further @kbd{j n} commands would be in error because,
21812 even though there is something to the right of @samp{c} (namely, @samp{x}),
21813 it is not at the same level; in this case, it is not a term of the
21814 same product as @samp{b} and @samp{c}. However, @kbd{j m} (to select
21815 the whole product @samp{a*b*c} as a term of the sum) followed by
21816 @w{@kbd{j n}} would successfully select the @samp{x}.
21818 Similarly, @kbd{j p} moves the selection from the @samp{b} in this
21819 sample formula to the @samp{a}. Both commands accept numeric prefix
21820 arguments to move several steps at a time.
21822 It is interesting to compare Calc's selection commands with the
21823 Emacs Info system's commands for navigating through hierarchically
21824 organized documentation. Calc's @kbd{j n} command is completely
21825 analogous to Info's @kbd{n} command. Likewise, @kbd{j p} maps to
21826 @kbd{p}, @kbd{j 2} maps to @kbd{2}, and Info's @kbd{u} is like @kbd{j m}.
21827 (Note that @kbd{j u} stands for @code{calc-unselect}, not ``up''.)
21828 The Info @kbd{m} command is somewhat similar to Calc's @kbd{j s} and
21829 @kbd{j l}; in each case, you can jump directly to a sub-component
21830 of the hierarchy simply by pointing to it with the cursor.
21832 @node Displaying Selections, Operating on Selections, Changing Selections, Selecting Subformulas
21833 @subsection Displaying Selections
21837 @pindex calc-show-selections
21838 The @kbd{j d} (@code{calc-show-selections}) command controls how
21839 selected sub-formulas are displayed. One of the alternatives is
21840 illustrated in the above examples; if we press @kbd{j d} we switch
21841 to the other style in which the selected portion itself is obscured
21847 (a + b) . . . ## # ## + V c
21848 1* ............... 1* ---------------
21853 @node Operating on Selections, Rearranging with Selections, Displaying Selections, Selecting Subformulas
21854 @subsection Operating on Selections
21857 Once a selection is made, all Calc commands that manipulate items
21858 on the stack will operate on the selected portions of the items
21859 instead. (Note that several stack elements may have selections
21860 at once, though there can be only one selection at a time in any
21861 given stack element.)
21864 @pindex calc-enable-selections
21865 The @kbd{j e} (@code{calc-enable-selections}) command disables the
21866 effect that selections have on Calc commands. The current selections
21867 still exist, but Calc commands operate on whole stack elements anyway.
21868 This mode can be identified by the fact that the @samp{*} markers on
21869 the line numbers are gone, even though selections are visible. To
21870 reactivate the selections, press @kbd{j e} again.
21872 To extract a sub-formula as a new formula, simply select the
21873 sub-formula and press @key{RET}. This normally duplicates the top
21874 stack element; here it duplicates only the selected portion of that
21877 To replace a sub-formula with something different, you can enter the
21878 new value onto the stack and press @key{TAB}. This normally exchanges
21879 the top two stack elements; here it swaps the value you entered into
21880 the selected portion of the formula, returning the old selected
21881 portion to the top of the stack.
21886 (a + b) . . . 17 x y . . . 17 x y + V c
21887 2* ............... 2* ............. 2: -------------
21888 . . . . . . . . 2 x + 1
21891 1: 17 x y 1: (a + b) 1: (a + b)
21895 In this example we select a sub-formula of our original example,
21896 enter a new formula, @key{TAB} it into place, then deselect to see
21897 the complete, edited formula.
21899 If you want to swap whole formulas around even though they contain
21900 selections, just use @kbd{j e} before and after.
21903 @pindex calc-enter-selection
21904 The @kbd{j '} (@code{calc-enter-selection}) command is another way
21905 to replace a selected sub-formula. This command does an algebraic
21906 entry just like the regular @kbd{'} key. When you press @key{RET},
21907 the formula you type replaces the original selection. You can use
21908 the @samp{$} symbol in the formula to refer to the original
21909 selection. If there is no selection in the formula under the cursor,
21910 the cursor is used to make a temporary selection for the purposes of
21911 the command. Thus, to change a term of a formula, all you have to
21912 do is move the Emacs cursor to that term and press @kbd{j '}.
21915 @pindex calc-edit-selection
21916 The @kbd{j `} (@code{calc-edit-selection}) command is a similar
21917 analogue of the @kbd{`} (@code{calc-edit}) command. It edits the
21918 selected sub-formula in a separate buffer. If there is no
21919 selection, it edits the sub-formula indicated by the cursor.
21921 To delete a sub-formula, press @key{DEL}. This generally replaces
21922 the sub-formula with the constant zero, but in a few suitable contexts
21923 it uses the constant one instead. The @key{DEL} key automatically
21924 deselects and re-simplifies the entire formula afterwards. Thus:
21929 17 x y + # # 17 x y 17 # y 17 y
21930 1* ------------- 1: ------- 1* ------- 1: -------
21931 2 x + 1 2 x + 1 2 x + 1 2 x + 1
21935 In this example, we first delete the @samp{sqrt(c)} term; Calc
21936 accomplishes this by replacing @samp{sqrt(c)} with zero and
21937 resimplifying. We then delete the @kbd{x} in the numerator;
21938 since this is part of a product, Calc replaces it with @samp{1}
21941 If you select an element of a vector and press @key{DEL}, that
21942 element is deleted from the vector. If you delete one side of
21943 an equation or inequality, only the opposite side remains.
21945 @kindex j @key{DEL}
21946 @pindex calc-del-selection
21947 The @kbd{j @key{DEL}} (@code{calc-del-selection}) command is like
21948 @key{DEL} but with the auto-selecting behavior of @kbd{j '} and
21949 @kbd{j `}. It deletes the selected portion of the formula
21950 indicated by the cursor, or, in the absence of a selection, it
21951 deletes the sub-formula indicated by the cursor position.
21953 @kindex j @key{RET}
21954 @pindex calc-grab-selection
21955 (There is also an auto-selecting @kbd{j @key{RET}} (@code{calc-copy-selection})
21958 Normal arithmetic operations also apply to sub-formulas. Here we
21959 select the denominator, press @kbd{5 -} to subtract five from the
21960 denominator, press @kbd{n} to negate the denominator, then
21961 press @kbd{Q} to take the square root.
21965 .. . .. . .. . .. .
21966 1* ....... 1* ....... 1* ....... 1* ..........
21967 2 x + 1 2 x - 4 4 - 2 x _________
21972 Certain types of operations on selections are not allowed. For
21973 example, for an arithmetic function like @kbd{-} no more than one of
21974 the arguments may be a selected sub-formula. (As the above example
21975 shows, the result of the subtraction is spliced back into the argument
21976 which had the selection; if there were more than one selection involved,
21977 this would not be well-defined.) If you try to subtract two selections,
21978 the command will abort with an error message.
21980 Operations on sub-formulas sometimes leave the formula as a whole
21981 in an ``un-natural'' state. Consider negating the @samp{2 x} term
21982 of our sample formula by selecting it and pressing @kbd{n}
21983 (@code{calc-change-sign}).
21988 1* .......... 1* ...........
21989 ......... ..........
21990 . . . 2 x . . . -2 x
21994 Unselecting the sub-formula reveals that the minus sign, which would
21995 normally have cancelled out with the subtraction automatically, has
21996 not been able to do so because the subtraction was not part of the
21997 selected portion. Pressing @kbd{=} (@code{calc-evaluate}) or doing
21998 any other mathematical operation on the whole formula will cause it
22004 1: ----------- 1: ----------
22005 __________ _________
22006 V 4 - -2 x V 4 + 2 x
22010 @node Rearranging with Selections, , Operating on Selections, Selecting Subformulas
22011 @subsection Rearranging Formulas using Selections
22015 @pindex calc-commute-right
22016 The @kbd{j R} (@code{calc-commute-right}) command moves the selected
22017 sub-formula to the right in its surrounding formula. Generally the
22018 selection is one term of a sum or product; the sum or product is
22019 rearranged according to the commutative laws of algebra.
22021 As with @kbd{j '} and @kbd{j @key{DEL}}, the term under the cursor is used
22022 if there is no selection in the current formula. All commands described
22023 in this section share this property. In this example, we place the
22024 cursor on the @samp{a} and type @kbd{j R}, then repeat.
22027 1: a + b - c 1: b + a - c 1: b - c + a
22031 Note that in the final step above, the @samp{a} is switched with
22032 the @samp{c} but the signs are adjusted accordingly. When moving
22033 terms of sums and products, @kbd{j R} will never change the
22034 mathematical meaning of the formula.
22036 The selected term may also be an element of a vector or an argument
22037 of a function. The term is exchanged with the one to its right.
22038 In this case, the ``meaning'' of the vector or function may of
22039 course be drastically changed.
22042 1: [a, b, c] 1: [b, a, c] 1: [b, c, a]
22044 1: f(a, b, c) 1: f(b, a, c) 1: f(b, c, a)
22048 @pindex calc-commute-left
22049 The @kbd{j L} (@code{calc-commute-left}) command is like @kbd{j R}
22050 except that it swaps the selected term with the one to its left.
22052 With numeric prefix arguments, these commands move the selected
22053 term several steps at a time. It is an error to try to move a
22054 term left or right past the end of its enclosing formula.
22055 With numeric prefix arguments of zero, these commands move the
22056 selected term as far as possible in the given direction.
22059 @pindex calc-sel-distribute
22060 The @kbd{j D} (@code{calc-sel-distribute}) command mixes the selected
22061 sum or product into the surrounding formula using the distributive
22062 law. For example, in @samp{a * (b - c)} with the @samp{b - c}
22063 selected, the result is @samp{a b - a c}. This also distributes
22064 products or quotients into surrounding powers, and can also do
22065 transformations like @samp{exp(a + b)} to @samp{exp(a) exp(b)},
22066 where @samp{a + b} is the selected term, and @samp{ln(a ^ b)}
22067 to @samp{ln(a) b}, where @samp{a ^ b} is the selected term.
22069 For multiple-term sums or products, @kbd{j D} takes off one term
22070 at a time: @samp{a * (b + c - d)} goes to @samp{a * (c - d) + a b}
22071 with the @samp{c - d} selected so that you can type @kbd{j D}
22072 repeatedly to expand completely. The @kbd{j D} command allows a
22073 numeric prefix argument which specifies the maximum number of
22074 times to expand at once; the default is one time only.
22076 @vindex DistribRules
22077 The @kbd{j D} command is implemented using rewrite rules.
22078 @xref{Selections with Rewrite Rules}. The rules are stored in
22079 the Calc variable @code{DistribRules}. A convenient way to view
22080 these rules is to use @kbd{s e} (@code{calc-edit-variable}) which
22081 displays and edits the stored value of a variable. Press @kbd{C-c C-c}
22082 to return from editing mode; be careful not to make any actual changes
22083 or else you will affect the behavior of future @kbd{j D} commands!
22085 To extend @kbd{j D} to handle new cases, just edit @code{DistribRules}
22086 as described above. You can then use the @kbd{s p} command to save
22087 this variable's value permanently for future Calc sessions.
22088 @xref{Operations on Variables}.
22091 @pindex calc-sel-merge
22093 The @kbd{j M} (@code{calc-sel-merge}) command is the complement
22094 of @kbd{j D}; given @samp{a b - a c} with either @samp{a b} or
22095 @samp{a c} selected, the result is @samp{a * (b - c)}. Once
22096 again, @kbd{j M} can also merge calls to functions like @code{exp}
22097 and @code{ln}; examine the variable @code{MergeRules} to see all
22098 the relevant rules.
22101 @pindex calc-sel-commute
22102 @vindex CommuteRules
22103 The @kbd{j C} (@code{calc-sel-commute}) command swaps the arguments
22104 of the selected sum, product, or equation. It always behaves as
22105 if @kbd{j b} mode were in effect, i.e., the sum @samp{a + b + c} is
22106 treated as the nested sums @samp{(a + b) + c} by this command.
22107 If you put the cursor on the first @samp{+}, the result is
22108 @samp{(b + a) + c}; if you put the cursor on the second @samp{+}, the
22109 result is @samp{c + (a + b)} (which the default simplifications
22110 will rearrange to @samp{(c + a) + b}). The relevant rules are stored
22111 in the variable @code{CommuteRules}.
22113 You may need to turn default simplifications off (with the @kbd{m O}
22114 command) in order to get the full benefit of @kbd{j C}. For example,
22115 commuting @samp{a - b} produces @samp{-b + a}, but the default
22116 simplifications will ``simplify'' this right back to @samp{a - b} if
22117 you don't turn them off. The same is true of some of the other
22118 manipulations described in this section.
22121 @pindex calc-sel-negate
22122 @vindex NegateRules
22123 The @kbd{j N} (@code{calc-sel-negate}) command replaces the selected
22124 term with the negative of that term, then adjusts the surrounding
22125 formula in order to preserve the meaning. For example, given
22126 @samp{exp(a - b)} where @samp{a - b} is selected, the result is
22127 @samp{1 / exp(b - a)}. By contrast, selecting a term and using the
22128 regular @kbd{n} (@code{calc-change-sign}) command negates the
22129 term without adjusting the surroundings, thus changing the meaning
22130 of the formula as a whole. The rules variable is @code{NegateRules}.
22133 @pindex calc-sel-invert
22134 @vindex InvertRules
22135 The @kbd{j &} (@code{calc-sel-invert}) command is similar to @kbd{j N}
22136 except it takes the reciprocal of the selected term. For example,
22137 given @samp{a - ln(b)} with @samp{b} selected, the result is
22138 @samp{a + ln(1/b)}. The rules variable is @code{InvertRules}.
22141 @pindex calc-sel-jump-equals
22143 The @kbd{j E} (@code{calc-sel-jump-equals}) command moves the
22144 selected term from one side of an equation to the other. Given
22145 @samp{a + b = c + d} with @samp{c} selected, the result is
22146 @samp{a + b - c = d}. This command also works if the selected
22147 term is part of a @samp{*}, @samp{/}, or @samp{^} formula. The
22148 relevant rules variable is @code{JumpRules}.
22152 @pindex calc-sel-isolate
22153 The @kbd{j I} (@code{calc-sel-isolate}) command isolates the
22154 selected term on its side of an equation. It uses the @kbd{a S}
22155 (@code{calc-solve-for}) command to solve the equation, and the
22156 Hyperbolic flag affects it in the same way. @xref{Solving Equations}.
22157 When it applies, @kbd{j I} is often easier to use than @kbd{j E}.
22158 It understands more rules of algebra, and works for inequalities
22159 as well as equations.
22163 @pindex calc-sel-mult-both-sides
22164 @pindex calc-sel-div-both-sides
22165 The @kbd{j *} (@code{calc-sel-mult-both-sides}) command prompts for a
22166 formula using algebraic entry, then multiplies both sides of the
22167 selected quotient or equation by that formula. It simplifies each
22168 side with @kbd{a s} (@code{calc-simplify}) before re-forming the
22169 quotient or equation. You can suppress this simplification by
22170 providing any numeric prefix argument. There is also a @kbd{j /}
22171 (@code{calc-sel-div-both-sides}) which is similar to @kbd{j *} but
22172 dividing instead of multiplying by the factor you enter.
22174 As a special feature, if the numerator of the quotient is 1, then
22175 the denominator is expanded at the top level using the distributive
22176 law (i.e., using the @kbd{C-u -1 a x} command). Suppose the
22177 formula on the stack is @samp{1 / (sqrt(a) + 1)}, and you wish
22178 to eliminate the square root in the denominator by multiplying both
22179 sides by @samp{sqrt(a) - 1}. Calc's default simplifications would
22180 change the result @samp{(sqrt(a) - 1) / (sqrt(a) - 1) (sqrt(a) + 1)}
22181 right back to the original form by cancellation; Calc expands the
22182 denominator to @samp{sqrt(a) (sqrt(a) - 1) + sqrt(a) - 1} to prevent
22183 this. (You would now want to use an @kbd{a x} command to expand
22184 the rest of the way, whereupon the denominator would cancel out to
22185 the desired form, @samp{a - 1}.) When the numerator is not 1, this
22186 initial expansion is not necessary because Calc's default
22187 simplifications will not notice the potential cancellation.
22189 If the selection is an inequality, @kbd{j *} and @kbd{j /} will
22190 accept any factor, but will warn unless they can prove the factor
22191 is either positive or negative. (In the latter case the direction
22192 of the inequality will be switched appropriately.) @xref{Declarations},
22193 for ways to inform Calc that a given variable is positive or
22194 negative. If Calc can't tell for sure what the sign of the factor
22195 will be, it will assume it is positive and display a warning
22198 For selections that are not quotients, equations, or inequalities,
22199 these commands pull out a multiplicative factor: They divide (or
22200 multiply) by the entered formula, simplify, then multiply (or divide)
22201 back by the formula.
22205 @pindex calc-sel-add-both-sides
22206 @pindex calc-sel-sub-both-sides
22207 The @kbd{j +} (@code{calc-sel-add-both-sides}) and @kbd{j -}
22208 (@code{calc-sel-sub-both-sides}) commands analogously add to or
22209 subtract from both sides of an equation or inequality. For other
22210 types of selections, they extract an additive factor. A numeric
22211 prefix argument suppresses simplification of the intermediate
22215 @pindex calc-sel-unpack
22216 The @kbd{j U} (@code{calc-sel-unpack}) command replaces the
22217 selected function call with its argument. For example, given
22218 @samp{a + sin(x^2)} with @samp{sin(x^2)} selected, the result
22219 is @samp{a + x^2}. (The @samp{x^2} will remain selected; if you
22220 wanted to change the @code{sin} to @code{cos}, just press @kbd{C}
22221 now to take the cosine of the selected part.)
22224 @pindex calc-sel-evaluate
22225 The @kbd{j v} (@code{calc-sel-evaluate}) command performs the
22226 normal default simplifications on the selected sub-formula.
22227 These are the simplifications that are normally done automatically
22228 on all results, but which may have been partially inhibited by
22229 previous selection-related operations, or turned off altogether
22230 by the @kbd{m O} command. This command is just an auto-selecting
22231 version of the @w{@kbd{a v}} command (@pxref{Algebraic Manipulation}).
22233 With a numeric prefix argument of 2, @kbd{C-u 2 j v} applies
22234 the @kbd{a s} (@code{calc-simplify}) command to the selected
22235 sub-formula. With a prefix argument of 3 or more, e.g., @kbd{C-u j v}
22236 applies the @kbd{a e} (@code{calc-simplify-extended}) command.
22237 @xref{Simplifying Formulas}. With a negative prefix argument
22238 it simplifies at the top level only, just as with @kbd{a v}.
22239 Here the ``top'' level refers to the top level of the selected
22243 @pindex calc-sel-expand-formula
22244 The @kbd{j "} (@code{calc-sel-expand-formula}) command is to @kbd{a "}
22245 (@pxref{Algebraic Manipulation}) what @kbd{j v} is to @kbd{a v}.
22247 You can use the @kbd{j r} (@code{calc-rewrite-selection}) command
22248 to define other algebraic operations on sub-formulas. @xref{Rewrite Rules}.
22250 @node Algebraic Manipulation, Simplifying Formulas, Selecting Subformulas, Algebra
22251 @section Algebraic Manipulation
22254 The commands in this section perform general-purpose algebraic
22255 manipulations. They work on the whole formula at the top of the
22256 stack (unless, of course, you have made a selection in that
22259 Many algebra commands prompt for a variable name or formula. If you
22260 answer the prompt with a blank line, the variable or formula is taken
22261 from top-of-stack, and the normal argument for the command is taken
22262 from the second-to-top stack level.
22265 @pindex calc-alg-evaluate
22266 The @kbd{a v} (@code{calc-alg-evaluate}) command performs the normal
22267 default simplifications on a formula; for example, @samp{a - -b} is
22268 changed to @samp{a + b}. These simplifications are normally done
22269 automatically on all Calc results, so this command is useful only if
22270 you have turned default simplifications off with an @kbd{m O}
22271 command. @xref{Simplification Modes}.
22273 It is often more convenient to type @kbd{=}, which is like @kbd{a v}
22274 but which also substitutes stored values for variables in the formula.
22275 Use @kbd{a v} if you want the variables to ignore their stored values.
22277 If you give a numeric prefix argument of 2 to @kbd{a v}, it simplifies
22278 as if in Algebraic Simplification mode. This is equivalent to typing
22279 @kbd{a s}; @pxref{Simplifying Formulas}. If you give a numeric prefix
22280 of 3 or more, it uses Extended Simplification mode (@kbd{a e}).
22282 If you give a negative prefix argument @mathit{-1}, @mathit{-2}, or @mathit{-3},
22283 it simplifies in the corresponding mode but only works on the top-level
22284 function call of the formula. For example, @samp{(2 + 3) * (2 + 3)} will
22285 simplify to @samp{(2 + 3)^2}, without simplifying the sub-formulas
22286 @samp{2 + 3}. As another example, typing @kbd{V R +} to sum the vector
22287 @samp{[1, 2, 3, 4]} produces the formula @samp{reduce(add, [1, 2, 3, 4])}
22288 in No-Simplify mode. Using @kbd{a v} will evaluate this all the way to
22289 10; using @kbd{C-u - a v} will evaluate it only to @samp{1 + 2 + 3 + 4}.
22290 (@xref{Reducing and Mapping}.)
22294 The @kbd{=} command corresponds to the @code{evalv} function, and
22295 the related @kbd{N} command, which is like @kbd{=} but temporarily
22296 disables Symbolic mode (@kbd{m s}) during the evaluation, corresponds
22297 to the @code{evalvn} function. (These commands interpret their prefix
22298 arguments differently than @kbd{a v}; @kbd{=} treats the prefix as
22299 the number of stack elements to evaluate at once, and @kbd{N} treats
22300 it as a temporary different working precision.)
22302 The @code{evalvn} function can take an alternate working precision
22303 as an optional second argument. This argument can be either an
22304 integer, to set the precision absolutely, or a vector containing
22305 a single integer, to adjust the precision relative to the current
22306 precision. Note that @code{evalvn} with a larger than current
22307 precision will do the calculation at this higher precision, but the
22308 result will as usual be rounded back down to the current precision
22309 afterward. For example, @samp{evalvn(pi - 3.1415)} at a precision
22310 of 12 will return @samp{9.265359e-5}; @samp{evalvn(pi - 3.1415, 30)}
22311 will return @samp{9.26535897932e-5} (computing a 25-digit result which
22312 is then rounded down to 12); and @samp{evalvn(pi - 3.1415, [-2])}
22313 will return @samp{9.2654e-5}.
22316 @pindex calc-expand-formula
22317 The @kbd{a "} (@code{calc-expand-formula}) command expands functions
22318 into their defining formulas wherever possible. For example,
22319 @samp{deg(x^2)} is changed to @samp{180 x^2 / pi}. Most functions,
22320 like @code{sin} and @code{gcd}, are not defined by simple formulas
22321 and so are unaffected by this command. One important class of
22322 functions which @emph{can} be expanded is the user-defined functions
22323 created by the @kbd{Z F} command. @xref{Algebraic Definitions}.
22324 Other functions which @kbd{a "} can expand include the probability
22325 distribution functions, most of the financial functions, and the
22326 hyperbolic and inverse hyperbolic functions. A numeric prefix argument
22327 affects @kbd{a "} in the same way as it does @kbd{a v}: A positive
22328 argument expands all functions in the formula and then simplifies in
22329 various ways; a negative argument expands and simplifies only the
22330 top-level function call.
22333 @pindex calc-map-equation
22335 The @kbd{a M} (@code{calc-map-equation}) [@code{mapeq}] command applies
22336 a given function or operator to one or more equations. It is analogous
22337 to @kbd{V M}, which operates on vectors instead of equations.
22338 @pxref{Reducing and Mapping}. For example, @kbd{a M S} changes
22339 @samp{x = y+1} to @samp{sin(x) = sin(y+1)}, and @kbd{a M +} with
22340 @samp{x = y+1} and @expr{6} on the stack produces @samp{x+6 = y+7}.
22341 With two equations on the stack, @kbd{a M +} would add the lefthand
22342 sides together and the righthand sides together to get the two
22343 respective sides of a new equation.
22345 Mapping also works on inequalities. Mapping two similar inequalities
22346 produces another inequality of the same type. Mapping an inequality
22347 with an equation produces an inequality of the same type. Mapping a
22348 @samp{<=} with a @samp{<} or @samp{!=} (not-equal) produces a @samp{<}.
22349 If inequalities with opposite direction (e.g., @samp{<} and @samp{>})
22350 are mapped, the direction of the second inequality is reversed to
22351 match the first: Using @kbd{a M +} on @samp{a < b} and @samp{a > 2}
22352 reverses the latter to get @samp{2 < a}, which then allows the
22353 combination @samp{a + 2 < b + a}, which the @kbd{a s} command can
22354 then simplify to get @samp{2 < b}.
22356 Using @kbd{a M *}, @kbd{a M /}, @kbd{a M n}, or @kbd{a M &} to negate
22357 or invert an inequality will reverse the direction of the inequality.
22358 Other adjustments to inequalities are @emph{not} done automatically;
22359 @kbd{a M S} will change @w{@samp{x < y}} to @samp{sin(x) < sin(y)} even
22360 though this is not true for all values of the variables.
22364 With the Hyperbolic flag, @kbd{H a M} [@code{mapeqp}] does a plain
22365 mapping operation without reversing the direction of any inequalities.
22366 Thus, @kbd{H a M &} would change @kbd{x > 2} to @kbd{1/x > 0.5}.
22367 (This change is mathematically incorrect, but perhaps you were
22368 fixing an inequality which was already incorrect.)
22372 With the Inverse flag, @kbd{I a M} [@code{mapeqr}] always reverses
22373 the direction of the inequality. You might use @kbd{I a M C} to
22374 change @samp{x < y} to @samp{cos(x) > cos(y)} if you know you are
22375 working with small positive angles.
22378 @pindex calc-substitute
22380 The @kbd{a b} (@code{calc-substitute}) [@code{subst}] command substitutes
22382 of some variable or sub-expression of an expression with a new
22383 sub-expression. For example, substituting @samp{sin(x)} with @samp{cos(y)}
22384 in @samp{2 sin(x)^2 + x sin(x) + sin(2 x)} produces
22385 @samp{2 cos(y)^2 + x cos(y) + @w{sin(2 x)}}.
22386 Note that this is a purely structural substitution; the lone @samp{x} and
22387 the @samp{sin(2 x)} stayed the same because they did not look like
22388 @samp{sin(x)}. @xref{Rewrite Rules}, for a more general method for
22389 doing substitutions.
22391 The @kbd{a b} command normally prompts for two formulas, the old
22392 one and the new one. If you enter a blank line for the first
22393 prompt, all three arguments are taken from the stack (new, then old,
22394 then target expression). If you type an old formula but then enter a
22395 blank line for the new one, the new formula is taken from top-of-stack
22396 and the target from second-to-top. If you answer both prompts, the
22397 target is taken from top-of-stack as usual.
22399 Note that @kbd{a b} has no understanding of commutativity or
22400 associativity. The pattern @samp{x+y} will not match the formula
22401 @samp{y+x}. Also, @samp{y+z} will not match inside the formula @samp{x+y+z}
22402 because the @samp{+} operator is left-associative, so the ``deep
22403 structure'' of that formula is @samp{(x+y) + z}. Use @kbd{d U}
22404 (@code{calc-unformatted-language}) mode to see the true structure of
22405 a formula. The rewrite rule mechanism, discussed later, does not have
22408 As an algebraic function, @code{subst} takes three arguments:
22409 Target expression, old, new. Note that @code{subst} is always
22410 evaluated immediately, even if its arguments are variables, so if
22411 you wish to put a call to @code{subst} onto the stack you must
22412 turn the default simplifications off first (with @kbd{m O}).
22414 @node Simplifying Formulas, Polynomials, Algebraic Manipulation, Algebra
22415 @section Simplifying Formulas
22419 @pindex calc-simplify
22421 The @kbd{a s} (@code{calc-simplify}) [@code{simplify}] command applies
22422 various algebraic rules to simplify a formula. This includes rules which
22423 are not part of the default simplifications because they may be too slow
22424 to apply all the time, or may not be desirable all of the time. For
22425 example, non-adjacent terms of sums are combined, as in @samp{a + b + 2 a}
22426 to @samp{b + 3 a}, and some formulas like @samp{sin(arcsin(x))} are
22427 simplified to @samp{x}.
22429 The sections below describe all the various kinds of algebraic
22430 simplifications Calc provides in full detail. None of Calc's
22431 simplification commands are designed to pull rabbits out of hats;
22432 they simply apply certain specific rules to put formulas into
22433 less redundant or more pleasing forms. Serious algebra in Calc
22434 must be done manually, usually with a combination of selections
22435 and rewrite rules. @xref{Rearranging with Selections}.
22436 @xref{Rewrite Rules}.
22438 @xref{Simplification Modes}, for commands to control what level of
22439 simplification occurs automatically. Normally only the ``default
22440 simplifications'' occur.
22443 * Default Simplifications::
22444 * Algebraic Simplifications::
22445 * Unsafe Simplifications::
22446 * Simplification of Units::
22449 @node Default Simplifications, Algebraic Simplifications, Simplifying Formulas, Simplifying Formulas
22450 @subsection Default Simplifications
22453 @cindex Default simplifications
22454 This section describes the ``default simplifications,'' those which are
22455 normally applied to all results. For example, if you enter the variable
22456 @expr{x} on the stack twice and push @kbd{+}, Calc's default
22457 simplifications automatically change @expr{x + x} to @expr{2 x}.
22459 The @kbd{m O} command turns off the default simplifications, so that
22460 @expr{x + x} will remain in this form unless you give an explicit
22461 ``simplify'' command like @kbd{=} or @kbd{a v}. @xref{Algebraic
22462 Manipulation}. The @kbd{m D} command turns the default simplifications
22465 The most basic default simplification is the evaluation of functions.
22466 For example, @expr{2 + 3} is evaluated to @expr{5}, and @expr{@tfn{sqrt}(9)}
22467 is evaluated to @expr{3}. Evaluation does not occur if the arguments
22468 to a function are somehow of the wrong type @expr{@tfn{tan}([2,3,4])}),
22469 range (@expr{@tfn{tan}(90)}), or number (@expr{@tfn{tan}(3,5)}),
22470 or if the function name is not recognized (@expr{@tfn{f}(5)}), or if
22471 Symbolic mode (@pxref{Symbolic Mode}) prevents evaluation
22472 (@expr{@tfn{sqrt}(2)}).
22474 Calc simplifies (evaluates) the arguments to a function before it
22475 simplifies the function itself. Thus @expr{@tfn{sqrt}(5+4)} is
22476 simplified to @expr{@tfn{sqrt}(9)} before the @code{sqrt} function
22477 itself is applied. There are very few exceptions to this rule:
22478 @code{quote}, @code{lambda}, and @code{condition} (the @code{::}
22479 operator) do not evaluate their arguments, @code{if} (the @code{? :}
22480 operator) does not evaluate all of its arguments, and @code{evalto}
22481 does not evaluate its lefthand argument.
22483 Most commands apply the default simplifications to all arguments they
22484 take from the stack, perform a particular operation, then simplify
22485 the result before pushing it back on the stack. In the common special
22486 case of regular arithmetic commands like @kbd{+} and @kbd{Q} [@code{sqrt}],
22487 the arguments are simply popped from the stack and collected into a
22488 suitable function call, which is then simplified (the arguments being
22489 simplified first as part of the process, as described above).
22491 The default simplifications are too numerous to describe completely
22492 here, but this section will describe the ones that apply to the
22493 major arithmetic operators. This list will be rather technical in
22494 nature, and will probably be interesting to you only if you are
22495 a serious user of Calc's algebra facilities.
22501 As well as the simplifications described here, if you have stored
22502 any rewrite rules in the variable @code{EvalRules} then these rules
22503 will also be applied before any built-in default simplifications.
22504 @xref{Automatic Rewrites}, for details.
22510 And now, on with the default simplifications:
22512 Arithmetic operators like @kbd{+} and @kbd{*} always take two
22513 arguments in Calc's internal form. Sums and products of three or
22514 more terms are arranged by the associative law of algebra into
22515 a left-associative form for sums, @expr{((a + b) + c) + d}, and
22516 a right-associative form for products, @expr{a * (b * (c * d))}.
22517 Formulas like @expr{(a + b) + (c + d)} are rearranged to
22518 left-associative form, though this rarely matters since Calc's
22519 algebra commands are designed to hide the inner structure of
22520 sums and products as much as possible. Sums and products in
22521 their proper associative form will be written without parentheses
22522 in the examples below.
22524 Sums and products are @emph{not} rearranged according to the
22525 commutative law (@expr{a + b} to @expr{b + a}) except in a few
22526 special cases described below. Some algebra programs always
22527 rearrange terms into a canonical order, which enables them to
22528 see that @expr{a b + b a} can be simplified to @expr{2 a b}.
22529 Calc assumes you have put the terms into the order you want
22530 and generally leaves that order alone, with the consequence
22531 that formulas like the above will only be simplified if you
22532 explicitly give the @kbd{a s} command. @xref{Algebraic
22535 Differences @expr{a - b} are treated like sums @expr{a + (-b)}
22536 for purposes of simplification; one of the default simplifications
22537 is to rewrite @expr{a + (-b)} or @expr{(-b) + a}, where @expr{-b}
22538 represents a ``negative-looking'' term, into @expr{a - b} form.
22539 ``Negative-looking'' means negative numbers, negated formulas like
22540 @expr{-x}, and products or quotients in which either term is
22543 Other simplifications involving negation are @expr{-(-x)} to @expr{x};
22544 @expr{-(a b)} or @expr{-(a/b)} where either @expr{a} or @expr{b} is
22545 negative-looking, simplified by negating that term, or else where
22546 @expr{a} or @expr{b} is any number, by negating that number;
22547 @expr{-(a + b)} to @expr{-a - b}, and @expr{-(b - a)} to @expr{a - b}.
22548 (This, and rewriting @expr{(-b) + a} to @expr{a - b}, are the only
22549 cases where the order of terms in a sum is changed by the default
22552 The distributive law is used to simplify sums in some cases:
22553 @expr{a x + b x} to @expr{(a + b) x}, where @expr{a} represents
22554 a number or an implicit 1 or @mathit{-1} (as in @expr{x} or @expr{-x})
22555 and similarly for @expr{b}. Use the @kbd{a c}, @w{@kbd{a f}}, or
22556 @kbd{j M} commands to merge sums with non-numeric coefficients
22557 using the distributive law.
22559 The distributive law is only used for sums of two terms, or
22560 for adjacent terms in a larger sum. Thus @expr{a + b + b + c}
22561 is simplified to @expr{a + 2 b + c}, but @expr{a + b + c + b}
22562 is not simplified. The reason is that comparing all terms of a
22563 sum with one another would require time proportional to the
22564 square of the number of terms; Calc relegates potentially slow
22565 operations like this to commands that have to be invoked
22566 explicitly, like @kbd{a s}.
22568 Finally, @expr{a + 0} and @expr{0 + a} are simplified to @expr{a}.
22569 A consequence of the above rules is that @expr{0 - a} is simplified
22576 The products @expr{1 a} and @expr{a 1} are simplified to @expr{a};
22577 @expr{(-1) a} and @expr{a (-1)} are simplified to @expr{-a};
22578 @expr{0 a} and @expr{a 0} are simplified to @expr{0}, except that
22579 in Matrix mode where @expr{a} is not provably scalar the result
22580 is the generic zero matrix @samp{idn(0)}, and that if @expr{a} is
22581 infinite the result is @samp{nan}.
22583 Also, @expr{(-a) b} and @expr{a (-b)} are simplified to @expr{-(a b)},
22584 where this occurs for negated formulas but not for regular negative
22587 Products are commuted only to move numbers to the front:
22588 @expr{a b 2} is commuted to @expr{2 a b}.
22590 The product @expr{a (b + c)} is distributed over the sum only if
22591 @expr{a} and at least one of @expr{b} and @expr{c} are numbers:
22592 @expr{2 (x + 3)} goes to @expr{2 x + 6}. The formula
22593 @expr{(-a) (b - c)}, where @expr{-a} is a negative number, is
22594 rewritten to @expr{a (c - b)}.
22596 The distributive law of products and powers is used for adjacent
22597 terms of the product: @expr{x^a x^b} goes to
22598 @texline @math{x^{a+b}}
22599 @infoline @expr{x^(a+b)}
22600 where @expr{a} is a number, or an implicit 1 (as in @expr{x}),
22601 or the implicit one-half of @expr{@tfn{sqrt}(x)}, and similarly for
22602 @expr{b}. The result is written using @samp{sqrt} or @samp{1/sqrt}
22603 if the sum of the powers is @expr{1/2} or @expr{-1/2}, respectively.
22604 If the sum of the powers is zero, the product is simplified to
22605 @expr{1} or to @samp{idn(1)} if Matrix mode is enabled.
22607 The product of a negative power times anything but another negative
22608 power is changed to use division:
22609 @texline @math{x^{-2} y}
22610 @infoline @expr{x^(-2) y}
22611 goes to @expr{y / x^2} unless Matrix mode is
22612 in effect and neither @expr{x} nor @expr{y} are scalar (in which
22613 case it is considered unsafe to rearrange the order of the terms).
22615 Finally, @expr{a (b/c)} is rewritten to @expr{(a b)/c}, and also
22616 @expr{(a/b) c} is changed to @expr{(a c)/b} unless in Matrix mode.
22622 Simplifications for quotients are analogous to those for products.
22623 The quotient @expr{0 / x} is simplified to @expr{0}, with the same
22624 exceptions that were noted for @expr{0 x}. Likewise, @expr{x / 1}
22625 and @expr{x / (-1)} are simplified to @expr{x} and @expr{-x},
22628 The quotient @expr{x / 0} is left unsimplified or changed to an
22629 infinite quantity, as directed by the current infinite mode.
22630 @xref{Infinite Mode}.
22633 @texline @math{a / b^{-c}}
22634 @infoline @expr{a / b^(-c)}
22635 is changed to @expr{a b^c}, where @expr{-c} is any negative-looking
22636 power. Also, @expr{1 / b^c} is changed to
22637 @texline @math{b^{-c}}
22638 @infoline @expr{b^(-c)}
22639 for any power @expr{c}.
22641 Also, @expr{(-a) / b} and @expr{a / (-b)} go to @expr{-(a/b)};
22642 @expr{(a/b) / c} goes to @expr{a / (b c)}; and @expr{a / (b/c)}
22643 goes to @expr{(a c) / b} unless Matrix mode prevents this
22644 rearrangement. Similarly, @expr{a / (b:c)} is simplified to
22645 @expr{(c:b) a} for any fraction @expr{b:c}.
22647 The distributive law is applied to @expr{(a + b) / c} only if
22648 @expr{c} and at least one of @expr{a} and @expr{b} are numbers.
22649 Quotients of powers and square roots are distributed just as
22650 described for multiplication.
22652 Quotients of products cancel only in the leading terms of the
22653 numerator and denominator. In other words, @expr{a x b / a y b}
22654 is cancelled to @expr{x b / y b} but not to @expr{x / y}. Once
22655 again this is because full cancellation can be slow; use @kbd{a s}
22656 to cancel all terms of the quotient.
22658 Quotients of negative-looking values are simplified according
22659 to @expr{(-a) / (-b)} to @expr{a / b}, @expr{(-a) / (b - c)}
22660 to @expr{a / (c - b)}, and @expr{(a - b) / (-c)} to @expr{(b - a) / c}.
22666 The formula @expr{x^0} is simplified to @expr{1}, or to @samp{idn(1)}
22667 in Matrix mode. The formula @expr{0^x} is simplified to @expr{0}
22668 unless @expr{x} is a negative number, complex number or zero.
22669 If @expr{x} is negative, complex or @expr{0.0}, @expr{0^x} is an
22670 infinity or an unsimplified formula according to the current infinite
22671 mode. The expression @expr{0^0} is simplified to @expr{1}.
22673 Powers of products or quotients @expr{(a b)^c}, @expr{(a/b)^c}
22674 are distributed to @expr{a^c b^c}, @expr{a^c / b^c} only if @expr{c}
22675 is an integer, or if either @expr{a} or @expr{b} are nonnegative
22676 real numbers. Powers of powers @expr{(a^b)^c} are simplified to
22677 @texline @math{a^{b c}}
22678 @infoline @expr{a^(b c)}
22679 only when @expr{c} is an integer and @expr{b c} also
22680 evaluates to an integer. Without these restrictions these simplifications
22681 would not be safe because of problems with principal values.
22683 @texline @math{((-3)^{1/2})^2}
22684 @infoline @expr{((-3)^1:2)^2}
22685 is safe to simplify, but
22686 @texline @math{((-3)^2)^{1/2}}
22687 @infoline @expr{((-3)^2)^1:2}
22688 is not.) @xref{Declarations}, for ways to inform Calc that your
22689 variables satisfy these requirements.
22691 As a special case of this rule, @expr{@tfn{sqrt}(x)^n} is simplified to
22692 @texline @math{x^{n/2}}
22693 @infoline @expr{x^(n/2)}
22694 only for even integers @expr{n}.
22696 If @expr{a} is known to be real, @expr{b} is an even integer, and
22697 @expr{c} is a half- or quarter-integer, then @expr{(a^b)^c} is
22698 simplified to @expr{@tfn{abs}(a^(b c))}.
22700 Also, @expr{(-a)^b} is simplified to @expr{a^b} if @expr{b} is an
22701 even integer, or to @expr{-(a^b)} if @expr{b} is an odd integer,
22702 for any negative-looking expression @expr{-a}.
22704 Square roots @expr{@tfn{sqrt}(x)} generally act like one-half powers
22705 @texline @math{x^{1:2}}
22706 @infoline @expr{x^1:2}
22707 for the purposes of the above-listed simplifications.
22710 @texline @math{1 / x^{1:2}}
22711 @infoline @expr{1 / x^1:2}
22713 @texline @math{x^{-1:2}},
22714 @infoline @expr{x^(-1:2)},
22715 but @expr{1 / @tfn{sqrt}(x)} is left alone.
22721 Generic identity matrices (@pxref{Matrix Mode}) are simplified by the
22722 following rules: @expr{@tfn{idn}(a) + b} to @expr{a + b} if @expr{b}
22723 is provably scalar, or expanded out if @expr{b} is a matrix;
22724 @expr{@tfn{idn}(a) + @tfn{idn}(b)} to @expr{@tfn{idn}(a + b)};
22725 @expr{-@tfn{idn}(a)} to @expr{@tfn{idn}(-a)}; @expr{a @tfn{idn}(b)} to
22726 @expr{@tfn{idn}(a b)} if @expr{a} is provably scalar, or to @expr{a b}
22727 if @expr{a} is provably non-scalar; @expr{@tfn{idn}(a) @tfn{idn}(b)} to
22728 @expr{@tfn{idn}(a b)}; analogous simplifications for quotients involving
22729 @code{idn}; and @expr{@tfn{idn}(a)^n} to @expr{@tfn{idn}(a^n)} where
22730 @expr{n} is an integer.
22736 The @code{floor} function and other integer truncation functions
22737 vanish if the argument is provably integer-valued, so that
22738 @expr{@tfn{floor}(@tfn{round}(x))} simplifies to @expr{@tfn{round}(x)}.
22739 Also, combinations of @code{float}, @code{floor} and its friends,
22740 and @code{ffloor} and its friends, are simplified in appropriate
22741 ways. @xref{Integer Truncation}.
22743 The expression @expr{@tfn{abs}(-x)} changes to @expr{@tfn{abs}(x)}.
22744 The expression @expr{@tfn{abs}(@tfn{abs}(x))} changes to
22745 @expr{@tfn{abs}(x)}; in fact, @expr{@tfn{abs}(x)} changes to @expr{x} or
22746 @expr{-x} if @expr{x} is provably nonnegative or nonpositive
22747 (@pxref{Declarations}).
22749 While most functions do not recognize the variable @code{i} as an
22750 imaginary number, the @code{arg} function does handle the two cases
22751 @expr{@tfn{arg}(@tfn{i})} and @expr{@tfn{arg}(-@tfn{i})} just for convenience.
22753 The expression @expr{@tfn{conj}(@tfn{conj}(x))} simplifies to @expr{x}.
22754 Various other expressions involving @code{conj}, @code{re}, and
22755 @code{im} are simplified, especially if some of the arguments are
22756 provably real or involve the constant @code{i}. For example,
22757 @expr{@tfn{conj}(a + b i)} is changed to
22758 @expr{@tfn{conj}(a) - @tfn{conj}(b) i}, or to @expr{a - b i} if @expr{a}
22759 and @expr{b} are known to be real.
22761 Functions like @code{sin} and @code{arctan} generally don't have
22762 any default simplifications beyond simply evaluating the functions
22763 for suitable numeric arguments and infinity. The @kbd{a s} command
22764 described in the next section does provide some simplifications for
22765 these functions, though.
22767 One important simplification that does occur is that
22768 @expr{@tfn{ln}(@tfn{e})} is simplified to 1, and @expr{@tfn{ln}(@tfn{e}^x)} is
22769 simplified to @expr{x} for any @expr{x}. This occurs even if you have
22770 stored a different value in the Calc variable @samp{e}; but this would
22771 be a bad idea in any case if you were also using natural logarithms!
22773 Among the logical functions, @tfn{!(@var{a} <= @var{b})} changes to
22774 @tfn{@var{a} > @var{b}} and so on. Equations and inequalities where both sides
22775 are either negative-looking or zero are simplified by negating both sides
22776 and reversing the inequality. While it might seem reasonable to simplify
22777 @expr{!!x} to @expr{x}, this would not be valid in general because
22778 @expr{!!2} is 1, not 2.
22780 Most other Calc functions have few if any default simplifications
22781 defined, aside of course from evaluation when the arguments are
22784 @node Algebraic Simplifications, Unsafe Simplifications, Default Simplifications, Simplifying Formulas
22785 @subsection Algebraic Simplifications
22788 @cindex Algebraic simplifications
22789 The @kbd{a s} command makes simplifications that may be too slow to
22790 do all the time, or that may not be desirable all of the time.
22791 If you find these simplifications are worthwhile, you can type
22792 @kbd{m A} to have Calc apply them automatically.
22794 This section describes all simplifications that are performed by
22795 the @kbd{a s} command. Note that these occur in addition to the
22796 default simplifications; even if the default simplifications have
22797 been turned off by an @kbd{m O} command, @kbd{a s} will turn them
22798 back on temporarily while it simplifies the formula.
22800 There is a variable, @code{AlgSimpRules}, in which you can put rewrites
22801 to be applied by @kbd{a s}. Its use is analogous to @code{EvalRules},
22802 but without the special restrictions. Basically, the simplifier does
22803 @samp{@w{a r} AlgSimpRules} with an infinite repeat count on the whole
22804 expression being simplified, then it traverses the expression applying
22805 the built-in rules described below. If the result is different from
22806 the original expression, the process repeats with the default
22807 simplifications (including @code{EvalRules}), then @code{AlgSimpRules},
22808 then the built-in simplifications, and so on.
22814 Sums are simplified in two ways. Constant terms are commuted to the
22815 end of the sum, so that @expr{a + 2 + b} changes to @expr{a + b + 2}.
22816 The only exception is that a constant will not be commuted away
22817 from the first position of a difference, i.e., @expr{2 - x} is not
22818 commuted to @expr{-x + 2}.
22820 Also, terms of sums are combined by the distributive law, as in
22821 @expr{x + y + 2 x} to @expr{y + 3 x}. This always occurs for
22822 adjacent terms, but @kbd{a s} compares all pairs of terms including
22829 Products are sorted into a canonical order using the commutative
22830 law. For example, @expr{b c a} is commuted to @expr{a b c}.
22831 This allows easier comparison of products; for example, the default
22832 simplifications will not change @expr{x y + y x} to @expr{2 x y},
22833 but @kbd{a s} will; it first rewrites the sum to @expr{x y + x y},
22834 and then the default simplifications are able to recognize a sum
22835 of identical terms.
22837 The canonical ordering used to sort terms of products has the
22838 property that real-valued numbers, interval forms and infinities
22839 come first, and are sorted into increasing order. The @kbd{V S}
22840 command uses the same ordering when sorting a vector.
22842 Sorting of terms of products is inhibited when Matrix mode is
22843 turned on; in this case, Calc will never exchange the order of
22844 two terms unless it knows at least one of the terms is a scalar.
22846 Products of powers are distributed by comparing all pairs of
22847 terms, using the same method that the default simplifications
22848 use for adjacent terms of products.
22850 Even though sums are not sorted, the commutative law is still
22851 taken into account when terms of a product are being compared.
22852 Thus @expr{(x + y) (y + x)} will be simplified to @expr{(x + y)^2}.
22853 A subtle point is that @expr{(x - y) (y - x)} will @emph{not}
22854 be simplified to @expr{-(x - y)^2}; Calc does not notice that
22855 one term can be written as a constant times the other, even if
22856 that constant is @mathit{-1}.
22858 A fraction times any expression, @expr{(a:b) x}, is changed to
22859 a quotient involving integers: @expr{a x / b}. This is not
22860 done for floating-point numbers like @expr{0.5}, however. This
22861 is one reason why you may find it convenient to turn Fraction mode
22862 on while doing algebra; @pxref{Fraction Mode}.
22868 Quotients are simplified by comparing all terms in the numerator
22869 with all terms in the denominator for possible cancellation using
22870 the distributive law. For example, @expr{a x^2 b / c x^3 d} will
22871 cancel @expr{x^2} from the top and bottom to get @expr{a b / c x d}.
22872 (The terms in the denominator will then be rearranged to @expr{c d x}
22873 as described above.) If there is any common integer or fractional
22874 factor in the numerator and denominator, it is cancelled out;
22875 for example, @expr{(4 x + 6) / 8 x} simplifies to @expr{(2 x + 3) / 4 x}.
22877 Non-constant common factors are not found even by @kbd{a s}. To
22878 cancel the factor @expr{a} in @expr{(a x + a) / a^2} you could first
22879 use @kbd{j M} on the product @expr{a x} to Merge the numerator to
22880 @expr{a (1+x)}, which can then be simplified successfully.
22886 Integer powers of the variable @code{i} are simplified according
22887 to the identity @expr{i^2 = -1}. If you store a new value other
22888 than the complex number @expr{(0,1)} in @code{i}, this simplification
22889 will no longer occur. This is done by @kbd{a s} instead of by default
22890 in case someone (unwisely) uses the name @code{i} for a variable
22891 unrelated to complex numbers; it would be unfortunate if Calc
22892 quietly and automatically changed this formula for reasons the
22893 user might not have been thinking of.
22895 Square roots of integer or rational arguments are simplified in
22896 several ways. (Note that these will be left unevaluated only in
22897 Symbolic mode.) First, square integer or rational factors are
22898 pulled out so that @expr{@tfn{sqrt}(8)} is rewritten as
22899 @texline @math{2\,@tfn{sqrt}(2)}.
22900 @infoline @expr{2 sqrt(2)}.
22901 Conceptually speaking this implies factoring the argument into primes
22902 and moving pairs of primes out of the square root, but for reasons of
22903 efficiency Calc only looks for primes up to 29.
22905 Square roots in the denominator of a quotient are moved to the
22906 numerator: @expr{1 / @tfn{sqrt}(3)} changes to @expr{@tfn{sqrt}(3) / 3}.
22907 The same effect occurs for the square root of a fraction:
22908 @expr{@tfn{sqrt}(2:3)} changes to @expr{@tfn{sqrt}(6) / 3}.
22914 The @code{%} (modulo) operator is simplified in several ways
22915 when the modulus @expr{M} is a positive real number. First, if
22916 the argument is of the form @expr{x + n} for some real number
22917 @expr{n}, then @expr{n} is itself reduced modulo @expr{M}. For
22918 example, @samp{(x - 23) % 10} is simplified to @samp{(x + 7) % 10}.
22920 If the argument is multiplied by a constant, and this constant
22921 has a common integer divisor with the modulus, then this factor is
22922 cancelled out. For example, @samp{12 x % 15} is changed to
22923 @samp{3 (4 x % 5)} by factoring out 3. Also, @samp{(12 x + 1) % 15}
22924 is changed to @samp{3 ((4 x + 1:3) % 5)}. While these forms may
22925 not seem ``simpler,'' they allow Calc to discover useful information
22926 about modulo forms in the presence of declarations.
22928 If the modulus is 1, then Calc can use @code{int} declarations to
22929 evaluate the expression. For example, the idiom @samp{x % 2} is
22930 often used to check whether a number is odd or even. As described
22931 above, @w{@samp{2 n % 2}} and @samp{(2 n + 1) % 2} are simplified to
22932 @samp{2 (n % 1)} and @samp{2 ((n + 1:2) % 1)}, respectively; Calc
22933 can simplify these to 0 and 1 (respectively) if @code{n} has been
22934 declared to be an integer.
22940 Trigonometric functions are simplified in several ways. Whenever a
22941 products of two trigonometric functions can be replaced by a single
22942 function, the replacement is made; for example,
22943 @expr{@tfn{tan}(x) @tfn{cos}(x)} is simplified to @expr{@tfn{sin}(x)}.
22944 Reciprocals of trigonometric functions are replaced by their reciprocal
22945 function; for example, @expr{1/@tfn{sec}(x)} is simplified to
22946 @expr{@tfn{cos}(x)}. The corresponding simplifications for the
22947 hyperbolic functions are also handled.
22949 Trigonometric functions of their inverse functions are
22950 simplified. The expression @expr{@tfn{sin}(@tfn{arcsin}(x))} is
22951 simplified to @expr{x}, and similarly for @code{cos} and @code{tan}.
22952 Trigonometric functions of inverses of different trigonometric
22953 functions can also be simplified, as in @expr{@tfn{sin}(@tfn{arccos}(x))}
22954 to @expr{@tfn{sqrt}(1 - x^2)}.
22956 If the argument to @code{sin} is negative-looking, it is simplified to
22957 @expr{-@tfn{sin}(x)}, and similarly for @code{cos} and @code{tan}.
22958 Finally, certain special values of the argument are recognized;
22959 @pxref{Trigonometric and Hyperbolic Functions}.
22961 Hyperbolic functions of their inverses and of negative-looking
22962 arguments are also handled, as are exponentials of inverse
22963 hyperbolic functions.
22965 No simplifications for inverse trigonometric and hyperbolic
22966 functions are known, except for negative arguments of @code{arcsin},
22967 @code{arctan}, @code{arcsinh}, and @code{arctanh}. Note that
22968 @expr{@tfn{arcsin}(@tfn{sin}(x))} can @emph{not} safely change to
22969 @expr{x}, since this only correct within an integer multiple of
22970 @texline @math{2 \pi}
22971 @infoline @expr{2 pi}
22972 radians or 360 degrees. However, @expr{@tfn{arcsinh}(@tfn{sinh}(x))} is
22973 simplified to @expr{x} if @expr{x} is known to be real.
22975 Several simplifications that apply to logarithms and exponentials
22976 are that @expr{@tfn{exp}(@tfn{ln}(x))},
22977 @texline @tfn{e}@math{^{\ln(x)}},
22978 @infoline @expr{e^@tfn{ln}(x)},
22980 @texline @math{10^{{\rm log10}(x)}}
22981 @infoline @expr{10^@tfn{log10}(x)}
22982 all reduce to @expr{x}. Also, @expr{@tfn{ln}(@tfn{exp}(x))}, etc., can
22983 reduce to @expr{x} if @expr{x} is provably real. The form
22984 @expr{@tfn{exp}(x)^y} is simplified to @expr{@tfn{exp}(x y)}. If @expr{x}
22985 is a suitable multiple of
22986 @texline @math{\pi i}
22987 @infoline @expr{pi i}
22988 (as described above for the trigonometric functions), then
22989 @expr{@tfn{exp}(x)} or @expr{e^x} will be expanded. Finally,
22990 @expr{@tfn{ln}(x)} is simplified to a form involving @code{pi} and
22991 @code{i} where @expr{x} is provably negative, positive imaginary, or
22992 negative imaginary.
22994 The error functions @code{erf} and @code{erfc} are simplified when
22995 their arguments are negative-looking or are calls to the @code{conj}
23002 Equations and inequalities are simplified by cancelling factors
23003 of products, quotients, or sums on both sides. Inequalities
23004 change sign if a negative multiplicative factor is cancelled.
23005 Non-constant multiplicative factors as in @expr{a b = a c} are
23006 cancelled from equations only if they are provably nonzero (generally
23007 because they were declared so; @pxref{Declarations}). Factors
23008 are cancelled from inequalities only if they are nonzero and their
23011 Simplification also replaces an equation or inequality with
23012 1 or 0 (``true'' or ``false'') if it can through the use of
23013 declarations. If @expr{x} is declared to be an integer greater
23014 than 5, then @expr{x < 3}, @expr{x = 3}, and @expr{x = 7.5} are
23015 all simplified to 0, but @expr{x > 3} is simplified to 1.
23016 By a similar analysis, @expr{abs(x) >= 0} is simplified to 1,
23017 as is @expr{x^2 >= 0} if @expr{x} is known to be real.
23019 @node Unsafe Simplifications, Simplification of Units, Algebraic Simplifications, Simplifying Formulas
23020 @subsection ``Unsafe'' Simplifications
23023 @cindex Unsafe simplifications
23024 @cindex Extended simplification
23026 @pindex calc-simplify-extended
23028 @mindex esimpl@idots
23031 The @kbd{a e} (@code{calc-simplify-extended}) [@code{esimplify}] command
23033 except that it applies some additional simplifications which are not
23034 ``safe'' in all cases. Use this only if you know the values in your
23035 formula lie in the restricted ranges for which these simplifications
23036 are valid. The symbolic integrator uses @kbd{a e};
23037 one effect of this is that the integrator's results must be used with
23038 caution. Where an integral table will often attach conditions like
23039 ``for positive @expr{a} only,'' Calc (like most other symbolic
23040 integration programs) will simply produce an unqualified result.
23042 Because @kbd{a e}'s simplifications are unsafe, it is sometimes better
23043 to type @kbd{C-u -3 a v}, which does extended simplification only
23044 on the top level of the formula without affecting the sub-formulas.
23045 In fact, @kbd{C-u -3 j v} allows you to target extended simplification
23046 to any specific part of a formula.
23048 The variable @code{ExtSimpRules} contains rewrites to be applied by
23049 the @kbd{a e} command. These are applied in addition to
23050 @code{EvalRules} and @code{AlgSimpRules}. (The @kbd{a r AlgSimpRules}
23051 step described above is simply followed by an @kbd{a r ExtSimpRules} step.)
23053 Following is a complete list of ``unsafe'' simplifications performed
23060 Inverse trigonometric or hyperbolic functions, called with their
23061 corresponding non-inverse functions as arguments, are simplified
23062 by @kbd{a e}. For example, @expr{@tfn{arcsin}(@tfn{sin}(x))} changes
23063 to @expr{x}. Also, @expr{@tfn{arcsin}(@tfn{cos}(x))} and
23064 @expr{@tfn{arccos}(@tfn{sin}(x))} both change to @expr{@tfn{pi}/2 - x}.
23065 These simplifications are unsafe because they are valid only for
23066 values of @expr{x} in a certain range; outside that range, values
23067 are folded down to the 360-degree range that the inverse trigonometric
23068 functions always produce.
23070 Powers of powers @expr{(x^a)^b} are simplified to
23071 @texline @math{x^{a b}}
23072 @infoline @expr{x^(a b)}
23073 for all @expr{a} and @expr{b}. These results will be valid only
23074 in a restricted range of @expr{x}; for example, in
23075 @texline @math{(x^2)^{1:2}}
23076 @infoline @expr{(x^2)^1:2}
23077 the powers cancel to get @expr{x}, which is valid for positive values
23078 of @expr{x} but not for negative or complex values.
23080 Similarly, @expr{@tfn{sqrt}(x^a)} and @expr{@tfn{sqrt}(x)^a} are both
23081 simplified (possibly unsafely) to
23082 @texline @math{x^{a/2}}.
23083 @infoline @expr{x^(a/2)}.
23085 Forms like @expr{@tfn{sqrt}(1 - sin(x)^2)} are simplified to, e.g.,
23086 @expr{@tfn{cos}(x)}. Calc has identities of this sort for @code{sin},
23087 @code{cos}, @code{tan}, @code{sinh}, and @code{cosh}.
23089 Arguments of square roots are partially factored to look for
23090 squared terms that can be extracted. For example,
23091 @expr{@tfn{sqrt}(a^2 b^3 + a^3 b^2)} simplifies to
23092 @expr{a b @tfn{sqrt}(a+b)}.
23094 The simplifications of @expr{@tfn{ln}(@tfn{exp}(x))},
23095 @expr{@tfn{ln}(@tfn{e}^x)}, and @expr{@tfn{log10}(10^x)} to @expr{x} are also
23096 unsafe because of problems with principal values (although these
23097 simplifications are safe if @expr{x} is known to be real).
23099 Common factors are cancelled from products on both sides of an
23100 equation, even if those factors may be zero: @expr{a x / b x}
23101 to @expr{a / b}. Such factors are never cancelled from
23102 inequalities: Even @kbd{a e} is not bold enough to reduce
23103 @expr{a x < b x} to @expr{a < b} (or @expr{a > b}, depending
23104 on whether you believe @expr{x} is positive or negative).
23105 The @kbd{a M /} command can be used to divide a factor out of
23106 both sides of an inequality.
23108 @node Simplification of Units, , Unsafe Simplifications, Simplifying Formulas
23109 @subsection Simplification of Units
23112 The simplifications described in this section are applied by the
23113 @kbd{u s} (@code{calc-simplify-units}) command. These are in addition
23114 to the regular @kbd{a s} (but not @kbd{a e}) simplifications described
23115 earlier. @xref{Basic Operations on Units}.
23117 The variable @code{UnitSimpRules} contains rewrites to be applied by
23118 the @kbd{u s} command. These are applied in addition to @code{EvalRules}
23119 and @code{AlgSimpRules}.
23121 Scalar mode is automatically put into effect when simplifying units.
23122 @xref{Matrix Mode}.
23124 Sums @expr{a + b} involving units are simplified by extracting the
23125 units of @expr{a} as if by the @kbd{u x} command (call the result
23126 @expr{u_a}), then simplifying the expression @expr{b / u_a}
23127 using @kbd{u b} and @kbd{u s}. If the result has units then the sum
23128 is inconsistent and is left alone. Otherwise, it is rewritten
23129 in terms of the units @expr{u_a}.
23131 If units auto-ranging mode is enabled, products or quotients in
23132 which the first argument is a number which is out of range for the
23133 leading unit are modified accordingly.
23135 When cancelling and combining units in products and quotients,
23136 Calc accounts for unit names that differ only in the prefix letter.
23137 For example, @samp{2 km m} is simplified to @samp{2000 m^2}.
23138 However, compatible but different units like @code{ft} and @code{in}
23139 are not combined in this way.
23141 Quotients @expr{a / b} are simplified in three additional ways. First,
23142 if @expr{b} is a number or a product beginning with a number, Calc
23143 computes the reciprocal of this number and moves it to the numerator.
23145 Second, for each pair of unit names from the numerator and denominator
23146 of a quotient, if the units are compatible (e.g., they are both
23147 units of area) then they are replaced by the ratio between those
23148 units. For example, in @samp{3 s in N / kg cm} the units
23149 @samp{in / cm} will be replaced by @expr{2.54}.
23151 Third, if the units in the quotient exactly cancel out, so that
23152 a @kbd{u b} command on the quotient would produce a dimensionless
23153 number for an answer, then the quotient simplifies to that number.
23155 For powers and square roots, the ``unsafe'' simplifications
23156 @expr{(a b)^c} to @expr{a^c b^c}, @expr{(a/b)^c} to @expr{a^c / b^c},
23157 and @expr{(a^b)^c} to
23158 @texline @math{a^{b c}}
23159 @infoline @expr{a^(b c)}
23160 are done if the powers are real numbers. (These are safe in the context
23161 of units because all numbers involved can reasonably be assumed to be
23164 Also, if a unit name is raised to a fractional power, and the
23165 base units in that unit name all occur to powers which are a
23166 multiple of the denominator of the power, then the unit name
23167 is expanded out into its base units, which can then be simplified
23168 according to the previous paragraph. For example, @samp{acre^1.5}
23169 is simplified by noting that @expr{1.5 = 3:2}, that @samp{acre}
23170 is defined in terms of @samp{m^2}, and that the 2 in the power of
23171 @code{m} is a multiple of 2 in @expr{3:2}. Thus, @code{acre^1.5} is
23172 replaced by approximately
23173 @texline @math{(4046 m^2)^{1.5}}
23174 @infoline @expr{(4046 m^2)^1.5},
23175 which is then changed to
23176 @texline @math{4046^{1.5} \, (m^2)^{1.5}},
23177 @infoline @expr{4046^1.5 (m^2)^1.5},
23178 then to @expr{257440 m^3}.
23180 The functions @code{float}, @code{frac}, @code{clean}, @code{abs},
23181 as well as @code{floor} and the other integer truncation functions,
23182 applied to unit names or products or quotients involving units, are
23183 simplified. For example, @samp{round(1.6 in)} is changed to
23184 @samp{round(1.6) round(in)}; the lefthand term evaluates to 2,
23185 and the righthand term simplifies to @code{in}.
23187 The functions @code{sin}, @code{cos}, and @code{tan} with arguments
23188 that have angular units like @code{rad} or @code{arcmin} are
23189 simplified by converting to base units (radians), then evaluating
23190 with the angular mode temporarily set to radians.
23192 @node Polynomials, Calculus, Simplifying Formulas, Algebra
23193 @section Polynomials
23195 A @dfn{polynomial} is a sum of terms which are coefficients times
23196 various powers of a ``base'' variable. For example, @expr{2 x^2 + 3 x - 4}
23197 is a polynomial in @expr{x}. Some formulas can be considered
23198 polynomials in several different variables: @expr{1 + 2 x + 3 y + 4 x y^2}
23199 is a polynomial in both @expr{x} and @expr{y}. Polynomial coefficients
23200 are often numbers, but they may in general be any formulas not
23201 involving the base variable.
23204 @pindex calc-factor
23206 The @kbd{a f} (@code{calc-factor}) [@code{factor}] command factors a
23207 polynomial into a product of terms. For example, the polynomial
23208 @expr{x^3 + 2 x^2 + x} is factored into @samp{x*(x+1)^2}. As another
23209 example, @expr{a c + b d + b c + a d} is factored into the product
23210 @expr{(a + b) (c + d)}.
23212 Calc currently has three algorithms for factoring. Formulas which are
23213 linear in several variables, such as the second example above, are
23214 merged according to the distributive law. Formulas which are
23215 polynomials in a single variable, with constant integer or fractional
23216 coefficients, are factored into irreducible linear and/or quadratic
23217 terms. The first example above factors into three linear terms
23218 (@expr{x}, @expr{x+1}, and @expr{x+1} again). Finally, formulas
23219 which do not fit the above criteria are handled by the algebraic
23222 Calc's polynomial factorization algorithm works by using the general
23223 root-finding command (@w{@kbd{a P}}) to solve for the roots of the
23224 polynomial. It then looks for roots which are rational numbers
23225 or complex-conjugate pairs, and converts these into linear and
23226 quadratic terms, respectively. Because it uses floating-point
23227 arithmetic, it may be unable to find terms that involve large
23228 integers (whose number of digits approaches the current precision).
23229 Also, irreducible factors of degree higher than quadratic are not
23230 found, and polynomials in more than one variable are not treated.
23231 (A more robust factorization algorithm may be included in a future
23234 @vindex FactorRules
23246 The rewrite-based factorization method uses rules stored in the variable
23247 @code{FactorRules}. @xref{Rewrite Rules}, for a discussion of the
23248 operation of rewrite rules. The default @code{FactorRules} are able
23249 to factor quadratic forms symbolically into two linear terms,
23250 @expr{(a x + b) (c x + d)}. You can edit these rules to include other
23251 cases if you wish. To use the rules, Calc builds the formula
23252 @samp{thecoefs(x, [a, b, c, ...])} where @code{x} is the polynomial
23253 base variable and @code{a}, @code{b}, etc., are polynomial coefficients
23254 (which may be numbers or formulas). The constant term is written first,
23255 i.e., in the @code{a} position. When the rules complete, they should have
23256 changed the formula into the form @samp{thefactors(x, [f1, f2, f3, ...])}
23257 where each @code{fi} should be a factored term, e.g., @samp{x - ai}.
23258 Calc then multiplies these terms together to get the complete
23259 factored form of the polynomial. If the rules do not change the
23260 @code{thecoefs} call to a @code{thefactors} call, @kbd{a f} leaves the
23261 polynomial alone on the assumption that it is unfactorable. (Note that
23262 the function names @code{thecoefs} and @code{thefactors} are used only
23263 as placeholders; there are no actual Calc functions by those names.)
23267 The @kbd{H a f} [@code{factors}] command also factors a polynomial,
23268 but it returns a list of factors instead of an expression which is the
23269 product of the factors. Each factor is represented by a sub-vector
23270 of the factor, and the power with which it appears. For example,
23271 @expr{x^5 + x^4 - 33 x^3 + 63 x^2} factors to @expr{(x + 7) x^2 (x - 3)^2}
23272 in @kbd{a f}, or to @expr{[ [x, 2], [x+7, 1], [x-3, 2] ]} in @kbd{H a f}.
23273 If there is an overall numeric factor, it always comes first in the list.
23274 The functions @code{factor} and @code{factors} allow a second argument
23275 when written in algebraic form; @samp{factor(x,v)} factors @expr{x} with
23276 respect to the specific variable @expr{v}. The default is to factor with
23277 respect to all the variables that appear in @expr{x}.
23280 @pindex calc-collect
23282 The @kbd{a c} (@code{calc-collect}) [@code{collect}] command rearranges a
23284 polynomial in a given variable, ordered in decreasing powers of that
23285 variable. For example, given @expr{1 + 2 x + 3 y + 4 x y^2} on
23286 the stack, @kbd{a c x} would produce @expr{(2 + 4 y^2) x + (1 + 3 y)},
23287 and @kbd{a c y} would produce @expr{(4 x) y^2 + 3 y + (1 + 2 x)}.
23288 The polynomial will be expanded out using the distributive law as
23289 necessary: Collecting @expr{x} in @expr{(x - 1)^3} produces
23290 @expr{x^3 - 3 x^2 + 3 x - 1}. Terms not involving @expr{x} will
23293 The ``variable'' you specify at the prompt can actually be any
23294 expression: @kbd{a c ln(x+1)} will collect together all terms multiplied
23295 by @samp{ln(x+1)} or integer powers thereof. If @samp{x} also appears
23296 in the formula in a context other than @samp{ln(x+1)}, @kbd{a c} will
23297 treat those occurrences as unrelated to @samp{ln(x+1)}, i.e., as constants.
23300 @pindex calc-expand
23302 The @kbd{a x} (@code{calc-expand}) [@code{expand}] command expands an
23303 expression by applying the distributive law everywhere. It applies to
23304 products, quotients, and powers involving sums. By default, it fully
23305 distributes all parts of the expression. With a numeric prefix argument,
23306 the distributive law is applied only the specified number of times, then
23307 the partially expanded expression is left on the stack.
23309 The @kbd{a x} and @kbd{j D} commands are somewhat redundant. Use
23310 @kbd{a x} if you want to expand all products of sums in your formula.
23311 Use @kbd{j D} if you want to expand a particular specified term of
23312 the formula. There is an exactly analogous correspondence between
23313 @kbd{a f} and @kbd{j M}. (The @kbd{j D} and @kbd{j M} commands
23314 also know many other kinds of expansions, such as
23315 @samp{exp(a + b) = exp(a) exp(b)}, which @kbd{a x} and @kbd{a f}
23318 Calc's automatic simplifications will sometimes reverse a partial
23319 expansion. For example, the first step in expanding @expr{(x+1)^3} is
23320 to write @expr{(x+1) (x+1)^2}. If @kbd{a x} stops there and tries
23321 to put this formula onto the stack, though, Calc will automatically
23322 simplify it back to @expr{(x+1)^3} form. The solution is to turn
23323 simplification off first (@pxref{Simplification Modes}), or to run
23324 @kbd{a x} without a numeric prefix argument so that it expands all
23325 the way in one step.
23330 The @kbd{a a} (@code{calc-apart}) [@code{apart}] command expands a
23331 rational function by partial fractions. A rational function is the
23332 quotient of two polynomials; @code{apart} pulls this apart into a
23333 sum of rational functions with simple denominators. In algebraic
23334 notation, the @code{apart} function allows a second argument that
23335 specifies which variable to use as the ``base''; by default, Calc
23336 chooses the base variable automatically.
23339 @pindex calc-normalize-rat
23341 The @kbd{a n} (@code{calc-normalize-rat}) [@code{nrat}] command
23342 attempts to arrange a formula into a quotient of two polynomials.
23343 For example, given @expr{1 + (a + b/c) / d}, the result would be
23344 @expr{(b + a c + c d) / c d}. The quotient is reduced, so that
23345 @kbd{a n} will simplify @expr{(x^2 + 2x + 1) / (x^2 - 1)} by dividing
23346 out the common factor @expr{x + 1}, yielding @expr{(x + 1) / (x - 1)}.
23349 @pindex calc-poly-div
23351 The @kbd{a \} (@code{calc-poly-div}) [@code{pdiv}] command divides
23352 two polynomials @expr{u} and @expr{v}, yielding a new polynomial
23353 @expr{q}. If several variables occur in the inputs, the inputs are
23354 considered multivariate polynomials. (Calc divides by the variable
23355 with the largest power in @expr{u} first, or, in the case of equal
23356 powers, chooses the variables in alphabetical order.) For example,
23357 dividing @expr{x^2 + 3 x + 2} by @expr{x + 2} yields @expr{x + 1}.
23358 The remainder from the division, if any, is reported at the bottom
23359 of the screen and is also placed in the Trail along with the quotient.
23361 Using @code{pdiv} in algebraic notation, you can specify the particular
23362 variable to be used as the base: @code{pdiv(@var{a},@var{b},@var{x})}.
23363 If @code{pdiv} is given only two arguments (as is always the case with
23364 the @kbd{a \} command), then it does a multivariate division as outlined
23368 @pindex calc-poly-rem
23370 The @kbd{a %} (@code{calc-poly-rem}) [@code{prem}] command divides
23371 two polynomials and keeps the remainder @expr{r}. The quotient
23372 @expr{q} is discarded. For any formulas @expr{a} and @expr{b}, the
23373 results of @kbd{a \} and @kbd{a %} satisfy @expr{a = q b + r}.
23374 (This is analogous to plain @kbd{\} and @kbd{%}, which compute the
23375 integer quotient and remainder from dividing two numbers.)
23379 @pindex calc-poly-div-rem
23382 The @kbd{a /} (@code{calc-poly-div-rem}) [@code{pdivrem}] command
23383 divides two polynomials and reports both the quotient and the
23384 remainder as a vector @expr{[q, r]}. The @kbd{H a /} [@code{pdivide}]
23385 command divides two polynomials and constructs the formula
23386 @expr{q + r/b} on the stack. (Naturally if the remainder is zero,
23387 this will immediately simplify to @expr{q}.)
23390 @pindex calc-poly-gcd
23392 The @kbd{a g} (@code{calc-poly-gcd}) [@code{pgcd}] command computes
23393 the greatest common divisor of two polynomials. (The GCD actually
23394 is unique only to within a constant multiplier; Calc attempts to
23395 choose a GCD which will be unsurprising.) For example, the @kbd{a n}
23396 command uses @kbd{a g} to take the GCD of the numerator and denominator
23397 of a quotient, then divides each by the result using @kbd{a \}. (The
23398 definition of GCD ensures that this division can take place without
23399 leaving a remainder.)
23401 While the polynomials used in operations like @kbd{a /} and @kbd{a g}
23402 often have integer coefficients, this is not required. Calc can also
23403 deal with polynomials over the rationals or floating-point reals.
23404 Polynomials with modulo-form coefficients are also useful in many
23405 applications; if you enter @samp{(x^2 + 3 x - 1) mod 5}, Calc
23406 automatically transforms this into a polynomial over the field of
23407 integers mod 5: @samp{(1 mod 5) x^2 + (3 mod 5) x + (4 mod 5)}.
23409 Congratulations and thanks go to Ove Ewerlid
23410 (@code{ewerlid@@mizar.DoCS.UU.SE}), who contributed many of the
23411 polynomial routines used in the above commands.
23413 @xref{Decomposing Polynomials}, for several useful functions for
23414 extracting the individual coefficients of a polynomial.
23416 @node Calculus, Solving Equations, Polynomials, Algebra
23420 The following calculus commands do not automatically simplify their
23421 inputs or outputs using @code{calc-simplify}. You may find it helps
23422 to do this by hand by typing @kbd{a s} or @kbd{a e}. It may also help
23423 to use @kbd{a x} and/or @kbd{a c} to arrange a result in the most
23427 * Differentiation::
23429 * Customizing the Integrator::
23430 * Numerical Integration::
23434 @node Differentiation, Integration, Calculus, Calculus
23435 @subsection Differentiation
23440 @pindex calc-derivative
23443 The @kbd{a d} (@code{calc-derivative}) [@code{deriv}] command computes
23444 the derivative of the expression on the top of the stack with respect to
23445 some variable, which it will prompt you to enter. Normally, variables
23446 in the formula other than the specified differentiation variable are
23447 considered constant, i.e., @samp{deriv(y,x)} is reduced to zero. With
23448 the Hyperbolic flag, the @code{tderiv} (total derivative) operation is used
23449 instead, in which derivatives of variables are not reduced to zero
23450 unless those variables are known to be ``constant,'' i.e., independent
23451 of any other variables. (The built-in special variables like @code{pi}
23452 are considered constant, as are variables that have been declared
23453 @code{const}; @pxref{Declarations}.)
23455 With a numeric prefix argument @var{n}, this command computes the
23456 @var{n}th derivative.
23458 When working with trigonometric functions, it is best to switch to
23459 Radians mode first (with @w{@kbd{m r}}). The derivative of @samp{sin(x)}
23460 in degrees is @samp{(pi/180) cos(x)}, probably not the expected
23463 If you use the @code{deriv} function directly in an algebraic formula,
23464 you can write @samp{deriv(f,x,x0)} which represents the derivative
23465 of @expr{f} with respect to @expr{x}, evaluated at the point
23466 @texline @math{x=x_0}.
23467 @infoline @expr{x=x0}.
23469 If the formula being differentiated contains functions which Calc does
23470 not know, the derivatives of those functions are produced by adding
23471 primes (apostrophe characters). For example, @samp{deriv(f(2x), x)}
23472 produces @samp{2 f'(2 x)}, where the function @code{f'} represents the
23473 derivative of @code{f}.
23475 For functions you have defined with the @kbd{Z F} command, Calc expands
23476 the functions according to their defining formulas unless you have
23477 also defined @code{f'} suitably. For example, suppose we define
23478 @samp{sinc(x) = sin(x)/x} using @kbd{Z F}. If we then differentiate
23479 the formula @samp{sinc(2 x)}, the formula will be expanded to
23480 @samp{sin(2 x) / (2 x)} and differentiated. However, if we also
23481 define @samp{sinc'(x) = dsinc(x)}, say, then Calc will write the
23482 result as @samp{2 dsinc(2 x)}. @xref{Algebraic Definitions}.
23484 For multi-argument functions @samp{f(x,y,z)}, the derivative with respect
23485 to the first argument is written @samp{f'(x,y,z)}; derivatives with
23486 respect to the other arguments are @samp{f'2(x,y,z)} and @samp{f'3(x,y,z)}.
23487 Various higher-order derivatives can be formed in the obvious way, e.g.,
23488 @samp{f'@var{}'(x)} (the second derivative of @code{f}) or
23489 @samp{f'@var{}'2'3(x,y,z)} (@code{f} differentiated with respect to each
23492 @node Integration, Customizing the Integrator, Differentiation, Calculus
23493 @subsection Integration
23497 @pindex calc-integral
23499 The @kbd{a i} (@code{calc-integral}) [@code{integ}] command computes the
23500 indefinite integral of the expression on the top of the stack with
23501 respect to a variable. The integrator is not guaranteed to work for
23502 all integrable functions, but it is able to integrate several large
23503 classes of formulas. In particular, any polynomial or rational function
23504 (a polynomial divided by a polynomial) is acceptable. (Rational functions
23505 don't have to be in explicit quotient form, however;
23506 @texline @math{x/(1+x^{-2})}
23507 @infoline @expr{x/(1+x^-2)}
23508 is not strictly a quotient of polynomials, but it is equivalent to
23509 @expr{x^3/(x^2+1)}, which is.) Also, square roots of terms involving
23510 @expr{x} and @expr{x^2} may appear in rational functions being
23511 integrated. Finally, rational functions involving trigonometric or
23512 hyperbolic functions can be integrated.
23515 If you use the @code{integ} function directly in an algebraic formula,
23516 you can also write @samp{integ(f,x,v)} which expresses the resulting
23517 indefinite integral in terms of variable @code{v} instead of @code{x}.
23518 With four arguments, @samp{integ(f(x),x,a,b)} represents a definite
23519 integral from @code{a} to @code{b}.
23522 If you use the @code{integ} function directly in an algebraic formula,
23523 you can also write @samp{integ(f,x,v)} which expresses the resulting
23524 indefinite integral in terms of variable @code{v} instead of @code{x}.
23525 With four arguments, @samp{integ(f(x),x,a,b)} represents a definite
23526 integral $\int_a^b f(x) \, dx$.
23529 Please note that the current implementation of Calc's integrator sometimes
23530 produces results that are significantly more complex than they need to
23531 be. For example, the integral Calc finds for
23532 @texline @math{1/(x+\sqrt{x^2+1})}
23533 @infoline @expr{1/(x+sqrt(x^2+1))}
23534 is several times more complicated than the answer Mathematica
23535 returns for the same input, although the two forms are numerically
23536 equivalent. Also, any indefinite integral should be considered to have
23537 an arbitrary constant of integration added to it, although Calc does not
23538 write an explicit constant of integration in its result. For example,
23539 Calc's solution for
23540 @texline @math{1/(1+\tan x)}
23541 @infoline @expr{1/(1+tan(x))}
23542 differs from the solution given in the @emph{CRC Math Tables} by a
23544 @texline @math{\pi i / 2}
23545 @infoline @expr{pi i / 2},
23546 due to a different choice of constant of integration.
23548 The Calculator remembers all the integrals it has done. If conditions
23549 change in a way that would invalidate the old integrals, say, a switch
23550 from Degrees to Radians mode, then they will be thrown out. If you
23551 suspect this is not happening when it should, use the
23552 @code{calc-flush-caches} command; @pxref{Caches}.
23555 Calc normally will pursue integration by substitution or integration by
23556 parts up to 3 nested times before abandoning an approach as fruitless.
23557 If the integrator is taking too long, you can lower this limit by storing
23558 a number (like 2) in the variable @code{IntegLimit}. (The @kbd{s I}
23559 command is a convenient way to edit @code{IntegLimit}.) If this variable
23560 has no stored value or does not contain a nonnegative integer, a limit
23561 of 3 is used. The lower this limit is, the greater the chance that Calc
23562 will be unable to integrate a function it could otherwise handle. Raising
23563 this limit allows the Calculator to solve more integrals, though the time
23564 it takes may grow exponentially. You can monitor the integrator's actions
23565 by creating an Emacs buffer called @code{*Trace*}. If such a buffer
23566 exists, the @kbd{a i} command will write a log of its actions there.
23568 If you want to manipulate integrals in a purely symbolic way, you can
23569 set the integration nesting limit to 0 to prevent all but fast
23570 table-lookup solutions of integrals. You might then wish to define
23571 rewrite rules for integration by parts, various kinds of substitutions,
23572 and so on. @xref{Rewrite Rules}.
23574 @node Customizing the Integrator, Numerical Integration, Integration, Calculus
23575 @subsection Customizing the Integrator
23579 Calc has two built-in rewrite rules called @code{IntegRules} and
23580 @code{IntegAfterRules} which you can edit to define new integration
23581 methods. @xref{Rewrite Rules}. At each step of the integration process,
23582 Calc wraps the current integrand in a call to the fictitious function
23583 @samp{integtry(@var{expr},@var{var})}, where @var{expr} is the
23584 integrand and @var{var} is the integration variable. If your rules
23585 rewrite this to be a plain formula (not a call to @code{integtry}), then
23586 Calc will use this formula as the integral of @var{expr}. For example,
23587 the rule @samp{integtry(mysin(x),x) := -mycos(x)} would define a rule to
23588 integrate a function @code{mysin} that acts like the sine function.
23589 Then, putting @samp{4 mysin(2y+1)} on the stack and typing @kbd{a i y}
23590 will produce the integral @samp{-2 mycos(2y+1)}. Note that Calc has
23591 automatically made various transformations on the integral to allow it
23592 to use your rule; integral tables generally give rules for
23593 @samp{mysin(a x + b)}, but you don't need to use this much generality
23594 in your @code{IntegRules}.
23596 @cindex Exponential integral Ei(x)
23601 As a more serious example, the expression @samp{exp(x)/x} cannot be
23602 integrated in terms of the standard functions, so the ``exponential
23603 integral'' function
23604 @texline @math{{\rm Ei}(x)}
23605 @infoline @expr{Ei(x)}
23606 was invented to describe it.
23607 We can get Calc to do this integral in terms of a made-up @code{Ei}
23608 function by adding the rule @samp{[integtry(exp(x)/x, x) := Ei(x)]}
23609 to @code{IntegRules}. Now entering @samp{exp(2x)/x} on the stack
23610 and typing @kbd{a i x} yields @samp{Ei(2 x)}. This new rule will
23611 work with Calc's various built-in integration methods (such as
23612 integration by substitution) to solve a variety of other problems
23613 involving @code{Ei}: For example, now Calc will also be able to
23614 integrate @samp{exp(exp(x))} and @samp{ln(ln(x))} (to get @samp{Ei(exp(x))}
23615 and @samp{x ln(ln(x)) - Ei(ln(x))}, respectively).
23617 Your rule may do further integration by calling @code{integ}. For
23618 example, @samp{integtry(twice(u),x) := twice(integ(u))} allows Calc
23619 to integrate @samp{twice(sin(x))} to get @samp{twice(-cos(x))}.
23620 Note that @code{integ} was called with only one argument. This notation
23621 is allowed only within @code{IntegRules}; it means ``integrate this
23622 with respect to the same integration variable.'' If Calc is unable
23623 to integrate @code{u}, the integration that invoked @code{IntegRules}
23624 also fails. Thus integrating @samp{twice(f(x))} fails, returning the
23625 unevaluated integral @samp{integ(twice(f(x)), x)}. It is still valid
23626 to call @code{integ} with two or more arguments, however; in this case,
23627 if @code{u} is not integrable, @code{twice} itself will still be
23628 integrated: If the above rule is changed to @samp{... := twice(integ(u,x))},
23629 then integrating @samp{twice(f(x))} will yield @samp{twice(integ(f(x),x))}.
23631 If a rule instead produces the formula @samp{integsubst(@var{sexpr},
23632 @var{svar})}, either replacing the top-level @code{integtry} call or
23633 nested anywhere inside the expression, then Calc will apply the
23634 substitution @samp{@var{u} = @var{sexpr}(@var{svar})} to try to
23635 integrate the original @var{expr}. For example, the rule
23636 @samp{sqrt(a) := integsubst(sqrt(x),x)} says that if Calc ever finds
23637 a square root in the integrand, it should attempt the substitution
23638 @samp{u = sqrt(x)}. (This particular rule is unnecessary because
23639 Calc always tries ``obvious'' substitutions where @var{sexpr} actually
23640 appears in the integrand.) The variable @var{svar} may be the same
23641 as the @var{var} that appeared in the call to @code{integtry}, but
23644 When integrating according to an @code{integsubst}, Calc uses the
23645 equation solver to find the inverse of @var{sexpr} (if the integrand
23646 refers to @var{var} anywhere except in subexpressions that exactly
23647 match @var{sexpr}). It uses the differentiator to find the derivative
23648 of @var{sexpr} and/or its inverse (it has two methods that use one
23649 derivative or the other). You can also specify these items by adding
23650 extra arguments to the @code{integsubst} your rules construct; the
23651 general form is @samp{integsubst(@var{sexpr}, @var{svar}, @var{sinv},
23652 @var{sprime})}, where @var{sinv} is the inverse of @var{sexpr} (still
23653 written as a function of @var{svar}), and @var{sprime} is the
23654 derivative of @var{sexpr} with respect to @var{svar}. If you don't
23655 specify these things, and Calc is not able to work them out on its
23656 own with the information it knows, then your substitution rule will
23657 work only in very specific, simple cases.
23659 Calc applies @code{IntegRules} as if by @kbd{C-u 1 a r IntegRules};
23660 in other words, Calc stops rewriting as soon as any rule in your rule
23661 set succeeds. (If it weren't for this, the @samp{integsubst(sqrt(x),x)}
23662 example above would keep on adding layers of @code{integsubst} calls
23665 @vindex IntegSimpRules
23666 Another set of rules, stored in @code{IntegSimpRules}, are applied
23667 every time the integrator uses @kbd{a s} to simplify an intermediate
23668 result. For example, putting the rule @samp{twice(x) := 2 x} into
23669 @code{IntegSimpRules} would tell Calc to convert the @code{twice}
23670 function into a form it knows whenever integration is attempted.
23672 One more way to influence the integrator is to define a function with
23673 the @kbd{Z F} command (@pxref{Algebraic Definitions}). Calc's
23674 integrator automatically expands such functions according to their
23675 defining formulas, even if you originally asked for the function to
23676 be left unevaluated for symbolic arguments. (Certain other Calc
23677 systems, such as the differentiator and the equation solver, also
23680 @vindex IntegAfterRules
23681 Sometimes Calc is able to find a solution to your integral, but it
23682 expresses the result in a way that is unnecessarily complicated. If
23683 this happens, you can either use @code{integsubst} as described
23684 above to try to hint at a more direct path to the desired result, or
23685 you can use @code{IntegAfterRules}. This is an extra rule set that
23686 runs after the main integrator returns its result; basically, Calc does
23687 an @kbd{a r IntegAfterRules} on the result before showing it to you.
23688 (It also does an @kbd{a s}, without @code{IntegSimpRules}, after that
23689 to further simplify the result.) For example, Calc's integrator
23690 sometimes produces expressions of the form @samp{ln(1+x) - ln(1-x)};
23691 the default @code{IntegAfterRules} rewrite this into the more readable
23692 form @samp{2 arctanh(x)}. Note that, unlike @code{IntegRules},
23693 @code{IntegSimpRules} and @code{IntegAfterRules} are applied any number
23694 of times until no further changes are possible. Rewriting by
23695 @code{IntegAfterRules} occurs only after the main integrator has
23696 finished, not at every step as for @code{IntegRules} and
23697 @code{IntegSimpRules}.
23699 @node Numerical Integration, Taylor Series, Customizing the Integrator, Calculus
23700 @subsection Numerical Integration
23704 @pindex calc-num-integral
23706 If you want a purely numerical answer to an integration problem, you can
23707 use the @kbd{a I} (@code{calc-num-integral}) [@code{ninteg}] command. This
23708 command prompts for an integration variable, a lower limit, and an
23709 upper limit. Except for the integration variable, all other variables
23710 that appear in the integrand formula must have stored values. (A stored
23711 value, if any, for the integration variable itself is ignored.)
23713 Numerical integration works by evaluating your formula at many points in
23714 the specified interval. Calc uses an ``open Romberg'' method; this means
23715 that it does not evaluate the formula actually at the endpoints (so that
23716 it is safe to integrate @samp{sin(x)/x} from zero, for example). Also,
23717 the Romberg method works especially well when the function being
23718 integrated is fairly smooth. If the function is not smooth, Calc will
23719 have to evaluate it at quite a few points before it can accurately
23720 determine the value of the integral.
23722 Integration is much faster when the current precision is small. It is
23723 best to set the precision to the smallest acceptable number of digits
23724 before you use @kbd{a I}. If Calc appears to be taking too long, press
23725 @kbd{C-g} to halt it and try a lower precision. If Calc still appears
23726 to need hundreds of evaluations, check to make sure your function is
23727 well-behaved in the specified interval.
23729 It is possible for the lower integration limit to be @samp{-inf} (minus
23730 infinity). Likewise, the upper limit may be plus infinity. Calc
23731 internally transforms the integral into an equivalent one with finite
23732 limits. However, integration to or across singularities is not supported:
23733 The integral of @samp{1/sqrt(x)} from 0 to 1 exists (it can be found
23734 by Calc's symbolic integrator, for example), but @kbd{a I} will fail
23735 because the integrand goes to infinity at one of the endpoints.
23737 @node Taylor Series, , Numerical Integration, Calculus
23738 @subsection Taylor Series
23742 @pindex calc-taylor
23744 The @kbd{a t} (@code{calc-taylor}) [@code{taylor}] command computes a
23745 power series expansion or Taylor series of a function. You specify the
23746 variable and the desired number of terms. You may give an expression of
23747 the form @samp{@var{var} = @var{a}} or @samp{@var{var} - @var{a}} instead
23748 of just a variable to produce a Taylor expansion about the point @var{a}.
23749 You may specify the number of terms with a numeric prefix argument;
23750 otherwise the command will prompt you for the number of terms. Note that
23751 many series expansions have coefficients of zero for some terms, so you
23752 may appear to get fewer terms than you asked for.
23754 If the @kbd{a i} command is unable to find a symbolic integral for a
23755 function, you can get an approximation by integrating the function's
23758 @node Solving Equations, Numerical Solutions, Calculus, Algebra
23759 @section Solving Equations
23763 @pindex calc-solve-for
23765 @cindex Equations, solving
23766 @cindex Solving equations
23767 The @kbd{a S} (@code{calc-solve-for}) [@code{solve}] command rearranges
23768 an equation to solve for a specific variable. An equation is an
23769 expression of the form @expr{L = R}. For example, the command @kbd{a S x}
23770 will rearrange @expr{y = 3x + 6} to the form, @expr{x = y/3 - 2}. If the
23771 input is not an equation, it is treated like an equation of the
23774 This command also works for inequalities, as in @expr{y < 3x + 6}.
23775 Some inequalities cannot be solved where the analogous equation could
23776 be; for example, solving
23777 @texline @math{a < b \, c}
23778 @infoline @expr{a < b c}
23779 for @expr{b} is impossible
23780 without knowing the sign of @expr{c}. In this case, @kbd{a S} will
23782 @texline @math{b \mathbin{\hbox{\code{!=}}} a/c}
23783 @infoline @expr{b != a/c}
23784 (using the not-equal-to operator) to signify that the direction of the
23785 inequality is now unknown. The inequality
23786 @texline @math{a \le b \, c}
23787 @infoline @expr{a <= b c}
23788 is not even partially solved. @xref{Declarations}, for a way to tell
23789 Calc that the signs of the variables in a formula are in fact known.
23791 Two useful commands for working with the result of @kbd{a S} are
23792 @kbd{a .} (@pxref{Logical Operations}), which converts @expr{x = y/3 - 2}
23793 to @expr{y/3 - 2}, and @kbd{s l} (@pxref{Let Command}) which evaluates
23794 another formula with @expr{x} set equal to @expr{y/3 - 2}.
23797 * Multiple Solutions::
23798 * Solving Systems of Equations::
23799 * Decomposing Polynomials::
23802 @node Multiple Solutions, Solving Systems of Equations, Solving Equations, Solving Equations
23803 @subsection Multiple Solutions
23808 Some equations have more than one solution. The Hyperbolic flag
23809 (@code{H a S}) [@code{fsolve}] tells the solver to report the fully
23810 general family of solutions. It will invent variables @code{n1},
23811 @code{n2}, @dots{}, which represent independent arbitrary integers, and
23812 @code{s1}, @code{s2}, @dots{}, which represent independent arbitrary
23813 signs (either @mathit{+1} or @mathit{-1}). If you don't use the Hyperbolic
23814 flag, Calc will use zero in place of all arbitrary integers, and plus
23815 one in place of all arbitrary signs. Note that variables like @code{n1}
23816 and @code{s1} are not given any special interpretation in Calc except by
23817 the equation solver itself. As usual, you can use the @w{@kbd{s l}}
23818 (@code{calc-let}) command to obtain solutions for various actual values
23819 of these variables.
23821 For example, @kbd{' x^2 = y @key{RET} H a S x @key{RET}} solves to
23822 get @samp{x = s1 sqrt(y)}, indicating that the two solutions to the
23823 equation are @samp{sqrt(y)} and @samp{-sqrt(y)}. Another way to
23824 think about it is that the square-root operation is really a
23825 two-valued function; since every Calc function must return a
23826 single result, @code{sqrt} chooses to return the positive result.
23827 Then @kbd{H a S} doctors this result using @code{s1} to indicate
23828 the full set of possible values of the mathematical square-root.
23830 There is a similar phenomenon going the other direction: Suppose
23831 we solve @samp{sqrt(y) = x} for @code{y}. Calc squares both sides
23832 to get @samp{y = x^2}. This is correct, except that it introduces
23833 some dubious solutions. Consider solving @samp{sqrt(y) = -3}:
23834 Calc will report @expr{y = 9} as a valid solution, which is true
23835 in the mathematical sense of square-root, but false (there is no
23836 solution) for the actual Calc positive-valued @code{sqrt}. This
23837 happens for both @kbd{a S} and @kbd{H a S}.
23839 @cindex @code{GenCount} variable
23849 If you store a positive integer in the Calc variable @code{GenCount},
23850 then Calc will generate formulas of the form @samp{as(@var{n})} for
23851 arbitrary signs, and @samp{an(@var{n})} for arbitrary integers,
23852 where @var{n} represents successive values taken by incrementing
23853 @code{GenCount} by one. While the normal arbitrary sign and
23854 integer symbols start over at @code{s1} and @code{n1} with each
23855 new Calc command, the @code{GenCount} approach will give each
23856 arbitrary value a name that is unique throughout the entire Calc
23857 session. Also, the arbitrary values are function calls instead
23858 of variables, which is advantageous in some cases. For example,
23859 you can make a rewrite rule that recognizes all arbitrary signs
23860 using a pattern like @samp{as(n)}. The @kbd{s l} command only works
23861 on variables, but you can use the @kbd{a b} (@code{calc-substitute})
23862 command to substitute actual values for function calls like @samp{as(3)}.
23864 The @kbd{s G} (@code{calc-edit-GenCount}) command is a convenient
23865 way to create or edit this variable. Press @kbd{C-c C-c} to finish.
23867 If you have not stored a value in @code{GenCount}, or if the value
23868 in that variable is not a positive integer, the regular
23869 @code{s1}/@code{n1} notation is used.
23875 With the Inverse flag, @kbd{I a S} [@code{finv}] treats the expression
23876 on top of the stack as a function of the specified variable and solves
23877 to find the inverse function, written in terms of the same variable.
23878 For example, @kbd{I a S x} inverts @expr{2x + 6} to @expr{x/2 - 3}.
23879 You can use both Inverse and Hyperbolic [@code{ffinv}] to obtain a
23880 fully general inverse, as described above.
23883 @pindex calc-poly-roots
23885 Some equations, specifically polynomials, have a known, finite number
23886 of solutions. The @kbd{a P} (@code{calc-poly-roots}) [@code{roots}]
23887 command uses @kbd{H a S} to solve an equation in general form, then, for
23888 all arbitrary-sign variables like @code{s1}, and all arbitrary-integer
23889 variables like @code{n1} for which @code{n1} only usefully varies over
23890 a finite range, it expands these variables out to all their possible
23891 values. The results are collected into a vector, which is returned.
23892 For example, @samp{roots(x^4 = 1, x)} returns the four solutions
23893 @samp{[1, -1, (0, 1), (0, -1)]}. Generally an @var{n}th degree
23894 polynomial will always have @var{n} roots on the complex plane.
23895 (If you have given a @code{real} declaration for the solution
23896 variable, then only the real-valued solutions, if any, will be
23897 reported; @pxref{Declarations}.)
23899 Note that because @kbd{a P} uses @kbd{H a S}, it is able to deliver
23900 symbolic solutions if the polynomial has symbolic coefficients. Also
23901 note that Calc's solver is not able to get exact symbolic solutions
23902 to all polynomials. Polynomials containing powers up to @expr{x^4}
23903 can always be solved exactly; polynomials of higher degree sometimes
23904 can be: @expr{x^6 + x^3 + 1} is converted to @expr{(x^3)^2 + (x^3) + 1},
23905 which can be solved for @expr{x^3} using the quadratic equation, and then
23906 for @expr{x} by taking cube roots. But in many cases, like
23907 @expr{x^6 + x + 1}, Calc does not know how to rewrite the polynomial
23908 into a form it can solve. The @kbd{a P} command can still deliver a
23909 list of numerical roots, however, provided that Symbolic mode (@kbd{m s})
23910 is not turned on. (If you work with Symbolic mode on, recall that the
23911 @kbd{N} (@code{calc-eval-num}) key is a handy way to reevaluate the
23912 formula on the stack with Symbolic mode temporarily off.) Naturally,
23913 @kbd{a P} can only provide numerical roots if the polynomial coefficients
23914 are all numbers (real or complex).
23916 @node Solving Systems of Equations, Decomposing Polynomials, Multiple Solutions, Solving Equations
23917 @subsection Solving Systems of Equations
23920 @cindex Systems of equations, symbolic
23921 You can also use the commands described above to solve systems of
23922 simultaneous equations. Just create a vector of equations, then
23923 specify a vector of variables for which to solve. (You can omit
23924 the surrounding brackets when entering the vector of variables
23927 For example, putting @samp{[x + y = a, x - y = b]} on the stack
23928 and typing @kbd{a S x,y @key{RET}} produces the vector of solutions
23929 @samp{[x = a - (a-b)/2, y = (a-b)/2]}. The result vector will
23930 have the same length as the variables vector, and the variables
23931 will be listed in the same order there. Note that the solutions
23932 are not always simplified as far as possible; the solution for
23933 @expr{x} here could be improved by an application of the @kbd{a n}
23936 Calc's algorithm works by trying to eliminate one variable at a
23937 time by solving one of the equations for that variable and then
23938 substituting into the other equations. Calc will try all the
23939 possibilities, but you can speed things up by noting that Calc
23940 first tries to eliminate the first variable with the first
23941 equation, then the second variable with the second equation,
23942 and so on. It also helps to put the simpler (e.g., more linear)
23943 equations toward the front of the list. Calc's algorithm will
23944 solve any system of linear equations, and also many kinds of
23951 Normally there will be as many variables as equations. If you
23952 give fewer variables than equations (an ``over-determined'' system
23953 of equations), Calc will find a partial solution. For example,
23954 typing @kbd{a S y @key{RET}} with the above system of equations
23955 would produce @samp{[y = a - x]}. There are now several ways to
23956 express this solution in terms of the original variables; Calc uses
23957 the first one that it finds. You can control the choice by adding
23958 variable specifiers of the form @samp{elim(@var{v})} to the
23959 variables list. This says that @var{v} should be eliminated from
23960 the equations; the variable will not appear at all in the solution.
23961 For example, typing @kbd{a S y,elim(x)} would yield
23962 @samp{[y = a - (b+a)/2]}.
23964 If the variables list contains only @code{elim} specifiers,
23965 Calc simply eliminates those variables from the equations
23966 and then returns the resulting set of equations. For example,
23967 @kbd{a S elim(x)} produces @samp{[a - 2 y = b]}. Every variable
23968 eliminated will reduce the number of equations in the system
23971 Again, @kbd{a S} gives you one solution to the system of
23972 equations. If there are several solutions, you can use @kbd{H a S}
23973 to get a general family of solutions, or, if there is a finite
23974 number of solutions, you can use @kbd{a P} to get a list. (In
23975 the latter case, the result will take the form of a matrix where
23976 the rows are different solutions and the columns correspond to the
23977 variables you requested.)
23979 Another way to deal with certain kinds of overdetermined systems of
23980 equations is the @kbd{a F} command, which does least-squares fitting
23981 to satisfy the equations. @xref{Curve Fitting}.
23983 @node Decomposing Polynomials, , Solving Systems of Equations, Solving Equations
23984 @subsection Decomposing Polynomials
23991 The @code{poly} function takes a polynomial and a variable as
23992 arguments, and returns a vector of polynomial coefficients (constant
23993 coefficient first). For example, @samp{poly(x^3 + 2 x, x)} returns
23994 @expr{[0, 2, 0, 1]}. If the input is not a polynomial in @expr{x},
23995 the call to @code{poly} is left in symbolic form. If the input does
23996 not involve the variable @expr{x}, the input is returned in a list
23997 of length one, representing a polynomial with only a constant
23998 coefficient. The call @samp{poly(x, x)} returns the vector @expr{[0, 1]}.
23999 The last element of the returned vector is guaranteed to be nonzero;
24000 note that @samp{poly(0, x)} returns the empty vector @expr{[]}.
24001 Note also that @expr{x} may actually be any formula; for example,
24002 @samp{poly(sin(x)^2 - sin(x) + 3, sin(x))} returns @expr{[3, -1, 1]}.
24004 @cindex Coefficients of polynomial
24005 @cindex Degree of polynomial
24006 To get the @expr{x^k} coefficient of polynomial @expr{p}, use
24007 @samp{poly(p, x)_(k+1)}. To get the degree of polynomial @expr{p},
24008 use @samp{vlen(poly(p, x)) - 1}. For example, @samp{poly((x+1)^4, x)}
24009 returns @samp{[1, 4, 6, 4, 1]}, so @samp{poly((x+1)^4, x)_(2+1)}
24010 gives the @expr{x^2} coefficient of this polynomial, 6.
24016 One important feature of the solver is its ability to recognize
24017 formulas which are ``essentially'' polynomials. This ability is
24018 made available to the user through the @code{gpoly} function, which
24019 is used just like @code{poly}: @samp{gpoly(@var{expr}, @var{var})}.
24020 If @var{expr} is a polynomial in some term which includes @var{var}, then
24021 this function will return a vector @samp{[@var{x}, @var{c}, @var{a}]}
24022 where @var{x} is the term that depends on @var{var}, @var{c} is a
24023 vector of polynomial coefficients (like the one returned by @code{poly}),
24024 and @var{a} is a multiplier which is usually 1. Basically,
24025 @samp{@var{expr} = @var{a}*(@var{c}_1 + @var{c}_2 @var{x} +
24026 @var{c}_3 @var{x}^2 + ...)}. The last element of @var{c} is
24027 guaranteed to be non-zero, and @var{c} will not equal @samp{[1]}
24028 (i.e., the trivial decomposition @var{expr} = @var{x} is not
24029 considered a polynomial). One side effect is that @samp{gpoly(x, x)}
24030 and @samp{gpoly(6, x)}, both of which might be expected to recognize
24031 their arguments as polynomials, will not because the decomposition
24032 is considered trivial.
24034 For example, @samp{gpoly((x-2)^2, x)} returns @samp{[x, [4, -4, 1], 1]},
24035 since the expanded form of this polynomial is @expr{4 - 4 x + x^2}.
24037 The term @var{x} may itself be a polynomial in @var{var}. This is
24038 done to reduce the size of the @var{c} vector. For example,
24039 @samp{gpoly(x^4 + x^2 - 1, x)} returns @samp{[x^2, [-1, 1, 1], 1]},
24040 since a quadratic polynomial in @expr{x^2} is easier to solve than
24041 a quartic polynomial in @expr{x}.
24043 A few more examples of the kinds of polynomials @code{gpoly} can
24047 sin(x) - 1 [sin(x), [-1, 1], 1]
24048 x + 1/x - 1 [x, [1, -1, 1], 1/x]
24049 x + 1/x [x^2, [1, 1], 1/x]
24050 x^3 + 2 x [x^2, [2, 1], x]
24051 x + x^2:3 + sqrt(x) [x^1:6, [1, 1, 0, 1], x^1:2]
24052 x^(2a) + 2 x^a + 5 [x^a, [5, 2, 1], 1]
24053 (exp(-x) + exp(x)) / 2 [e^(2 x), [0.5, 0.5], e^-x]
24056 The @code{poly} and @code{gpoly} functions accept a third integer argument
24057 which specifies the largest degree of polynomial that is acceptable.
24058 If this is @expr{n}, then only @var{c} vectors of length @expr{n+1}
24059 or less will be returned. Otherwise, the @code{poly} or @code{gpoly}
24060 call will remain in symbolic form. For example, the equation solver
24061 can handle quartics and smaller polynomials, so it calls
24062 @samp{gpoly(@var{expr}, @var{var}, 4)} to discover whether @var{expr}
24063 can be treated by its linear, quadratic, cubic, or quartic formulas.
24069 The @code{pdeg} function computes the degree of a polynomial;
24070 @samp{pdeg(p,x)} is the highest power of @code{x} that appears in
24071 @code{p}. This is the same as @samp{vlen(poly(p,x))-1}, but is
24072 much more efficient. If @code{p} is constant with respect to @code{x},
24073 then @samp{pdeg(p,x) = 0}. If @code{p} is not a polynomial in @code{x}
24074 (e.g., @samp{pdeg(2 cos(x), x)}, the function remains unevaluated.
24075 It is possible to omit the second argument @code{x}, in which case
24076 @samp{pdeg(p)} returns the highest total degree of any term of the
24077 polynomial, counting all variables that appear in @code{p}. Note
24078 that @code{pdeg(c) = pdeg(c,x) = 0} for any nonzero constant @code{c};
24079 the degree of the constant zero is considered to be @code{-inf}
24086 The @code{plead} function finds the leading term of a polynomial.
24087 Thus @samp{plead(p,x)} is equivalent to @samp{poly(p,x)_vlen(poly(p,x))},
24088 though again more efficient. In particular, @samp{plead((2x+1)^10, x)}
24089 returns 1024 without expanding out the list of coefficients. The
24090 value of @code{plead(p,x)} will be zero only if @expr{p = 0}.
24096 The @code{pcont} function finds the @dfn{content} of a polynomial. This
24097 is the greatest common divisor of all the coefficients of the polynomial.
24098 With two arguments, @code{pcont(p,x)} effectively uses @samp{poly(p,x)}
24099 to get a list of coefficients, then uses @code{pgcd} (the polynomial
24100 GCD function) to combine these into an answer. For example,
24101 @samp{pcont(4 x y^2 + 6 x^2 y, x)} is @samp{2 y}. The content is
24102 basically the ``biggest'' polynomial that can be divided into @code{p}
24103 exactly. The sign of the content is the same as the sign of the leading
24106 With only one argument, @samp{pcont(p)} computes the numerical
24107 content of the polynomial, i.e., the @code{gcd} of the numerical
24108 coefficients of all the terms in the formula. Note that @code{gcd}
24109 is defined on rational numbers as well as integers; it computes
24110 the @code{gcd} of the numerators and the @code{lcm} of the
24111 denominators. Thus @samp{pcont(4:3 x y^2 + 6 x^2 y)} returns 2:3.
24112 Dividing the polynomial by this number will clear all the
24113 denominators, as well as dividing by any common content in the
24114 numerators. The numerical content of a polynomial is negative only
24115 if all the coefficients in the polynomial are negative.
24121 The @code{pprim} function finds the @dfn{primitive part} of a
24122 polynomial, which is simply the polynomial divided (using @code{pdiv}
24123 if necessary) by its content. If the input polynomial has rational
24124 coefficients, the result will have integer coefficients in simplest
24127 @node Numerical Solutions, Curve Fitting, Solving Equations, Algebra
24128 @section Numerical Solutions
24131 Not all equations can be solved symbolically. The commands in this
24132 section use numerical algorithms that can find a solution to a specific
24133 instance of an equation to any desired accuracy. Note that the
24134 numerical commands are slower than their algebraic cousins; it is a
24135 good idea to try @kbd{a S} before resorting to these commands.
24137 (@xref{Curve Fitting}, for some other, more specialized, operations
24138 on numerical data.)
24143 * Numerical Systems of Equations::
24146 @node Root Finding, Minimization, Numerical Solutions, Numerical Solutions
24147 @subsection Root Finding
24151 @pindex calc-find-root
24153 @cindex Newton's method
24154 @cindex Roots of equations
24155 @cindex Numerical root-finding
24156 The @kbd{a R} (@code{calc-find-root}) [@code{root}] command finds a
24157 numerical solution (or @dfn{root}) of an equation. (This command treats
24158 inequalities the same as equations. If the input is any other kind
24159 of formula, it is interpreted as an equation of the form @expr{X = 0}.)
24161 The @kbd{a R} command requires an initial guess on the top of the
24162 stack, and a formula in the second-to-top position. It prompts for a
24163 solution variable, which must appear in the formula. All other variables
24164 that appear in the formula must have assigned values, i.e., when
24165 a value is assigned to the solution variable and the formula is
24166 evaluated with @kbd{=}, it should evaluate to a number. Any assigned
24167 value for the solution variable itself is ignored and unaffected by
24170 When the command completes, the initial guess is replaced on the stack
24171 by a vector of two numbers: The value of the solution variable that
24172 solves the equation, and the difference between the lefthand and
24173 righthand sides of the equation at that value. Ordinarily, the second
24174 number will be zero or very nearly zero. (Note that Calc uses a
24175 slightly higher precision while finding the root, and thus the second
24176 number may be slightly different from the value you would compute from
24177 the equation yourself.)
24179 The @kbd{v h} (@code{calc-head}) command is a handy way to extract
24180 the first element of the result vector, discarding the error term.
24182 The initial guess can be a real number, in which case Calc searches
24183 for a real solution near that number, or a complex number, in which
24184 case Calc searches the whole complex plane near that number for a
24185 solution, or it can be an interval form which restricts the search
24186 to real numbers inside that interval.
24188 Calc tries to use @kbd{a d} to take the derivative of the equation.
24189 If this succeeds, it uses Newton's method. If the equation is not
24190 differentiable Calc uses a bisection method. (If Newton's method
24191 appears to be going astray, Calc switches over to bisection if it
24192 can, or otherwise gives up. In this case it may help to try again
24193 with a slightly different initial guess.) If the initial guess is a
24194 complex number, the function must be differentiable.
24196 If the formula (or the difference between the sides of an equation)
24197 is negative at one end of the interval you specify and positive at
24198 the other end, the root finder is guaranteed to find a root.
24199 Otherwise, Calc subdivides the interval into small parts looking for
24200 positive and negative values to bracket the root. When your guess is
24201 an interval, Calc will not look outside that interval for a root.
24205 The @kbd{H a R} [@code{wroot}] command is similar to @kbd{a R}, except
24206 that if the initial guess is an interval for which the function has
24207 the same sign at both ends, then rather than subdividing the interval
24208 Calc attempts to widen it to enclose a root. Use this mode if
24209 you are not sure if the function has a root in your interval.
24211 If the function is not differentiable, and you give a simple number
24212 instead of an interval as your initial guess, Calc uses this widening
24213 process even if you did not type the Hyperbolic flag. (If the function
24214 @emph{is} differentiable, Calc uses Newton's method which does not
24215 require a bounding interval in order to work.)
24217 If Calc leaves the @code{root} or @code{wroot} function in symbolic
24218 form on the stack, it will normally display an explanation for why
24219 no root was found. If you miss this explanation, press @kbd{w}
24220 (@code{calc-why}) to get it back.
24222 @node Minimization, Numerical Systems of Equations, Root Finding, Numerical Solutions
24223 @subsection Minimization
24230 @pindex calc-find-minimum
24231 @pindex calc-find-maximum
24234 @cindex Minimization, numerical
24235 The @kbd{a N} (@code{calc-find-minimum}) [@code{minimize}] command
24236 finds a minimum value for a formula. It is very similar in operation
24237 to @kbd{a R} (@code{calc-find-root}): You give the formula and an initial
24238 guess on the stack, and are prompted for the name of a variable. The guess
24239 may be either a number near the desired minimum, or an interval enclosing
24240 the desired minimum. The function returns a vector containing the
24241 value of the variable which minimizes the formula's value, along
24242 with the minimum value itself.
24244 Note that this command looks for a @emph{local} minimum. Many functions
24245 have more than one minimum; some, like
24246 @texline @math{x \sin x},
24247 @infoline @expr{x sin(x)},
24248 have infinitely many. In fact, there is no easy way to define the
24249 ``global'' minimum of
24250 @texline @math{x \sin x}
24251 @infoline @expr{x sin(x)}
24252 but Calc can still locate any particular local minimum
24253 for you. Calc basically goes downhill from the initial guess until it
24254 finds a point at which the function's value is greater both to the left
24255 and to the right. Calc does not use derivatives when minimizing a function.
24257 If your initial guess is an interval and it looks like the minimum
24258 occurs at one or the other endpoint of the interval, Calc will return
24259 that endpoint only if that endpoint is closed; thus, minimizing @expr{17 x}
24260 over @expr{[2..3]} will return @expr{[2, 38]}, but minimizing over
24261 @expr{(2..3]} would report no minimum found. In general, you should
24262 use closed intervals to find literally the minimum value in that
24263 range of @expr{x}, or open intervals to find the local minimum, if
24264 any, that happens to lie in that range.
24266 Most functions are smooth and flat near their minimum values. Because
24267 of this flatness, if the current precision is, say, 12 digits, the
24268 variable can only be determined meaningfully to about six digits. Thus
24269 you should set the precision to twice as many digits as you need in your
24280 The @kbd{H a N} [@code{wminimize}] command, analogously to @kbd{H a R},
24281 expands the guess interval to enclose a minimum rather than requiring
24282 that the minimum lie inside the interval you supply.
24284 The @kbd{a X} (@code{calc-find-maximum}) [@code{maximize}] and
24285 @kbd{H a X} [@code{wmaximize}] commands effectively minimize the
24286 negative of the formula you supply.
24288 The formula must evaluate to a real number at all points inside the
24289 interval (or near the initial guess if the guess is a number). If
24290 the initial guess is a complex number the variable will be minimized
24291 over the complex numbers; if it is real or an interval it will
24292 be minimized over the reals.
24294 @node Numerical Systems of Equations, , Minimization, Numerical Solutions
24295 @subsection Systems of Equations
24298 @cindex Systems of equations, numerical
24299 The @kbd{a R} command can also solve systems of equations. In this
24300 case, the equation should instead be a vector of equations, the
24301 guess should instead be a vector of numbers (intervals are not
24302 supported), and the variable should be a vector of variables. You
24303 can omit the brackets while entering the list of variables. Each
24304 equation must be differentiable by each variable for this mode to
24305 work. The result will be a vector of two vectors: The variable
24306 values that solved the system of equations, and the differences
24307 between the sides of the equations with those variable values.
24308 There must be the same number of equations as variables. Since
24309 only plain numbers are allowed as guesses, the Hyperbolic flag has
24310 no effect when solving a system of equations.
24312 It is also possible to minimize over many variables with @kbd{a N}
24313 (or maximize with @kbd{a X}). Once again the variable name should
24314 be replaced by a vector of variables, and the initial guess should
24315 be an equal-sized vector of initial guesses. But, unlike the case of
24316 multidimensional @kbd{a R}, the formula being minimized should
24317 still be a single formula, @emph{not} a vector. Beware that
24318 multidimensional minimization is currently @emph{very} slow.
24320 @node Curve Fitting, Summations, Numerical Solutions, Algebra
24321 @section Curve Fitting
24324 The @kbd{a F} command fits a set of data to a @dfn{model formula},
24325 such as @expr{y = m x + b} where @expr{m} and @expr{b} are parameters
24326 to be determined. For a typical set of measured data there will be
24327 no single @expr{m} and @expr{b} that exactly fit the data; in this
24328 case, Calc chooses values of the parameters that provide the closest
24333 * Polynomial and Multilinear Fits::
24334 * Error Estimates for Fits::
24335 * Standard Nonlinear Models::
24336 * Curve Fitting Details::
24340 @node Linear Fits, Polynomial and Multilinear Fits, Curve Fitting, Curve Fitting
24341 @subsection Linear Fits
24345 @pindex calc-curve-fit
24347 @cindex Linear regression
24348 @cindex Least-squares fits
24349 The @kbd{a F} (@code{calc-curve-fit}) [@code{fit}] command attempts
24350 to fit a set of data (@expr{x} and @expr{y} vectors of numbers) to a
24351 straight line, polynomial, or other function of @expr{x}. For the
24352 moment we will consider only the case of fitting to a line, and we
24353 will ignore the issue of whether or not the model was in fact a good
24356 In a standard linear least-squares fit, we have a set of @expr{(x,y)}
24357 data points that we wish to fit to the model @expr{y = m x + b}
24358 by adjusting the parameters @expr{m} and @expr{b} to make the @expr{y}
24359 values calculated from the formula be as close as possible to the actual
24360 @expr{y} values in the data set. (In a polynomial fit, the model is
24361 instead, say, @expr{y = a x^3 + b x^2 + c x + d}. In a multilinear fit,
24362 we have data points of the form @expr{(x_1,x_2,x_3,y)} and our model is
24363 @expr{y = a x_1 + b x_2 + c x_3 + d}. These will be discussed later.)
24365 In the model formula, variables like @expr{x} and @expr{x_2} are called
24366 the @dfn{independent variables}, and @expr{y} is the @dfn{dependent
24367 variable}. Variables like @expr{m}, @expr{a}, and @expr{b} are called
24368 the @dfn{parameters} of the model.
24370 The @kbd{a F} command takes the data set to be fitted from the stack.
24371 By default, it expects the data in the form of a matrix. For example,
24372 for a linear or polynomial fit, this would be a
24373 @texline @math{2\times N}
24375 matrix where the first row is a list of @expr{x} values and the second
24376 row has the corresponding @expr{y} values. For the multilinear fit
24377 shown above, the matrix would have four rows (@expr{x_1}, @expr{x_2},
24378 @expr{x_3}, and @expr{y}, respectively).
24380 If you happen to have an
24381 @texline @math{N\times2}
24383 matrix instead of a
24384 @texline @math{2\times N}
24386 matrix, just press @kbd{v t} first to transpose the matrix.
24388 After you type @kbd{a F}, Calc prompts you to select a model. For a
24389 linear fit, press the digit @kbd{1}.
24391 Calc then prompts for you to name the variables. By default it chooses
24392 high letters like @expr{x} and @expr{y} for independent variables and
24393 low letters like @expr{a} and @expr{b} for parameters. (The dependent
24394 variable doesn't need a name.) The two kinds of variables are separated
24395 by a semicolon. Since you generally care more about the names of the
24396 independent variables than of the parameters, Calc also allows you to
24397 name only those and let the parameters use default names.
24399 For example, suppose the data matrix
24404 [ [ 1, 2, 3, 4, 5 ]
24405 [ 5, 7, 9, 11, 13 ] ]
24413 $$ \pmatrix{ 1 & 2 & 3 & 4 & 5 \cr
24414 5 & 7 & 9 & 11 & 13 }
24420 is on the stack and we wish to do a simple linear fit. Type
24421 @kbd{a F}, then @kbd{1} for the model, then @key{RET} to use
24422 the default names. The result will be the formula @expr{3 + 2 x}
24423 on the stack. Calc has created the model expression @kbd{a + b x},
24424 then found the optimal values of @expr{a} and @expr{b} to fit the
24425 data. (In this case, it was able to find an exact fit.) Calc then
24426 substituted those values for @expr{a} and @expr{b} in the model
24429 The @kbd{a F} command puts two entries in the trail. One is, as
24430 always, a copy of the result that went to the stack; the other is
24431 a vector of the actual parameter values, written as equations:
24432 @expr{[a = 3, b = 2]}, in case you'd rather read them in a list
24433 than pick them out of the formula. (You can type @kbd{t y}
24434 to move this vector to the stack; see @ref{Trail Commands}.
24436 Specifying a different independent variable name will affect the
24437 resulting formula: @kbd{a F 1 k @key{RET}} produces @kbd{3 + 2 k}.
24438 Changing the parameter names (say, @kbd{a F 1 k;b,m @key{RET}}) will affect
24439 the equations that go into the trail.
24445 To see what happens when the fit is not exact, we could change
24446 the number 13 in the data matrix to 14 and try the fit again.
24453 Evaluating this formula, say with @kbd{v x 5 @key{RET} @key{TAB} V M $ @key{RET}}, shows
24454 a reasonably close match to the y-values in the data.
24457 [4.8, 7., 9.2, 11.4, 13.6]
24460 Since there is no line which passes through all the @var{n} data points,
24461 Calc has chosen a line that best approximates the data points using
24462 the method of least squares. The idea is to define the @dfn{chi-square}
24467 chi^2 = sum((y_i - (a + b x_i))^2, i, 1, N)
24473 $$ \chi^2 = \sum_{i=1}^N (y_i - (a + b x_i))^2 $$
24478 which is clearly zero if @expr{a + b x} exactly fits all data points,
24479 and increases as various @expr{a + b x_i} values fail to match the
24480 corresponding @expr{y_i} values. There are several reasons why the
24481 summand is squared, one of them being to ensure that
24482 @texline @math{\chi^2 \ge 0}.
24483 @infoline @expr{chi^2 >= 0}.
24484 Least-squares fitting simply chooses the values of @expr{a} and @expr{b}
24485 for which the error
24486 @texline @math{\chi^2}
24487 @infoline @expr{chi^2}
24488 is as small as possible.
24490 Other kinds of models do the same thing but with a different model
24491 formula in place of @expr{a + b x_i}.
24497 A numeric prefix argument causes the @kbd{a F} command to take the
24498 data in some other form than one big matrix. A positive argument @var{n}
24499 will take @var{N} items from the stack, corresponding to the @var{n} rows
24500 of a data matrix. In the linear case, @var{n} must be 2 since there
24501 is always one independent variable and one dependent variable.
24503 A prefix of zero or plain @kbd{C-u} is a compromise; Calc takes two
24504 items from the stack, an @var{n}-row matrix of @expr{x} values, and a
24505 vector of @expr{y} values. If there is only one independent variable,
24506 the @expr{x} values can be either a one-row matrix or a plain vector,
24507 in which case the @kbd{C-u} prefix is the same as a @w{@kbd{C-u 2}} prefix.
24509 @node Polynomial and Multilinear Fits, Error Estimates for Fits, Linear Fits, Curve Fitting
24510 @subsection Polynomial and Multilinear Fits
24513 To fit the data to higher-order polynomials, just type one of the
24514 digits @kbd{2} through @kbd{9} when prompted for a model. For example,
24515 we could fit the original data matrix from the previous section
24516 (with 13, not 14) to a parabola instead of a line by typing
24517 @kbd{a F 2 @key{RET}}.
24520 2.00000000001 x - 1.5e-12 x^2 + 2.99999999999
24523 Note that since the constant and linear terms are enough to fit the
24524 data exactly, it's no surprise that Calc chose a tiny contribution
24525 for @expr{x^2}. (The fact that it's not exactly zero is due only
24526 to roundoff error. Since our data are exact integers, we could get
24527 an exact answer by typing @kbd{m f} first to get Fraction mode.
24528 Then the @expr{x^2} term would vanish altogether. Usually, though,
24529 the data being fitted will be approximate floats so Fraction mode
24532 Doing the @kbd{a F 2} fit on the data set with 14 instead of 13
24533 gives a much larger @expr{x^2} contribution, as Calc bends the
24534 line slightly to improve the fit.
24537 0.142857142855 x^2 + 1.34285714287 x + 3.59999999998
24540 An important result from the theory of polynomial fitting is that it
24541 is always possible to fit @var{n} data points exactly using a polynomial
24542 of degree @mathit{@var{n}-1}, sometimes called an @dfn{interpolating polynomial}.
24543 Using the modified (14) data matrix, a model number of 4 gives
24544 a polynomial that exactly matches all five data points:
24547 0.04167 x^4 - 0.4167 x^3 + 1.458 x^2 - 0.08333 x + 4.
24550 The actual coefficients we get with a precision of 12, like
24551 @expr{0.0416666663588}, clearly suffer from loss of precision.
24552 It is a good idea to increase the working precision to several
24553 digits beyond what you need when you do a fitting operation.
24554 Or, if your data are exact, use Fraction mode to get exact
24557 You can type @kbd{i} instead of a digit at the model prompt to fit
24558 the data exactly to a polynomial. This just counts the number of
24559 columns of the data matrix to choose the degree of the polynomial
24562 Fitting data ``exactly'' to high-degree polynomials is not always
24563 a good idea, though. High-degree polynomials have a tendency to
24564 wiggle uncontrollably in between the fitting data points. Also,
24565 if the exact-fit polynomial is going to be used to interpolate or
24566 extrapolate the data, it is numerically better to use the @kbd{a p}
24567 command described below. @xref{Interpolation}.
24573 Another generalization of the linear model is to assume the
24574 @expr{y} values are a sum of linear contributions from several
24575 @expr{x} values. This is a @dfn{multilinear} fit, and it is also
24576 selected by the @kbd{1} digit key. (Calc decides whether the fit
24577 is linear or multilinear by counting the rows in the data matrix.)
24579 Given the data matrix,
24583 [ [ 1, 2, 3, 4, 5 ]
24585 [ 14.5, 15, 18.5, 22.5, 24 ] ]
24590 the command @kbd{a F 1 @key{RET}} will call the first row @expr{x} and the
24591 second row @expr{y}, and will fit the values in the third row to the
24592 model @expr{a + b x + c y}.
24598 Calc can do multilinear fits with any number of independent variables
24599 (i.e., with any number of data rows).
24605 Yet another variation is @dfn{homogeneous} linear models, in which
24606 the constant term is known to be zero. In the linear case, this
24607 means the model formula is simply @expr{a x}; in the multilinear
24608 case, the model might be @expr{a x + b y + c z}; and in the polynomial
24609 case, the model could be @expr{a x + b x^2 + c x^3}. You can get
24610 a homogeneous linear or multilinear model by pressing the letter
24611 @kbd{h} followed by a regular model key, like @kbd{1} or @kbd{2}.
24613 It is certainly possible to have other constrained linear models,
24614 like @expr{2.3 + a x} or @expr{a - 4 x}. While there is no single
24615 key to select models like these, a later section shows how to enter
24616 any desired model by hand. In the first case, for example, you
24617 would enter @kbd{a F ' 2.3 + a x}.
24619 Another class of models that will work but must be entered by hand
24620 are multinomial fits, e.g., @expr{a + b x + c y + d x^2 + e y^2 + f x y}.
24622 @node Error Estimates for Fits, Standard Nonlinear Models, Polynomial and Multilinear Fits, Curve Fitting
24623 @subsection Error Estimates for Fits
24628 With the Hyperbolic flag, @kbd{H a F} [@code{efit}] performs the same
24629 fitting operation as @kbd{a F}, but reports the coefficients as error
24630 forms instead of plain numbers. Fitting our two data matrices (first
24631 with 13, then with 14) to a line with @kbd{H a F} gives the results,
24635 2.6 +/- 0.382970843103 + 2.2 +/- 0.115470053838 x
24638 In the first case the estimated errors are zero because the linear
24639 fit is perfect. In the second case, the errors are nonzero but
24640 moderately small, because the data are still very close to linear.
24642 It is also possible for the @emph{input} to a fitting operation to
24643 contain error forms. The data values must either all include errors
24644 or all be plain numbers. Error forms can go anywhere but generally
24645 go on the numbers in the last row of the data matrix. If the last
24646 row contains error forms
24647 @texline `@var{y_i}@w{ @tfn{+/-} }@math{\sigma_i}',
24648 @infoline `@var{y_i}@w{ @tfn{+/-} }@var{sigma_i}',
24650 @texline @math{\chi^2}
24651 @infoline @expr{chi^2}
24656 chi^2 = sum(((y_i - (a + b x_i)) / sigma_i)^2, i, 1, N)
24662 $$ \chi^2 = \sum_{i=1}^N \left(y_i - (a + b x_i) \over \sigma_i\right)^2 $$
24667 so that data points with larger error estimates contribute less to
24668 the fitting operation.
24670 If there are error forms on other rows of the data matrix, all the
24671 errors for a given data point are combined; the square root of the
24672 sum of the squares of the errors forms the
24673 @texline @math{\sigma_i}
24674 @infoline @expr{sigma_i}
24675 used for the data point.
24677 Both @kbd{a F} and @kbd{H a F} can accept error forms in the input
24678 matrix, although if you are concerned about error analysis you will
24679 probably use @kbd{H a F} so that the output also contains error
24682 If the input contains error forms but all the
24683 @texline @math{\sigma_i}
24684 @infoline @expr{sigma_i}
24685 values are the same, it is easy to see that the resulting fitted model
24686 will be the same as if the input did not have error forms at all
24687 @texline (@math{\chi^2}
24688 @infoline (@expr{chi^2}
24689 is simply scaled uniformly by
24690 @texline @math{1 / \sigma^2},
24691 @infoline @expr{1 / sigma^2},
24692 which doesn't affect where it has a minimum). But there @emph{will} be
24693 a difference in the estimated errors of the coefficients reported by
24696 Consult any text on statistical modeling of data for a discussion
24697 of where these error estimates come from and how they should be
24706 With the Inverse flag, @kbd{I a F} [@code{xfit}] produces even more
24707 information. The result is a vector of six items:
24711 The model formula with error forms for its coefficients or
24712 parameters. This is the result that @kbd{H a F} would have
24716 A vector of ``raw'' parameter values for the model. These are the
24717 polynomial coefficients or other parameters as plain numbers, in the
24718 same order as the parameters appeared in the final prompt of the
24719 @kbd{I a F} command. For polynomials of degree @expr{d}, this vector
24720 will have length @expr{M = d+1} with the constant term first.
24723 The covariance matrix @expr{C} computed from the fit. This is
24724 an @var{m}x@var{m} symmetric matrix; the diagonal elements
24725 @texline @math{C_{jj}}
24726 @infoline @expr{C_j_j}
24728 @texline @math{\sigma_j^2}
24729 @infoline @expr{sigma_j^2}
24730 of the parameters. The other elements are covariances
24731 @texline @math{\sigma_{ij}^2}
24732 @infoline @expr{sigma_i_j^2}
24733 that describe the correlation between pairs of parameters. (A related
24734 set of numbers, the @dfn{linear correlation coefficients}
24735 @texline @math{r_{ij}},
24736 @infoline @expr{r_i_j},
24738 @texline @math{\sigma_{ij}^2 / \sigma_i \, \sigma_j}.)
24739 @infoline @expr{sigma_i_j^2 / sigma_i sigma_j}.)
24742 A vector of @expr{M} ``parameter filter'' functions whose
24743 meanings are described below. If no filters are necessary this
24744 will instead be an empty vector; this is always the case for the
24745 polynomial and multilinear fits described so far.
24749 @texline @math{\chi^2}
24750 @infoline @expr{chi^2}
24751 for the fit, calculated by the formulas shown above. This gives a
24752 measure of the quality of the fit; statisticians consider
24753 @texline @math{\chi^2 \approx N - M}
24754 @infoline @expr{chi^2 = N - M}
24755 to indicate a moderately good fit (where again @expr{N} is the number of
24756 data points and @expr{M} is the number of parameters).
24759 A measure of goodness of fit expressed as a probability @expr{Q}.
24760 This is computed from the @code{utpc} probability distribution
24762 @texline @math{\chi^2}
24763 @infoline @expr{chi^2}
24764 with @expr{N - M} degrees of freedom. A
24765 value of 0.5 implies a good fit; some texts recommend that often
24766 @expr{Q = 0.1} or even 0.001 can signify an acceptable fit. In
24768 @texline @math{\chi^2}
24769 @infoline @expr{chi^2}
24770 statistics assume the errors in your inputs
24771 follow a normal (Gaussian) distribution; if they don't, you may
24772 have to accept smaller values of @expr{Q}.
24774 The @expr{Q} value is computed only if the input included error
24775 estimates. Otherwise, Calc will report the symbol @code{nan}
24776 for @expr{Q}. The reason is that in this case the
24777 @texline @math{\chi^2}
24778 @infoline @expr{chi^2}
24779 value has effectively been used to estimate the original errors
24780 in the input, and thus there is no redundant information left
24781 over to use for a confidence test.
24784 @node Standard Nonlinear Models, Curve Fitting Details, Error Estimates for Fits, Curve Fitting
24785 @subsection Standard Nonlinear Models
24788 The @kbd{a F} command also accepts other kinds of models besides
24789 lines and polynomials. Some common models have quick single-key
24790 abbreviations; others must be entered by hand as algebraic formulas.
24792 Here is a complete list of the standard models recognized by @kbd{a F}:
24796 Linear or multilinear. @mathit{a + b x + c y + d z}.
24798 Polynomials. @mathit{a + b x + c x^2 + d x^3}.
24800 Exponential. @mathit{a} @tfn{exp}@mathit{(b x)} @tfn{exp}@mathit{(c y)}.
24802 Base-10 exponential. @mathit{a} @tfn{10^}@mathit{(b x)} @tfn{10^}@mathit{(c y)}.
24804 Exponential (alternate notation). @tfn{exp}@mathit{(a + b x + c y)}.
24806 Base-10 exponential (alternate). @tfn{10^}@mathit{(a + b x + c y)}.
24808 Logarithmic. @mathit{a + b} @tfn{ln}@mathit{(x) + c} @tfn{ln}@mathit{(y)}.
24810 Base-10 logarithmic. @mathit{a + b} @tfn{log10}@mathit{(x) + c} @tfn{log10}@mathit{(y)}.
24812 General exponential. @mathit{a b^x c^y}.
24814 Power law. @mathit{a x^b y^c}.
24816 Quadratic. @mathit{a + b (x-c)^2 + d (x-e)^2}.
24819 @texline @math{{a \over b \sqrt{2 \pi}} \exp\left( -{1 \over 2} \left( x - c \over b \right)^2 \right)}.
24820 @infoline @mathit{(a / b sqrt(2 pi)) exp(-0.5*((x-c)/b)^2)}.
24823 All of these models are used in the usual way; just press the appropriate
24824 letter at the model prompt, and choose variable names if you wish. The
24825 result will be a formula as shown in the above table, with the best-fit
24826 values of the parameters substituted. (You may find it easier to read
24827 the parameter values from the vector that is placed in the trail.)
24829 All models except Gaussian and polynomials can generalize as shown to any
24830 number of independent variables. Also, all the built-in models have an
24831 additive or multiplicative parameter shown as @expr{a} in the above table
24832 which can be replaced by zero or one, as appropriate, by typing @kbd{h}
24833 before the model key.
24835 Note that many of these models are essentially equivalent, but express
24836 the parameters slightly differently. For example, @expr{a b^x} and
24837 the other two exponential models are all algebraic rearrangements of
24838 each other. Also, the ``quadratic'' model is just a degree-2 polynomial
24839 with the parameters expressed differently. Use whichever form best
24840 matches the problem.
24842 The HP-28/48 calculators support four different models for curve
24843 fitting, called @code{LIN}, @code{LOG}, @code{EXP}, and @code{PWR}.
24844 These correspond to Calc models @samp{a + b x}, @samp{a + b ln(x)},
24845 @samp{a exp(b x)}, and @samp{a x^b}, respectively. In each case,
24846 @expr{a} is what the HP-48 identifies as the ``intercept,'' and
24847 @expr{b} is what it calls the ``slope.''
24853 If the model you want doesn't appear on this list, press @kbd{'}
24854 (the apostrophe key) at the model prompt to enter any algebraic
24855 formula, such as @kbd{m x - b}, as the model. (Not all models
24856 will work, though---see the next section for details.)
24858 The model can also be an equation like @expr{y = m x + b}.
24859 In this case, Calc thinks of all the rows of the data matrix on
24860 equal terms; this model effectively has two parameters
24861 (@expr{m} and @expr{b}) and two independent variables (@expr{x}
24862 and @expr{y}), with no ``dependent'' variables. Model equations
24863 do not need to take this @expr{y =} form. For example, the
24864 implicit line equation @expr{a x + b y = 1} works fine as a
24867 When you enter a model, Calc makes an alphabetical list of all
24868 the variables that appear in the model. These are used for the
24869 default parameters, independent variables, and dependent variable
24870 (in that order). If you enter a plain formula (not an equation),
24871 Calc assumes the dependent variable does not appear in the formula
24872 and thus does not need a name.
24874 For example, if the model formula has the variables @expr{a,mu,sigma,t,x},
24875 and the data matrix has three rows (meaning two independent variables),
24876 Calc will use @expr{a,mu,sigma} as the default parameters, and the
24877 data rows will be named @expr{t} and @expr{x}, respectively. If you
24878 enter an equation instead of a plain formula, Calc will use @expr{a,mu}
24879 as the parameters, and @expr{sigma,t,x} as the three independent
24882 You can, of course, override these choices by entering something
24883 different at the prompt. If you leave some variables out of the list,
24884 those variables must have stored values and those stored values will
24885 be used as constants in the model. (Stored values for the parameters
24886 and independent variables are ignored by the @kbd{a F} command.)
24887 If you list only independent variables, all the remaining variables
24888 in the model formula will become parameters.
24890 If there are @kbd{$} signs in the model you type, they will stand
24891 for parameters and all other variables (in alphabetical order)
24892 will be independent. Use @kbd{$} for one parameter, @kbd{$$} for
24893 another, and so on. Thus @kbd{$ x + $$} is another way to describe
24896 If you type a @kbd{$} instead of @kbd{'} at the model prompt itself,
24897 Calc will take the model formula from the stack. (The data must then
24898 appear at the second stack level.) The same conventions are used to
24899 choose which variables in the formula are independent by default and
24900 which are parameters.
24902 Models taken from the stack can also be expressed as vectors of
24903 two or three elements, @expr{[@var{model}, @var{vars}]} or
24904 @expr{[@var{model}, @var{vars}, @var{params}]}. Each of @var{vars}
24905 and @var{params} may be either a variable or a vector of variables.
24906 (If @var{params} is omitted, all variables in @var{model} except
24907 those listed as @var{vars} are parameters.)
24909 When you enter a model manually with @kbd{'}, Calc puts a 3-vector
24910 describing the model in the trail so you can get it back if you wish.
24918 Finally, you can store a model in one of the Calc variables
24919 @code{Model1} or @code{Model2}, then use this model by typing
24920 @kbd{a F u} or @kbd{a F U} (respectively). The value stored in
24921 the variable can be any of the formats that @kbd{a F $} would
24922 accept for a model on the stack.
24928 Calc uses the principal values of inverse functions like @code{ln}
24929 and @code{arcsin} when doing fits. For example, when you enter
24930 the model @samp{y = sin(a t + b)} Calc actually uses the easier
24931 form @samp{arcsin(y) = a t + b}. The @code{arcsin} function always
24932 returns results in the range from @mathit{-90} to 90 degrees (or the
24933 equivalent range in radians). Suppose you had data that you
24934 believed to represent roughly three oscillations of a sine wave,
24935 so that the argument of the sine might go from zero to
24936 @texline @math{3\times360}
24937 @infoline @mathit{3*360}
24939 The above model would appear to be a good way to determine the
24940 true frequency and phase of the sine wave, but in practice it
24941 would fail utterly. The righthand side of the actual model
24942 @samp{arcsin(y) = a t + b} will grow smoothly with @expr{t}, but
24943 the lefthand side will bounce back and forth between @mathit{-90} and 90.
24944 No values of @expr{a} and @expr{b} can make the two sides match,
24945 even approximately.
24947 There is no good solution to this problem at present. You could
24948 restrict your data to small enough ranges so that the above problem
24949 doesn't occur (i.e., not straddling any peaks in the sine wave).
24950 Or, in this case, you could use a totally different method such as
24951 Fourier analysis, which is beyond the scope of the @kbd{a F} command.
24952 (Unfortunately, Calc does not currently have any facilities for
24953 taking Fourier and related transforms.)
24955 @node Curve Fitting Details, Interpolation, Standard Nonlinear Models, Curve Fitting
24956 @subsection Curve Fitting Details
24959 Calc's internal least-squares fitter can only handle multilinear
24960 models. More precisely, it can handle any model of the form
24961 @expr{a f(x,y,z) + b g(x,y,z) + c h(x,y,z)}, where @expr{a,b,c}
24962 are the parameters and @expr{x,y,z} are the independent variables
24963 (of course there can be any number of each, not just three).
24965 In a simple multilinear or polynomial fit, it is easy to see how
24966 to convert the model into this form. For example, if the model
24967 is @expr{a + b x + c x^2}, then @expr{f(x) = 1}, @expr{g(x) = x},
24968 and @expr{h(x) = x^2} are suitable functions.
24970 For other models, Calc uses a variety of algebraic manipulations
24971 to try to put the problem into the form
24974 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)
24978 where @expr{Y,A,B,C,F,G,H} are arbitrary functions. It computes
24979 @expr{Y}, @expr{F}, @expr{G}, and @expr{H} for all the data points,
24980 does a standard linear fit to find the values of @expr{A}, @expr{B},
24981 and @expr{C}, then uses the equation solver to solve for @expr{a,b,c}
24982 in terms of @expr{A,B,C}.
24984 A remarkable number of models can be cast into this general form.
24985 We'll look at two examples here to see how it works. The power-law
24986 model @expr{y = a x^b} with two independent variables and two parameters
24987 can be rewritten as follows:
24992 y = exp(ln(a) + b ln(x))
24993 ln(y) = ln(a) + b ln(x)
24997 which matches the desired form with
24998 @texline @math{Y = \ln(y)},
24999 @infoline @expr{Y = ln(y)},
25000 @texline @math{A = \ln(a)},
25001 @infoline @expr{A = ln(a)},
25002 @expr{F = 1}, @expr{B = b}, and
25003 @texline @math{G = \ln(x)}.
25004 @infoline @expr{G = ln(x)}.
25005 Calc thus computes the logarithms of your @expr{y} and @expr{x} values,
25006 does a linear fit for @expr{A} and @expr{B}, then solves to get
25007 @texline @math{a = \exp(A)}
25008 @infoline @expr{a = exp(A)}
25011 Another interesting example is the ``quadratic'' model, which can
25012 be handled by expanding according to the distributive law.
25015 y = a + b*(x - c)^2
25016 y = a + b c^2 - 2 b c x + b x^2
25020 which matches with @expr{Y = y}, @expr{A = a + b c^2}, @expr{F = 1},
25021 @expr{B = -2 b c}, @expr{G = x} (the @mathit{-2} factor could just as easily
25022 have been put into @expr{G} instead of @expr{B}), @expr{C = b}, and
25025 The Gaussian model looks quite complicated, but a closer examination
25026 shows that it's actually similar to the quadratic model but with an
25027 exponential that can be brought to the top and moved into @expr{Y}.
25029 An example of a model that cannot be put into general linear
25030 form is a Gaussian with a constant background added on, i.e.,
25031 @expr{d} + the regular Gaussian formula. If you have a model like
25032 this, your best bet is to replace enough of your parameters with
25033 constants to make the model linearizable, then adjust the constants
25034 manually by doing a series of fits. You can compare the fits by
25035 graphing them, by examining the goodness-of-fit measures returned by
25036 @kbd{I a F}, or by some other method suitable to your application.
25037 Note that some models can be linearized in several ways. The
25038 Gaussian-plus-@var{d} model can be linearized by setting @expr{d}
25039 (the background) to a constant, or by setting @expr{b} (the standard
25040 deviation) and @expr{c} (the mean) to constants.
25042 To fit a model with constants substituted for some parameters, just
25043 store suitable values in those parameter variables, then omit them
25044 from the list of parameters when you answer the variables prompt.
25050 A last desperate step would be to use the general-purpose
25051 @code{minimize} function rather than @code{fit}. After all, both
25052 functions solve the problem of minimizing an expression (the
25053 @texline @math{\chi^2}
25054 @infoline @expr{chi^2}
25055 sum) by adjusting certain parameters in the expression. The @kbd{a F}
25056 command is able to use a vastly more efficient algorithm due to its
25057 special knowledge about linear chi-square sums, but the @kbd{a N}
25058 command can do the same thing by brute force.
25060 A compromise would be to pick out a few parameters without which the
25061 fit is linearizable, and use @code{minimize} on a call to @code{fit}
25062 which efficiently takes care of the rest of the parameters. The thing
25063 to be minimized would be the value of
25064 @texline @math{\chi^2}
25065 @infoline @expr{chi^2}
25066 returned as the fifth result of the @code{xfit} function:
25069 minimize(xfit(gaus(a,b,c,d,x), x, [a,b,c], data)_5, d, guess)
25073 where @code{gaus} represents the Gaussian model with background,
25074 @code{data} represents the data matrix, and @code{guess} represents
25075 the initial guess for @expr{d} that @code{minimize} requires.
25076 This operation will only be, shall we say, extraordinarily slow
25077 rather than astronomically slow (as would be the case if @code{minimize}
25078 were used by itself to solve the problem).
25084 The @kbd{I a F} [@code{xfit}] command is somewhat trickier when
25085 nonlinear models are used. The second item in the result is the
25086 vector of ``raw'' parameters @expr{A}, @expr{B}, @expr{C}. The
25087 covariance matrix is written in terms of those raw parameters.
25088 The fifth item is a vector of @dfn{filter} expressions. This
25089 is the empty vector @samp{[]} if the raw parameters were the same
25090 as the requested parameters, i.e., if @expr{A = a}, @expr{B = b},
25091 and so on (which is always true if the model is already linear
25092 in the parameters as written, e.g., for polynomial fits). If the
25093 parameters had to be rearranged, the fifth item is instead a vector
25094 of one formula per parameter in the original model. The raw
25095 parameters are expressed in these ``filter'' formulas as
25096 @samp{fitdummy(1)} for @expr{A}, @samp{fitdummy(2)} for @expr{B},
25099 When Calc needs to modify the model to return the result, it replaces
25100 @samp{fitdummy(1)} in all the filters with the first item in the raw
25101 parameters list, and so on for the other raw parameters, then
25102 evaluates the resulting filter formulas to get the actual parameter
25103 values to be substituted into the original model. In the case of
25104 @kbd{H a F} and @kbd{I a F} where the parameters must be error forms,
25105 Calc uses the square roots of the diagonal entries of the covariance
25106 matrix as error values for the raw parameters, then lets Calc's
25107 standard error-form arithmetic take it from there.
25109 If you use @kbd{I a F} with a nonlinear model, be sure to remember
25110 that the covariance matrix is in terms of the raw parameters,
25111 @emph{not} the actual requested parameters. It's up to you to
25112 figure out how to interpret the covariances in the presence of
25113 nontrivial filter functions.
25115 Things are also complicated when the input contains error forms.
25116 Suppose there are three independent and dependent variables, @expr{x},
25117 @expr{y}, and @expr{z}, one or more of which are error forms in the
25118 data. Calc combines all the error values by taking the square root
25119 of the sum of the squares of the errors. It then changes @expr{x}
25120 and @expr{y} to be plain numbers, and makes @expr{z} into an error
25121 form with this combined error. The @expr{Y(x,y,z)} part of the
25122 linearized model is evaluated, and the result should be an error
25123 form. The error part of that result is used for
25124 @texline @math{\sigma_i}
25125 @infoline @expr{sigma_i}
25126 for the data point. If for some reason @expr{Y(x,y,z)} does not return
25127 an error form, the combined error from @expr{z} is used directly for
25128 @texline @math{\sigma_i}.
25129 @infoline @expr{sigma_i}.
25130 Finally, @expr{z} is also stripped of its error
25131 for use in computing @expr{F(x,y,z)}, @expr{G(x,y,z)} and so on;
25132 the righthand side of the linearized model is computed in regular
25133 arithmetic with no error forms.
25135 (While these rules may seem complicated, they are designed to do
25136 the most reasonable thing in the typical case that @expr{Y(x,y,z)}
25137 depends only on the dependent variable @expr{z}, and in fact is
25138 often simply equal to @expr{z}. For common cases like polynomials
25139 and multilinear models, the combined error is simply used as the
25140 @texline @math{\sigma}
25141 @infoline @expr{sigma}
25142 for the data point with no further ado.)
25149 It may be the case that the model you wish to use is linearizable,
25150 but Calc's built-in rules are unable to figure it out. Calc uses
25151 its algebraic rewrite mechanism to linearize a model. The rewrite
25152 rules are kept in the variable @code{FitRules}. You can edit this
25153 variable using the @kbd{s e FitRules} command; in fact, there is
25154 a special @kbd{s F} command just for editing @code{FitRules}.
25155 @xref{Operations on Variables}.
25157 @xref{Rewrite Rules}, for a discussion of rewrite rules.
25191 Calc uses @code{FitRules} as follows. First, it converts the model
25192 to an equation if necessary and encloses the model equation in a
25193 call to the function @code{fitmodel} (which is not actually a defined
25194 function in Calc; it is only used as a placeholder by the rewrite rules).
25195 Parameter variables are renamed to function calls @samp{fitparam(1)},
25196 @samp{fitparam(2)}, and so on, and independent variables are renamed
25197 to @samp{fitvar(1)}, @samp{fitvar(2)}, etc. The dependent variable
25198 is the highest-numbered @code{fitvar}. For example, the power law
25199 model @expr{a x^b} is converted to @expr{y = a x^b}, then to
25203 fitmodel(fitvar(2) = fitparam(1) fitvar(1)^fitparam(2))
25207 Calc then applies the rewrites as if by @samp{C-u 0 a r FitRules}.
25208 (The zero prefix means that rewriting should continue until no further
25209 changes are possible.)
25211 When rewriting is complete, the @code{fitmodel} call should have
25212 been replaced by a @code{fitsystem} call that looks like this:
25215 fitsystem(@var{Y}, @var{FGH}, @var{abc})
25219 where @var{Y} is a formula that describes the function @expr{Y(x,y,z)},
25220 @var{FGH} is the vector of formulas @expr{[F(x,y,z), G(x,y,z), H(x,y,z)]},
25221 and @var{abc} is the vector of parameter filters which refer to the
25222 raw parameters as @samp{fitdummy(1)} for @expr{A}, @samp{fitdummy(2)}
25223 for @expr{B}, etc. While the number of raw parameters (the length of
25224 the @var{FGH} vector) is usually the same as the number of original
25225 parameters (the length of the @var{abc} vector), this is not required.
25227 The power law model eventually boils down to
25231 fitsystem(ln(fitvar(2)),
25232 [1, ln(fitvar(1))],
25233 [exp(fitdummy(1)), fitdummy(2)])
25237 The actual implementation of @code{FitRules} is complicated; it
25238 proceeds in four phases. First, common rearrangements are done
25239 to try to bring linear terms together and to isolate functions like
25240 @code{exp} and @code{ln} either all the way ``out'' (so that they
25241 can be put into @var{Y}) or all the way ``in'' (so that they can
25242 be put into @var{abc} or @var{FGH}). In particular, all
25243 non-constant powers are converted to logs-and-exponentials form,
25244 and the distributive law is used to expand products of sums.
25245 Quotients are rewritten to use the @samp{fitinv} function, where
25246 @samp{fitinv(x)} represents @expr{1/x} while the @code{FitRules}
25247 are operating. (The use of @code{fitinv} makes recognition of
25248 linear-looking forms easier.) If you modify @code{FitRules}, you
25249 will probably only need to modify the rules for this phase.
25251 Phase two, whose rules can actually also apply during phases one
25252 and three, first rewrites @code{fitmodel} to a two-argument
25253 form @samp{fitmodel(@var{Y}, @var{model})}, where @var{Y} is
25254 initially zero and @var{model} has been changed from @expr{a=b}
25255 to @expr{a-b} form. It then tries to peel off invertible functions
25256 from the outside of @var{model} and put them into @var{Y} instead,
25257 calling the equation solver to invert the functions. Finally, when
25258 this is no longer possible, the @code{fitmodel} is changed to a
25259 four-argument @code{fitsystem}, where the fourth argument is
25260 @var{model} and the @var{FGH} and @var{abc} vectors are initially
25261 empty. (The last vector is really @var{ABC}, corresponding to
25262 raw parameters, for now.)
25264 Phase three converts a sum of items in the @var{model} to a sum
25265 of @samp{fitpart(@var{a}, @var{b}, @var{c})} terms which represent
25266 terms @samp{@var{a}*@var{b}*@var{c}} of the sum, where @var{a}
25267 is all factors that do not involve any variables, @var{b} is all
25268 factors that involve only parameters, and @var{c} is the factors
25269 that involve only independent variables. (If this decomposition
25270 is not possible, the rule set will not complete and Calc will
25271 complain that the model is too complex.) Then @code{fitpart}s
25272 with equal @var{b} or @var{c} components are merged back together
25273 using the distributive law in order to minimize the number of
25274 raw parameters needed.
25276 Phase four moves the @code{fitpart} terms into the @var{FGH} and
25277 @var{ABC} vectors. Also, some of the algebraic expansions that
25278 were done in phase 1 are undone now to make the formulas more
25279 computationally efficient. Finally, it calls the solver one more
25280 time to convert the @var{ABC} vector to an @var{abc} vector, and
25281 removes the fourth @var{model} argument (which by now will be zero)
25282 to obtain the three-argument @code{fitsystem} that the linear
25283 least-squares solver wants to see.
25289 @mindex hasfit@idots
25291 @tindex hasfitparams
25299 Two functions which are useful in connection with @code{FitRules}
25300 are @samp{hasfitparams(x)} and @samp{hasfitvars(x)}, which check
25301 whether @expr{x} refers to any parameters or independent variables,
25302 respectively. Specifically, these functions return ``true'' if the
25303 argument contains any @code{fitparam} (or @code{fitvar}) function
25304 calls, and ``false'' otherwise. (Recall that ``true'' means a
25305 nonzero number, and ``false'' means zero. The actual nonzero number
25306 returned is the largest @var{n} from all the @samp{fitparam(@var{n})}s
25307 or @samp{fitvar(@var{n})}s, respectively, that appear in the formula.)
25313 The @code{fit} function in algebraic notation normally takes four
25314 arguments, @samp{fit(@var{model}, @var{vars}, @var{params}, @var{data})},
25315 where @var{model} is the model formula as it would be typed after
25316 @kbd{a F '}, @var{vars} is the independent variable or a vector of
25317 independent variables, @var{params} likewise gives the parameter(s),
25318 and @var{data} is the data matrix. Note that the length of @var{vars}
25319 must be equal to the number of rows in @var{data} if @var{model} is
25320 an equation, or one less than the number of rows if @var{model} is
25321 a plain formula. (Actually, a name for the dependent variable is
25322 allowed but will be ignored in the plain-formula case.)
25324 If @var{params} is omitted, the parameters are all variables in
25325 @var{model} except those that appear in @var{vars}. If @var{vars}
25326 is also omitted, Calc sorts all the variables that appear in
25327 @var{model} alphabetically and uses the higher ones for @var{vars}
25328 and the lower ones for @var{params}.
25330 Alternatively, @samp{fit(@var{modelvec}, @var{data})} is allowed
25331 where @var{modelvec} is a 2- or 3-vector describing the model
25332 and variables, as discussed previously.
25334 If Calc is unable to do the fit, the @code{fit} function is left
25335 in symbolic form, ordinarily with an explanatory message. The
25336 message will be ``Model expression is too complex'' if the
25337 linearizer was unable to put the model into the required form.
25339 The @code{efit} (corresponding to @kbd{H a F}) and @code{xfit}
25340 (for @kbd{I a F}) functions are completely analogous.
25342 @node Interpolation, , Curve Fitting Details, Curve Fitting
25343 @subsection Polynomial Interpolation
25346 @pindex calc-poly-interp
25348 The @kbd{a p} (@code{calc-poly-interp}) [@code{polint}] command does
25349 a polynomial interpolation at a particular @expr{x} value. It takes
25350 two arguments from the stack: A data matrix of the sort used by
25351 @kbd{a F}, and a single number which represents the desired @expr{x}
25352 value. Calc effectively does an exact polynomial fit as if by @kbd{a F i},
25353 then substitutes the @expr{x} value into the result in order to get an
25354 approximate @expr{y} value based on the fit. (Calc does not actually
25355 use @kbd{a F i}, however; it uses a direct method which is both more
25356 efficient and more numerically stable.)
25358 The result of @kbd{a p} is actually a vector of two values: The @expr{y}
25359 value approximation, and an error measure @expr{dy} that reflects Calc's
25360 estimation of the probable error of the approximation at that value of
25361 @expr{x}. If the input @expr{x} is equal to any of the @expr{x} values
25362 in the data matrix, the output @expr{y} will be the corresponding @expr{y}
25363 value from the matrix, and the output @expr{dy} will be exactly zero.
25365 A prefix argument of 2 causes @kbd{a p} to take separate x- and
25366 y-vectors from the stack instead of one data matrix.
25368 If @expr{x} is a vector of numbers, @kbd{a p} will return a matrix of
25369 interpolated results for each of those @expr{x} values. (The matrix will
25370 have two columns, the @expr{y} values and the @expr{dy} values.)
25371 If @expr{x} is a formula instead of a number, the @code{polint} function
25372 remains in symbolic form; use the @kbd{a "} command to expand it out to
25373 a formula that describes the fit in symbolic terms.
25375 In all cases, the @kbd{a p} command leaves the data vectors or matrix
25376 on the stack. Only the @expr{x} value is replaced by the result.
25380 The @kbd{H a p} [@code{ratint}] command does a rational function
25381 interpolation. It is used exactly like @kbd{a p}, except that it
25382 uses as its model the quotient of two polynomials. If there are
25383 @expr{N} data points, the numerator and denominator polynomials will
25384 each have degree @expr{N/2} (if @expr{N} is odd, the denominator will
25385 have degree one higher than the numerator).
25387 Rational approximations have the advantage that they can accurately
25388 describe functions that have poles (points at which the function's value
25389 goes to infinity, so that the denominator polynomial of the approximation
25390 goes to zero). If @expr{x} corresponds to a pole of the fitted rational
25391 function, then the result will be a division by zero. If Infinite mode
25392 is enabled, the result will be @samp{[uinf, uinf]}.
25394 There is no way to get the actual coefficients of the rational function
25395 used by @kbd{H a p}. (The algorithm never generates these coefficients
25396 explicitly, and quotients of polynomials are beyond @w{@kbd{a F}}'s
25397 capabilities to fit.)
25399 @node Summations, Logical Operations, Curve Fitting, Algebra
25400 @section Summations
25403 @cindex Summation of a series
25405 @pindex calc-summation
25407 The @kbd{a +} (@code{calc-summation}) [@code{sum}] command computes
25408 the sum of a formula over a certain range of index values. The formula
25409 is taken from the top of the stack; the command prompts for the
25410 name of the summation index variable, the lower limit of the
25411 sum (any formula), and the upper limit of the sum. If you
25412 enter a blank line at any of these prompts, that prompt and
25413 any later ones are answered by reading additional elements from
25414 the stack. Thus, @kbd{' k^2 @key{RET} ' k @key{RET} 1 @key{RET} 5 @key{RET} a + @key{RET}}
25415 produces the result 55.
25418 $$ \sum_{k=1}^5 k^2 = 55 $$
25421 The choice of index variable is arbitrary, but it's best not to
25422 use a variable with a stored value. In particular, while
25423 @code{i} is often a favorite index variable, it should be avoided
25424 in Calc because @code{i} has the imaginary constant @expr{(0, 1)}
25425 as a value. If you pressed @kbd{=} on a sum over @code{i}, it would
25426 be changed to a nonsensical sum over the ``variable'' @expr{(0, 1)}!
25427 If you really want to use @code{i} as an index variable, use
25428 @w{@kbd{s u i @key{RET}}} first to ``unstore'' this variable.
25429 (@xref{Storing Variables}.)
25431 A numeric prefix argument steps the index by that amount rather
25432 than by one. Thus @kbd{' a_k @key{RET} C-u -2 a + k @key{RET} 10 @key{RET} 0 @key{RET}}
25433 yields @samp{a_10 + a_8 + a_6 + a_4 + a_2 + a_0}. A prefix
25434 argument of plain @kbd{C-u} causes @kbd{a +} to prompt for the
25435 step value, in which case you can enter any formula or enter
25436 a blank line to take the step value from the stack. With the
25437 @kbd{C-u} prefix, @kbd{a +} can take up to five arguments from
25438 the stack: The formula, the variable, the lower limit, the
25439 upper limit, and (at the top of the stack), the step value.
25441 Calc knows how to do certain sums in closed form. For example,
25442 @samp{sum(6 k^2, k, 1, n) = @w{2 n^3} + 3 n^2 + n}. In particular,
25443 this is possible if the formula being summed is polynomial or
25444 exponential in the index variable. Sums of logarithms are
25445 transformed into logarithms of products. Sums of trigonometric
25446 and hyperbolic functions are transformed to sums of exponentials
25447 and then done in closed form. Also, of course, sums in which the
25448 lower and upper limits are both numbers can always be evaluated
25449 just by grinding them out, although Calc will use closed forms
25450 whenever it can for the sake of efficiency.
25452 The notation for sums in algebraic formulas is
25453 @samp{sum(@var{expr}, @var{var}, @var{low}, @var{high}, @var{step})}.
25454 If @var{step} is omitted, it defaults to one. If @var{high} is
25455 omitted, @var{low} is actually the upper limit and the lower limit
25456 is one. If @var{low} is also omitted, the limits are @samp{-inf}
25457 and @samp{inf}, respectively.
25459 Infinite sums can sometimes be evaluated: @samp{sum(.5^k, k, 1, inf)}
25460 returns @expr{1}. This is done by evaluating the sum in closed
25461 form (to @samp{1. - 0.5^n} in this case), then evaluating this
25462 formula with @code{n} set to @code{inf}. Calc's usual rules
25463 for ``infinite'' arithmetic can find the answer from there. If
25464 infinite arithmetic yields a @samp{nan}, or if the sum cannot be
25465 solved in closed form, Calc leaves the @code{sum} function in
25466 symbolic form. @xref{Infinities}.
25468 As a special feature, if the limits are infinite (or omitted, as
25469 described above) but the formula includes vectors subscripted by
25470 expressions that involve the iteration variable, Calc narrows
25471 the limits to include only the range of integers which result in
25472 valid subscripts for the vector. For example, the sum
25473 @samp{sum(k [a,b,c,d,e,f,g]_(2k),k)} evaluates to @samp{b + 2 d + 3 f}.
25475 The limits of a sum do not need to be integers. For example,
25476 @samp{sum(a_k, k, 0, 2 n, n)} produces @samp{a_0 + a_n + a_(2 n)}.
25477 Calc computes the number of iterations using the formula
25478 @samp{1 + (@var{high} - @var{low}) / @var{step}}, which must,
25479 after simplification as if by @kbd{a s}, evaluate to an integer.
25481 If the number of iterations according to the above formula does
25482 not come out to an integer, the sum is invalid and will be left
25483 in symbolic form. However, closed forms are still supplied, and
25484 you are on your honor not to misuse the resulting formulas by
25485 substituting mismatched bounds into them. For example,
25486 @samp{sum(k, k, 1, 10, 2)} is invalid, but Calc will go ahead and
25487 evaluate the closed form solution for the limits 1 and 10 to get
25488 the rather dubious answer, 29.25.
25490 If the lower limit is greater than the upper limit (assuming a
25491 positive step size), the result is generally zero. However,
25492 Calc only guarantees a zero result when the upper limit is
25493 exactly one step less than the lower limit, i.e., if the number
25494 of iterations is @mathit{-1}. Thus @samp{sum(f(k), k, n, n-1)} is zero
25495 but the sum from @samp{n} to @samp{n-2} may report a nonzero value
25496 if Calc used a closed form solution.
25498 Calc's logical predicates like @expr{a < b} return 1 for ``true''
25499 and 0 for ``false.'' @xref{Logical Operations}. This can be
25500 used to advantage for building conditional sums. For example,
25501 @samp{sum(prime(k)*k^2, k, 1, 20)} is the sum of the squares of all
25502 prime numbers from 1 to 20; the @code{prime} predicate returns 1 if
25503 its argument is prime and 0 otherwise. You can read this expression
25504 as ``the sum of @expr{k^2}, where @expr{k} is prime.'' Indeed,
25505 @samp{sum(prime(k)*k^2, k)} would represent the sum of @emph{all} primes
25506 squared, since the limits default to plus and minus infinity, but
25507 there are no such sums that Calc's built-in rules can do in
25510 As another example, @samp{sum((k != k_0) * f(k), k, 1, n)} is the
25511 sum of @expr{f(k)} for all @expr{k} from 1 to @expr{n}, excluding
25512 one value @expr{k_0}. Slightly more tricky is the summand
25513 @samp{(k != k_0) / (k - k_0)}, which is an attempt to describe
25514 the sum of all @expr{1/(k-k_0)} except at @expr{k = k_0}, where
25515 this would be a division by zero. But at @expr{k = k_0}, this
25516 formula works out to the indeterminate form @expr{0 / 0}, which
25517 Calc will not assume is zero. Better would be to use
25518 @samp{(k != k_0) ? 1/(k-k_0) : 0}; the @samp{? :} operator does
25519 an ``if-then-else'' test: This expression says, ``if
25520 @texline @math{k \ne k_0},
25521 @infoline @expr{k != k_0},
25522 then @expr{1/(k-k_0)}, else zero.'' Now the formula @expr{1/(k-k_0)}
25523 will not even be evaluated by Calc when @expr{k = k_0}.
25525 @cindex Alternating sums
25527 @pindex calc-alt-summation
25529 The @kbd{a -} (@code{calc-alt-summation}) [@code{asum}] command
25530 computes an alternating sum. Successive terms of the sequence
25531 are given alternating signs, with the first term (corresponding
25532 to the lower index value) being positive. Alternating sums
25533 are converted to normal sums with an extra term of the form
25534 @samp{(-1)^(k-@var{low})}. This formula is adjusted appropriately
25535 if the step value is other than one. For example, the Taylor
25536 series for the sine function is @samp{asum(x^k / k!, k, 1, inf, 2)}.
25537 (Calc cannot evaluate this infinite series, but it can approximate
25538 it if you replace @code{inf} with any particular odd number.)
25539 Calc converts this series to a regular sum with a step of one,
25540 namely @samp{sum((-1)^k x^(2k+1) / (2k+1)!, k, 0, inf)}.
25542 @cindex Product of a sequence
25544 @pindex calc-product
25546 The @kbd{a *} (@code{calc-product}) [@code{prod}] command is
25547 the analogous way to take a product of many terms. Calc also knows
25548 some closed forms for products, such as @samp{prod(k, k, 1, n) = n!}.
25549 Conditional products can be written @samp{prod(k^prime(k), k, 1, n)}
25550 or @samp{prod(prime(k) ? k : 1, k, 1, n)}.
25553 @pindex calc-tabulate
25555 The @kbd{a T} (@code{calc-tabulate}) [@code{table}] command
25556 evaluates a formula at a series of iterated index values, just
25557 like @code{sum} and @code{prod}, but its result is simply a
25558 vector of the results. For example, @samp{table(a_i, i, 1, 7, 2)}
25559 produces @samp{[a_1, a_3, a_5, a_7]}.
25561 @node Logical Operations, Rewrite Rules, Summations, Algebra
25562 @section Logical Operations
25565 The following commands and algebraic functions return true/false values,
25566 where 1 represents ``true'' and 0 represents ``false.'' In cases where
25567 a truth value is required (such as for the condition part of a rewrite
25568 rule, or as the condition for a @w{@kbd{Z [ Z ]}} control structure), any
25569 nonzero value is accepted to mean ``true.'' (Specifically, anything
25570 for which @code{dnonzero} returns 1 is ``true,'' and anything for
25571 which @code{dnonzero} returns 0 or cannot decide is assumed ``false.''
25572 Note that this means that @w{@kbd{Z [ Z ]}} will execute the ``then''
25573 portion if its condition is provably true, but it will execute the
25574 ``else'' portion for any condition like @expr{a = b} that is not
25575 provably true, even if it might be true. Algebraic functions that
25576 have conditions as arguments, like @code{? :} and @code{&&}, remain
25577 unevaluated if the condition is neither provably true nor provably
25578 false. @xref{Declarations}.)
25581 @pindex calc-equal-to
25585 The @kbd{a =} (@code{calc-equal-to}) command, or @samp{eq(a,b)} function
25586 (which can also be written @samp{a = b} or @samp{a == b} in an algebraic
25587 formula) is true if @expr{a} and @expr{b} are equal, either because they
25588 are identical expressions, or because they are numbers which are
25589 numerically equal. (Thus the integer 1 is considered equal to the float
25590 1.0.) If the equality of @expr{a} and @expr{b} cannot be determined,
25591 the comparison is left in symbolic form. Note that as a command, this
25592 operation pops two values from the stack and pushes back either a 1 or
25593 a 0, or a formula @samp{a = b} if the values' equality cannot be determined.
25595 Many Calc commands use @samp{=} formulas to represent @dfn{equations}.
25596 For example, the @kbd{a S} (@code{calc-solve-for}) command rearranges
25597 an equation to solve for a given variable. The @kbd{a M}
25598 (@code{calc-map-equation}) command can be used to apply any
25599 function to both sides of an equation; for example, @kbd{2 a M *}
25600 multiplies both sides of the equation by two. Note that just
25601 @kbd{2 *} would not do the same thing; it would produce the formula
25602 @samp{2 (a = b)} which represents 2 if the equality is true or
25605 The @code{eq} function with more than two arguments (e.g., @kbd{C-u 3 a =}
25606 or @samp{a = b = c}) tests if all of its arguments are equal. In
25607 algebraic notation, the @samp{=} operator is unusual in that it is
25608 neither left- nor right-associative: @samp{a = b = c} is not the
25609 same as @samp{(a = b) = c} or @samp{a = (b = c)} (which each compare
25610 one variable with the 1 or 0 that results from comparing two other
25614 @pindex calc-not-equal-to
25617 The @kbd{a #} (@code{calc-not-equal-to}) command, or @samp{neq(a,b)} or
25618 @samp{a != b} function, is true if @expr{a} and @expr{b} are not equal.
25619 This also works with more than two arguments; @samp{a != b != c != d}
25620 tests that all four of @expr{a}, @expr{b}, @expr{c}, and @expr{d} are
25637 @pindex calc-less-than
25638 @pindex calc-greater-than
25639 @pindex calc-less-equal
25640 @pindex calc-greater-equal
25669 The @kbd{a <} (@code{calc-less-than}) [@samp{lt(a,b)} or @samp{a < b}]
25670 operation is true if @expr{a} is less than @expr{b}. Similar functions
25671 are @kbd{a >} (@code{calc-greater-than}) [@samp{gt(a,b)} or @samp{a > b}],
25672 @kbd{a [} (@code{calc-less-equal}) [@samp{leq(a,b)} or @samp{a <= b}], and
25673 @kbd{a ]} (@code{calc-greater-equal}) [@samp{geq(a,b)} or @samp{a >= b}].
25675 While the inequality functions like @code{lt} do not accept more
25676 than two arguments, the syntax @w{@samp{a <= b < c}} is translated to an
25677 equivalent expression involving intervals: @samp{b in [a .. c)}.
25678 (See the description of @code{in} below.) All four combinations
25679 of @samp{<} and @samp{<=} are allowed, or any of the four combinations
25680 of @samp{>} and @samp{>=}. Four-argument constructions like
25681 @samp{a < b < c < d}, and mixtures like @w{@samp{a < b = c}} that
25682 involve both equalities and inequalities, are not allowed.
25685 @pindex calc-remove-equal
25687 The @kbd{a .} (@code{calc-remove-equal}) [@code{rmeq}] command extracts
25688 the righthand side of the equation or inequality on the top of the
25689 stack. It also works elementwise on vectors. For example, if
25690 @samp{[x = 2.34, y = z / 2]} is on the stack, then @kbd{a .} produces
25691 @samp{[2.34, z / 2]}. As a special case, if the righthand side is a
25692 variable and the lefthand side is a number (as in @samp{2.34 = x}), then
25693 Calc keeps the lefthand side instead. Finally, this command works with
25694 assignments @samp{x := 2.34} as well as equations, always taking the
25695 righthand side, and for @samp{=>} (evaluates-to) operators, always
25696 taking the lefthand side.
25699 @pindex calc-logical-and
25702 The @kbd{a &} (@code{calc-logical-and}) [@samp{land(a,b)} or @samp{a && b}]
25703 function is true if both of its arguments are true, i.e., are
25704 non-zero numbers. In this case, the result will be either @expr{a} or
25705 @expr{b}, chosen arbitrarily. If either argument is zero, the result is
25706 zero. Otherwise, the formula is left in symbolic form.
25709 @pindex calc-logical-or
25712 The @kbd{a |} (@code{calc-logical-or}) [@samp{lor(a,b)} or @samp{a || b}]
25713 function is true if either or both of its arguments are true (nonzero).
25714 The result is whichever argument was nonzero, choosing arbitrarily if both
25715 are nonzero. If both @expr{a} and @expr{b} are zero, the result is
25719 @pindex calc-logical-not
25722 The @kbd{a !} (@code{calc-logical-not}) [@samp{lnot(a)} or @samp{!@: a}]
25723 function is true if @expr{a} is false (zero), or false if @expr{a} is
25724 true (nonzero). It is left in symbolic form if @expr{a} is not a
25728 @pindex calc-logical-if
25738 @cindex Arguments, not evaluated
25739 The @kbd{a :} (@code{calc-logical-if}) [@samp{if(a,b,c)} or @samp{a ? b :@: c}]
25740 function is equal to either @expr{b} or @expr{c} if @expr{a} is a nonzero
25741 number or zero, respectively. If @expr{a} is not a number, the test is
25742 left in symbolic form and neither @expr{b} nor @expr{c} is evaluated in
25743 any way. In algebraic formulas, this is one of the few Calc functions
25744 whose arguments are not automatically evaluated when the function itself
25745 is evaluated. The others are @code{lambda}, @code{quote}, and
25748 One minor surprise to watch out for is that the formula @samp{a?3:4}
25749 will not work because the @samp{3:4} is parsed as a fraction instead of
25750 as three separate symbols. Type something like @samp{a ? 3 : 4} or
25751 @samp{a?(3):4} instead.
25753 As a special case, if @expr{a} evaluates to a vector, then both @expr{b}
25754 and @expr{c} are evaluated; the result is a vector of the same length
25755 as @expr{a} whose elements are chosen from corresponding elements of
25756 @expr{b} and @expr{c} according to whether each element of @expr{a}
25757 is zero or nonzero. Each of @expr{b} and @expr{c} must be either a
25758 vector of the same length as @expr{a}, or a non-vector which is matched
25759 with all elements of @expr{a}.
25762 @pindex calc-in-set
25764 The @kbd{a @{} (@code{calc-in-set}) [@samp{in(a,b)}] function is true if
25765 the number @expr{a} is in the set of numbers represented by @expr{b}.
25766 If @expr{b} is an interval form, @expr{a} must be one of the values
25767 encompassed by the interval. If @expr{b} is a vector, @expr{a} must be
25768 equal to one of the elements of the vector. (If any vector elements are
25769 intervals, @expr{a} must be in any of the intervals.) If @expr{b} is a
25770 plain number, @expr{a} must be numerically equal to @expr{b}.
25771 @xref{Set Operations}, for a group of commands that manipulate sets
25778 The @samp{typeof(a)} function produces an integer or variable which
25779 characterizes @expr{a}. If @expr{a} is a number, vector, or variable,
25780 the result will be one of the following numbers:
25785 3 Floating-point number
25787 5 Rectangular complex number
25788 6 Polar complex number
25794 12 Infinity (inf, uinf, or nan)
25796 101 Vector (but not a matrix)
25800 Otherwise, @expr{a} is a formula, and the result is a variable which
25801 represents the name of the top-level function call.
25815 The @samp{integer(a)} function returns true if @expr{a} is an integer.
25816 The @samp{real(a)} function
25817 is true if @expr{a} is a real number, either integer, fraction, or
25818 float. The @samp{constant(a)} function returns true if @expr{a} is
25819 any of the objects for which @code{typeof} would produce an integer
25820 code result except for variables, and provided that the components of
25821 an object like a vector or error form are themselves constant.
25822 Note that infinities do not satisfy any of these tests, nor do
25823 special constants like @code{pi} and @code{e}.
25825 @xref{Declarations}, for a set of similar functions that recognize
25826 formulas as well as actual numbers. For example, @samp{dint(floor(x))}
25827 is true because @samp{floor(x)} is provably integer-valued, but
25828 @samp{integer(floor(x))} does not because @samp{floor(x)} is not
25829 literally an integer constant.
25835 The @samp{refers(a,b)} function is true if the variable (or sub-expression)
25836 @expr{b} appears in @expr{a}, or false otherwise. Unlike the other
25837 tests described here, this function returns a definite ``no'' answer
25838 even if its arguments are still in symbolic form. The only case where
25839 @code{refers} will be left unevaluated is if @expr{a} is a plain
25840 variable (different from @expr{b}).
25846 The @samp{negative(a)} function returns true if @expr{a} ``looks'' negative,
25847 because it is a negative number, because it is of the form @expr{-x},
25848 or because it is a product or quotient with a term that looks negative.
25849 This is most useful in rewrite rules. Beware that @samp{negative(a)}
25850 evaluates to 1 or 0 for @emph{any} argument @expr{a}, so it can only
25851 be stored in a formula if the default simplifications are turned off
25852 first with @kbd{m O} (or if it appears in an unevaluated context such
25853 as a rewrite rule condition).
25859 The @samp{variable(a)} function is true if @expr{a} is a variable,
25860 or false if not. If @expr{a} is a function call, this test is left
25861 in symbolic form. Built-in variables like @code{pi} and @code{inf}
25862 are considered variables like any others by this test.
25868 The @samp{nonvar(a)} function is true if @expr{a} is a non-variable.
25869 If its argument is a variable it is left unsimplified; it never
25870 actually returns zero. However, since Calc's condition-testing
25871 commands consider ``false'' anything not provably true, this is
25890 @cindex Linearity testing
25891 The functions @code{lin}, @code{linnt}, @code{islin}, and @code{islinnt}
25892 check if an expression is ``linear,'' i.e., can be written in the form
25893 @expr{a + b x} for some constants @expr{a} and @expr{b}, and some
25894 variable or subformula @expr{x}. The function @samp{islin(f,x)} checks
25895 if formula @expr{f} is linear in @expr{x}, returning 1 if so. For
25896 example, @samp{islin(x,x)}, @samp{islin(-x,x)}, @samp{islin(3,x)}, and
25897 @samp{islin(x y / 3 - 2, x)} all return 1. The @samp{lin(f,x)} function
25898 is similar, except that instead of returning 1 it returns the vector
25899 @expr{[a, b, x]}. For the above examples, this vector would be
25900 @expr{[0, 1, x]}, @expr{[0, -1, x]}, @expr{[3, 0, x]}, and
25901 @expr{[-2, y/3, x]}, respectively. Both @code{lin} and @code{islin}
25902 generally remain unevaluated for expressions which are not linear,
25903 e.g., @samp{lin(2 x^2, x)} and @samp{lin(sin(x), x)}. The second
25904 argument can also be a formula; @samp{islin(2 + 3 sin(x), sin(x))}
25907 The @code{linnt} and @code{islinnt} functions perform a similar check,
25908 but require a ``non-trivial'' linear form, which means that the
25909 @expr{b} coefficient must be non-zero. For example, @samp{lin(2,x)}
25910 returns @expr{[2, 0, x]} and @samp{lin(y,x)} returns @expr{[y, 0, x]},
25911 but @samp{linnt(2,x)} and @samp{linnt(y,x)} are left unevaluated
25912 (in other words, these formulas are considered to be only ``trivially''
25913 linear in @expr{x}).
25915 All four linearity-testing functions allow you to omit the second
25916 argument, in which case the input may be linear in any non-constant
25917 formula. Here, the @expr{a=0}, @expr{b=1} case is also considered
25918 trivial, and only constant values for @expr{a} and @expr{b} are
25919 recognized. Thus, @samp{lin(2 x y)} returns @expr{[0, 2, x y]},
25920 @samp{lin(2 - x y)} returns @expr{[2, -1, x y]}, and @samp{lin(x y)}
25921 returns @expr{[0, 1, x y]}. The @code{linnt} function would allow the
25922 first two cases but not the third. Also, neither @code{lin} nor
25923 @code{linnt} accept plain constants as linear in the one-argument
25924 case: @samp{islin(2,x)} is true, but @samp{islin(2)} is false.
25930 The @samp{istrue(a)} function returns 1 if @expr{a} is a nonzero
25931 number or provably nonzero formula, or 0 if @expr{a} is anything else.
25932 Calls to @code{istrue} can only be manipulated if @kbd{m O} mode is
25933 used to make sure they are not evaluated prematurely. (Note that
25934 declarations are used when deciding whether a formula is true;
25935 @code{istrue} returns 1 when @code{dnonzero} would return 1, and
25936 it returns 0 when @code{dnonzero} would return 0 or leave itself
25939 @node Rewrite Rules, , Logical Operations, Algebra
25940 @section Rewrite Rules
25943 @cindex Rewrite rules
25944 @cindex Transformations
25945 @cindex Pattern matching
25947 @pindex calc-rewrite
25949 The @kbd{a r} (@code{calc-rewrite}) [@code{rewrite}] command makes
25950 substitutions in a formula according to a specified pattern or patterns
25951 known as @dfn{rewrite rules}. Whereas @kbd{a b} (@code{calc-substitute})
25952 matches literally, so that substituting @samp{sin(x)} with @samp{cos(x)}
25953 matches only the @code{sin} function applied to the variable @code{x},
25954 rewrite rules match general kinds of formulas; rewriting using the rule
25955 @samp{sin(x) := cos(x)} matches @code{sin} of any argument and replaces
25956 it with @code{cos} of that same argument. The only significance of the
25957 name @code{x} is that the same name is used on both sides of the rule.
25959 Rewrite rules rearrange formulas already in Calc's memory.
25960 @xref{Syntax Tables}, to read about @dfn{syntax rules}, which are
25961 similar to algebraic rewrite rules but operate when new algebraic
25962 entries are being parsed, converting strings of characters into
25966 * Entering Rewrite Rules::
25967 * Basic Rewrite Rules::
25968 * Conditional Rewrite Rules::
25969 * Algebraic Properties of Rewrite Rules::
25970 * Other Features of Rewrite Rules::
25971 * Composing Patterns in Rewrite Rules::
25972 * Nested Formulas with Rewrite Rules::
25973 * Multi-Phase Rewrite Rules::
25974 * Selections with Rewrite Rules::
25975 * Matching Commands::
25976 * Automatic Rewrites::
25977 * Debugging Rewrites::
25978 * Examples of Rewrite Rules::
25981 @node Entering Rewrite Rules, Basic Rewrite Rules, Rewrite Rules, Rewrite Rules
25982 @subsection Entering Rewrite Rules
25985 Rewrite rules normally use the ``assignment'' operator
25986 @samp{@var{old} := @var{new}}.
25987 This operator is equivalent to the function call @samp{assign(old, new)}.
25988 The @code{assign} function is undefined by itself in Calc, so an
25989 assignment formula such as a rewrite rule will be left alone by ordinary
25990 Calc commands. But certain commands, like the rewrite system, interpret
25991 assignments in special ways.
25993 For example, the rule @samp{sin(x)^2 := 1-cos(x)^2} says to replace
25994 every occurrence of the sine of something, squared, with one minus the
25995 square of the cosine of that same thing. All by itself as a formula
25996 on the stack it does nothing, but when given to the @kbd{a r} command
25997 it turns that command into a sine-squared-to-cosine-squared converter.
25999 To specify a set of rules to be applied all at once, make a vector of
26002 When @kbd{a r} prompts you to enter the rewrite rules, you can answer
26007 With a rule: @kbd{f(x) := g(x) @key{RET}}.
26009 With a vector of rules: @kbd{[f1(x) := g1(x), f2(x) := g2(x)] @key{RET}}.
26010 (You can omit the enclosing square brackets if you wish.)
26012 With the name of a variable that contains the rule or rules vector:
26013 @kbd{myrules @key{RET}}.
26015 With any formula except a rule, a vector, or a variable name; this
26016 will be interpreted as the @var{old} half of a rewrite rule,
26017 and you will be prompted a second time for the @var{new} half:
26018 @kbd{f(x) @key{RET} g(x) @key{RET}}.
26020 With a blank line, in which case the rule, rules vector, or variable
26021 will be taken from the top of the stack (and the formula to be
26022 rewritten will come from the second-to-top position).
26025 If you enter the rules directly (as opposed to using rules stored
26026 in a variable), those rules will be put into the Trail so that you
26027 can retrieve them later. @xref{Trail Commands}.
26029 It is most convenient to store rules you use often in a variable and
26030 invoke them by giving the variable name. The @kbd{s e}
26031 (@code{calc-edit-variable}) command is an easy way to create or edit a
26032 rule set stored in a variable. You may also wish to use @kbd{s p}
26033 (@code{calc-permanent-variable}) to save your rules permanently;
26034 @pxref{Operations on Variables}.
26036 Rewrite rules are compiled into a special internal form for faster
26037 matching. If you enter a rule set directly it must be recompiled
26038 every time. If you store the rules in a variable and refer to them
26039 through that variable, they will be compiled once and saved away
26040 along with the variable for later reference. This is another good
26041 reason to store your rules in a variable.
26043 Calc also accepts an obsolete notation for rules, as vectors
26044 @samp{[@var{old}, @var{new}]}. But because it is easily confused with a
26045 vector of two rules, the use of this notation is no longer recommended.
26047 @node Basic Rewrite Rules, Conditional Rewrite Rules, Entering Rewrite Rules, Rewrite Rules
26048 @subsection Basic Rewrite Rules
26051 To match a particular formula @expr{x} with a particular rewrite rule
26052 @samp{@var{old} := @var{new}}, Calc compares the structure of @expr{x} with
26053 the structure of @var{old}. Variables that appear in @var{old} are
26054 treated as @dfn{meta-variables}; the corresponding positions in @expr{x}
26055 may contain any sub-formulas. For example, the pattern @samp{f(x,y)}
26056 would match the expression @samp{f(12, a+1)} with the meta-variable
26057 @samp{x} corresponding to 12 and with @samp{y} corresponding to
26058 @samp{a+1}. However, this pattern would not match @samp{f(12)} or
26059 @samp{g(12, a+1)}, since there is no assignment of the meta-variables
26060 that will make the pattern match these expressions. Notice that if
26061 the pattern is a single meta-variable, it will match any expression.
26063 If a given meta-variable appears more than once in @var{old}, the
26064 corresponding sub-formulas of @expr{x} must be identical. Thus
26065 the pattern @samp{f(x,x)} would match @samp{f(12, 12)} and
26066 @samp{f(a+1, a+1)} but not @samp{f(12, a+1)} or @samp{f(a+b, b+a)}.
26067 (@xref{Conditional Rewrite Rules}, for a way to match the latter.)
26069 Things other than variables must match exactly between the pattern
26070 and the target formula. To match a particular variable exactly, use
26071 the pseudo-function @samp{quote(v)} in the pattern. For example, the
26072 pattern @samp{x+quote(y)} matches @samp{x+y}, @samp{2+y}, or
26075 The special variable names @samp{e}, @samp{pi}, @samp{i}, @samp{phi},
26076 @samp{gamma}, @samp{inf}, @samp{uinf}, and @samp{nan} always match
26077 literally. Thus the pattern @samp{sin(d + e + f)} acts exactly like
26078 @samp{sin(d + quote(e) + f)}.
26080 If the @var{old} pattern is found to match a given formula, that
26081 formula is replaced by @var{new}, where any occurrences in @var{new}
26082 of meta-variables from the pattern are replaced with the sub-formulas
26083 that they matched. Thus, applying the rule @samp{f(x,y) := g(y+x,x)}
26084 to @samp{f(12, a+1)} would produce @samp{g(a+13, 12)}.
26086 The normal @kbd{a r} command applies rewrite rules over and over
26087 throughout the target formula until no further changes are possible
26088 (up to a limit of 100 times). Use @kbd{C-u 1 a r} to make only one
26091 @node Conditional Rewrite Rules, Algebraic Properties of Rewrite Rules, Basic Rewrite Rules, Rewrite Rules
26092 @subsection Conditional Rewrite Rules
26095 A rewrite rule can also be @dfn{conditional}, written in the form
26096 @samp{@var{old} := @var{new} :: @var{cond}}. (There is also the obsolete
26097 form @samp{[@var{old}, @var{new}, @var{cond}]}.) If a @var{cond} part
26099 rule, this is an additional condition that must be satisfied before
26100 the rule is accepted. Once @var{old} has been successfully matched
26101 to the target expression, @var{cond} is evaluated (with all the
26102 meta-variables substituted for the values they matched) and simplified
26103 with @kbd{a s} (@code{calc-simplify}). If the result is a nonzero
26104 number or any other object known to be nonzero (@pxref{Declarations}),
26105 the rule is accepted. If the result is zero or if it is a symbolic
26106 formula that is not known to be nonzero, the rule is rejected.
26107 @xref{Logical Operations}, for a number of functions that return
26108 1 or 0 according to the results of various tests.
26110 For example, the formula @samp{n > 0} simplifies to 1 or 0 if @expr{n}
26111 is replaced by a positive or nonpositive number, respectively (or if
26112 @expr{n} has been declared to be positive or nonpositive). Thus,
26113 the rule @samp{f(x,y) := g(y+x,x) :: x+y > 0} would apply to
26114 @samp{f(0, 4)} but not to @samp{f(-3, 2)} or @samp{f(12, a+1)}
26115 (assuming no outstanding declarations for @expr{a}). In the case of
26116 @samp{f(-3, 2)}, the condition can be shown not to be satisfied; in
26117 the case of @samp{f(12, a+1)}, the condition merely cannot be shown
26118 to be satisfied, but that is enough to reject the rule.
26120 While Calc will use declarations to reason about variables in the
26121 formula being rewritten, declarations do not apply to meta-variables.
26122 For example, the rule @samp{f(a) := g(a+1)} will match for any values
26123 of @samp{a}, such as complex numbers, vectors, or formulas, even if
26124 @samp{a} has been declared to be real or scalar. If you want the
26125 meta-variable @samp{a} to match only literal real numbers, use
26126 @samp{f(a) := g(a+1) :: real(a)}. If you want @samp{a} to match only
26127 reals and formulas which are provably real, use @samp{dreal(a)} as
26130 The @samp{::} operator is a shorthand for the @code{condition}
26131 function; @samp{@var{old} := @var{new} :: @var{cond}} is equivalent to
26132 the formula @samp{condition(assign(@var{old}, @var{new}), @var{cond})}.
26134 If you have several conditions, you can use @samp{... :: c1 :: c2 :: c3}
26135 or @samp{... :: c1 && c2 && c3}. The two are entirely equivalent.
26137 It is also possible to embed conditions inside the pattern:
26138 @samp{f(x :: x>0, y) := g(y+x, x)}. This is purely a notational
26139 convenience, though; where a condition appears in a rule has no
26140 effect on when it is tested. The rewrite-rule compiler automatically
26141 decides when it is best to test each condition while a rule is being
26144 Certain conditions are handled as special cases by the rewrite rule
26145 system and are tested very efficiently: Where @expr{x} is any
26146 meta-variable, these conditions are @samp{integer(x)}, @samp{real(x)},
26147 @samp{constant(x)}, @samp{negative(x)}, @samp{x >= y} where @expr{y}
26148 is either a constant or another meta-variable and @samp{>=} may be
26149 replaced by any of the six relational operators, and @samp{x % a = b}
26150 where @expr{a} and @expr{b} are constants. Other conditions, like
26151 @samp{x >= y+1} or @samp{dreal(x)}, will be less efficient to check
26152 since Calc must bring the whole evaluator and simplifier into play.
26154 An interesting property of @samp{::} is that neither of its arguments
26155 will be touched by Calc's default simplifications. This is important
26156 because conditions often are expressions that cannot safely be
26157 evaluated early. For example, the @code{typeof} function never
26158 remains in symbolic form; entering @samp{typeof(a)} will put the
26159 number 100 (the type code for variables like @samp{a}) on the stack.
26160 But putting the condition @samp{... :: typeof(a) = 6} on the stack
26161 is safe since @samp{::} prevents the @code{typeof} from being
26162 evaluated until the condition is actually used by the rewrite system.
26164 Since @samp{::} protects its lefthand side, too, you can use a dummy
26165 condition to protect a rule that must itself not evaluate early.
26166 For example, it's not safe to put @samp{a(f,x) := apply(f, [x])} on
26167 the stack because it will immediately evaluate to @samp{a(f,x) := f(x)},
26168 where the meta-variable-ness of @code{f} on the righthand side has been
26169 lost. But @samp{a(f,x) := apply(f, [x]) :: 1} is safe, and of course
26170 the condition @samp{1} is always true (nonzero) so it has no effect on
26171 the functioning of the rule. (The rewrite compiler will ensure that
26172 it doesn't even impact the speed of matching the rule.)
26174 @node Algebraic Properties of Rewrite Rules, Other Features of Rewrite Rules, Conditional Rewrite Rules, Rewrite Rules
26175 @subsection Algebraic Properties of Rewrite Rules
26178 The rewrite mechanism understands the algebraic properties of functions
26179 like @samp{+} and @samp{*}. In particular, pattern matching takes
26180 the associativity and commutativity of the following functions into
26184 + - * = != && || and or xor vint vunion vxor gcd lcm max min beta
26187 For example, the rewrite rule:
26190 a x + b x := (a + b) x
26194 will match formulas of the form,
26197 a x + b x, x a + x b, a x + x b, x a + b x
26200 Rewrites also understand the relationship between the @samp{+} and @samp{-}
26201 operators. The above rewrite rule will also match the formulas,
26204 a x - b x, x a - x b, a x - x b, x a - b x
26208 by matching @samp{b} in the pattern to @samp{-b} from the formula.
26210 Applied to a sum of many terms like @samp{r + a x + s + b x + t}, this
26211 pattern will check all pairs of terms for possible matches. The rewrite
26212 will take whichever suitable pair it discovers first.
26214 In general, a pattern using an associative operator like @samp{a + b}
26215 will try @var{2 n} different ways to match a sum of @var{n} terms
26216 like @samp{x + y + z - w}. First, @samp{a} is matched against each
26217 of @samp{x}, @samp{y}, @samp{z}, and @samp{-w} in turn, with @samp{b}
26218 being matched to the remainders @samp{y + z - w}, @samp{x + z - w}, etc.
26219 If none of these succeed, then @samp{b} is matched against each of the
26220 four terms with @samp{a} matching the remainder. Half-and-half matches,
26221 like @samp{(x + y) + (z - w)}, are not tried.
26223 Note that @samp{*} is not commutative when applied to matrices, but
26224 rewrite rules pretend that it is. If you type @kbd{m v} to enable
26225 Matrix mode (@pxref{Matrix Mode}), rewrite rules will match @samp{*}
26226 literally, ignoring its usual commutativity property. (In the
26227 current implementation, the associativity also vanishes---it is as
26228 if the pattern had been enclosed in a @code{plain} marker; see below.)
26229 If you are applying rewrites to formulas with matrices, it's best to
26230 enable Matrix mode first to prevent algebraically incorrect rewrites
26233 The pattern @samp{-x} will actually match any expression. For example,
26241 will rewrite @samp{f(a)} to @samp{-f(-a)}. To avoid this, either use
26242 a @code{plain} marker as described below, or add a @samp{negative(x)}
26243 condition. The @code{negative} function is true if its argument
26244 ``looks'' negative, for example, because it is a negative number or
26245 because it is a formula like @samp{-x}. The new rule using this
26249 f(x) := -f(-x) :: negative(x) @r{or, equivalently,}
26250 f(-x) := -f(x) :: negative(-x)
26253 In the same way, the pattern @samp{x - y} will match the sum @samp{a + b}
26254 by matching @samp{y} to @samp{-b}.
26256 The pattern @samp{a b} will also match the formula @samp{x/y} if
26257 @samp{y} is a number. Thus the rule @samp{a x + @w{b x} := (a+b) x}
26258 will also convert @samp{a x + x / 2} to @samp{(a + 0.5) x} (or
26259 @samp{(a + 1:2) x}, depending on the current fraction mode).
26261 Calc will @emph{not} take other liberties with @samp{*}, @samp{/}, and
26262 @samp{^}. For example, the pattern @samp{f(a b)} will not match
26263 @samp{f(x^2)}, and @samp{f(a + b)} will not match @samp{f(2 x)}, even
26264 though conceivably these patterns could match with @samp{a = b = x}.
26265 Nor will @samp{f(a b)} match @samp{f(x / y)} if @samp{y} is not a
26266 constant, even though it could be considered to match with @samp{a = x}
26267 and @samp{b = 1/y}. The reasons are partly for efficiency, and partly
26268 because while few mathematical operations are substantively different
26269 for addition and subtraction, often it is preferable to treat the cases
26270 of multiplication, division, and integer powers separately.
26272 Even more subtle is the rule set
26275 [ f(a) + f(b) := f(a + b), -f(a) := f(-a) ]
26279 attempting to match @samp{f(x) - f(y)}. You might think that Calc
26280 will view this subtraction as @samp{f(x) + (-f(y))} and then apply
26281 the above two rules in turn, but actually this will not work because
26282 Calc only does this when considering rules for @samp{+} (like the
26283 first rule in this set). So it will see first that @samp{f(x) + (-f(y))}
26284 does not match @samp{f(a) + f(b)} for any assignments of the
26285 meta-variables, and then it will see that @samp{f(x) - f(y)} does
26286 not match @samp{-f(a)} for any assignment of @samp{a}. Because Calc
26287 tries only one rule at a time, it will not be able to rewrite
26288 @samp{f(x) - f(y)} with this rule set. An explicit @samp{f(a) - f(b)}
26289 rule will have to be added.
26291 Another thing patterns will @emph{not} do is break up complex numbers.
26292 The pattern @samp{myconj(a + @w{b i)} := a - b i} will work for formulas
26293 involving the special constant @samp{i} (such as @samp{3 - 4 i}), but
26294 it will not match actual complex numbers like @samp{(3, -4)}. A version
26295 of the above rule for complex numbers would be
26298 myconj(a) := re(a) - im(a) (0,1) :: im(a) != 0
26302 (Because the @code{re} and @code{im} functions understand the properties
26303 of the special constant @samp{i}, this rule will also work for
26304 @samp{3 - 4 i}. In fact, this particular rule would probably be better
26305 without the @samp{im(a) != 0} condition, since if @samp{im(a) = 0} the
26306 righthand side of the rule will still give the correct answer for the
26307 conjugate of a real number.)
26309 It is also possible to specify optional arguments in patterns. The rule
26312 opt(a) x + opt(b) (x^opt(c) + opt(d)) := f(a, b, c, d)
26316 will match the formula
26323 in a fairly straightforward manner, but it will also match reduced
26327 x + x^2, 2(x + 1) - x, x + x
26331 producing, respectively,
26334 f(1, 1, 2, 0), f(-1, 2, 1, 1), f(1, 1, 1, 0)
26337 (The latter two formulas can be entered only if default simplifications
26338 have been turned off with @kbd{m O}.)
26340 The default value for a term of a sum is zero. The default value
26341 for a part of a product, for a power, or for the denominator of a
26342 quotient, is one. Also, @samp{-x} matches the pattern @samp{opt(a) b}
26343 with @samp{a = -1}.
26345 In particular, the distributive-law rule can be refined to
26348 opt(a) x + opt(b) x := (a + b) x
26352 so that it will convert, e.g., @samp{a x - x}, to @samp{(a - 1) x}.
26354 The pattern @samp{opt(a) + opt(b) x} matches almost any formulas which
26355 are linear in @samp{x}. You can also use the @code{lin} and @code{islin}
26356 functions with rewrite conditions to test for this; @pxref{Logical
26357 Operations}. These functions are not as convenient to use in rewrite
26358 rules, but they recognize more kinds of formulas as linear:
26359 @samp{x/z} is considered linear with @expr{b = 1/z} by @code{lin},
26360 but it will not match the above pattern because that pattern calls
26361 for a multiplication, not a division.
26363 As another example, the obvious rule to replace @samp{sin(x)^2 + cos(x)^2}
26367 sin(x)^2 + cos(x)^2 := 1
26371 misses many cases because the sine and cosine may both be multiplied by
26372 an equal factor. Here's a more successful rule:
26375 opt(a) sin(x)^2 + opt(a) cos(x)^2 := a
26378 Note that this rule will @emph{not} match @samp{sin(x)^2 + 6 cos(x)^2}
26379 because one @expr{a} would have ``matched'' 1 while the other matched 6.
26381 Calc automatically converts a rule like
26391 f(temp, x) := g(x) :: temp = x-1
26395 (where @code{temp} stands for a new, invented meta-variable that
26396 doesn't actually have a name). This modified rule will successfully
26397 match @samp{f(6, 7)}, binding @samp{temp} and @samp{x} to 6 and 7,
26398 respectively, then verifying that they differ by one even though
26399 @samp{6} does not superficially look like @samp{x-1}.
26401 However, Calc does not solve equations to interpret a rule. The
26405 f(x-1, x+1) := g(x)
26409 will not work. That is, it will match @samp{f(a - 1 + b, a + 1 + b)}
26410 but not @samp{f(6, 8)}. Calc always interprets at least one occurrence
26411 of a variable by literal matching. If the variable appears ``isolated''
26412 then Calc is smart enough to use it for literal matching. But in this
26413 last example, Calc is forced to rewrite the rule to @samp{f(x-1, temp)
26414 := g(x) :: temp = x+1} where the @samp{x-1} term must correspond to an
26415 actual ``something-minus-one'' in the target formula.
26417 A successful way to write this would be @samp{f(x, x+2) := g(x+1)}.
26418 You could make this resemble the original form more closely by using
26419 @code{let} notation, which is described in the next section:
26422 f(xm1, x+1) := g(x) :: let(x := xm1+1)
26425 Calc does this rewriting or ``conditionalizing'' for any sub-pattern
26426 which involves only the functions in the following list, operating
26427 only on constants and meta-variables which have already been matched
26428 elsewhere in the pattern. When matching a function call, Calc is
26429 careful to match arguments which are plain variables before arguments
26430 which are calls to any of the functions below, so that a pattern like
26431 @samp{f(x-1, x)} can be conditionalized even though the isolated
26432 @samp{x} comes after the @samp{x-1}.
26435 + - * / \ % ^ abs sign round rounde roundu trunc floor ceil
26436 max min re im conj arg
26439 You can suppress all of the special treatments described in this
26440 section by surrounding a function call with a @code{plain} marker.
26441 This marker causes the function call which is its argument to be
26442 matched literally, without regard to commutativity, associativity,
26443 negation, or conditionalization. When you use @code{plain}, the
26444 ``deep structure'' of the formula being matched can show through.
26448 plain(a - a b) := f(a, b)
26452 will match only literal subtractions. However, the @code{plain}
26453 marker does not affect its arguments' arguments. In this case,
26454 commutativity and associativity is still considered while matching
26455 the @w{@samp{a b}} sub-pattern, so the whole pattern will match
26456 @samp{x - y x} as well as @samp{x - x y}. We could go still
26460 plain(a - plain(a b)) := f(a, b)
26464 which would do a completely strict match for the pattern.
26466 By contrast, the @code{quote} marker means that not only the
26467 function name but also the arguments must be literally the same.
26468 The above pattern will match @samp{x - x y} but
26471 quote(a - a b) := f(a, b)
26475 will match only the single formula @samp{a - a b}. Also,
26478 quote(a - quote(a b)) := f(a, b)
26482 will match only @samp{a - quote(a b)}---probably not the desired
26485 A certain amount of algebra is also done when substituting the
26486 meta-variables on the righthand side of a rule. For example,
26490 a + f(b) := f(a + b)
26494 matching @samp{f(x) - y} would produce @samp{f((-y) + x)} if
26495 taken literally, but the rewrite mechanism will simplify the
26496 righthand side to @samp{f(x - y)} automatically. (Of course,
26497 the default simplifications would do this anyway, so this
26498 special simplification is only noticeable if you have turned the
26499 default simplifications off.) This rewriting is done only when
26500 a meta-variable expands to a ``negative-looking'' expression.
26501 If this simplification is not desirable, you can use a @code{plain}
26502 marker on the righthand side:
26505 a + f(b) := f(plain(a + b))
26509 In this example, we are still allowing the pattern-matcher to
26510 use all the algebra it can muster, but the righthand side will
26511 always simplify to a literal addition like @samp{f((-y) + x)}.
26513 @node Other Features of Rewrite Rules, Composing Patterns in Rewrite Rules, Algebraic Properties of Rewrite Rules, Rewrite Rules
26514 @subsection Other Features of Rewrite Rules
26517 Certain ``function names'' serve as markers in rewrite rules.
26518 Here is a complete list of these markers. First are listed the
26519 markers that work inside a pattern; then come the markers that
26520 work in the righthand side of a rule.
26526 One kind of marker, @samp{import(x)}, takes the place of a whole
26527 rule. Here @expr{x} is the name of a variable containing another
26528 rule set; those rules are ``spliced into'' the rule set that
26529 imports them. For example, if @samp{[f(a+b) := f(a) + f(b),
26530 f(a b) := a f(b) :: real(a)]} is stored in variable @samp{linearF},
26531 then the rule set @samp{[f(0) := 0, import(linearF)]} will apply
26532 all three rules. It is possible to modify the imported rules
26533 slightly: @samp{import(x, v1, x1, v2, x2, @dots{})} imports
26534 the rule set @expr{x} with all occurrences of
26535 @texline @math{v_1},
26536 @infoline @expr{v1},
26537 as either a variable name or a function name, replaced with
26538 @texline @math{x_1}
26539 @infoline @expr{x1}
26541 @texline @math{v_1}
26542 @infoline @expr{v1}
26543 is used as a function name, then
26544 @texline @math{x_1}
26545 @infoline @expr{x1}
26546 must be either a function name itself or a @w{@samp{< >}} nameless
26547 function; @pxref{Specifying Operators}.) For example, @samp{[g(0) := 0,
26548 import(linearF, f, g)]} applies the linearity rules to the function
26549 @samp{g} instead of @samp{f}. Imports can be nested, but the
26550 import-with-renaming feature may fail to rename sub-imports properly.
26552 The special functions allowed in patterns are:
26560 This pattern matches exactly @expr{x}; variable names in @expr{x} are
26561 not interpreted as meta-variables. The only flexibility is that
26562 numbers are compared for numeric equality, so that the pattern
26563 @samp{f(quote(12))} will match both @samp{f(12)} and @samp{f(12.0)}.
26564 (Numbers are always treated this way by the rewrite mechanism:
26565 The rule @samp{f(x,x) := g(x)} will match @samp{f(12, 12.0)}.
26566 The rewrite may produce either @samp{g(12)} or @samp{g(12.0)}
26567 as a result in this case.)
26574 Here @expr{x} must be a function call @samp{f(x1,x2,@dots{})}. This
26575 pattern matches a call to function @expr{f} with the specified
26576 argument patterns. No special knowledge of the properties of the
26577 function @expr{f} is used in this case; @samp{+} is not commutative or
26578 associative. Unlike @code{quote}, the arguments @samp{x1,x2,@dots{}}
26579 are treated as patterns. If you wish them to be treated ``plainly''
26580 as well, you must enclose them with more @code{plain} markers:
26581 @samp{plain(plain(@w{-a}) + plain(b c))}.
26588 Here @expr{x} must be a variable name. This must appear as an
26589 argument to a function or an element of a vector; it specifies that
26590 the argument or element is optional.
26591 As an argument to @samp{+}, @samp{-}, @samp{*}, @samp{&&}, or @samp{||},
26592 or as the second argument to @samp{/} or @samp{^}, the value @var{def}
26593 may be omitted. The pattern @samp{x + opt(y)} matches a sum by
26594 binding one summand to @expr{x} and the other to @expr{y}, and it
26595 matches anything else by binding the whole expression to @expr{x} and
26596 zero to @expr{y}. The other operators above work similarly.
26598 For general miscellaneous functions, the default value @code{def}
26599 must be specified. Optional arguments are dropped starting with
26600 the rightmost one during matching. For example, the pattern
26601 @samp{f(opt(a,0), b, opt(c,b))} will match @samp{f(b)}, @samp{f(a,b)},
26602 or @samp{f(a,b,c)}. Default values of zero and @expr{b} are
26603 supplied in this example for the omitted arguments. Note that
26604 the literal variable @expr{b} will be the default in the latter
26605 case, @emph{not} the value that matched the meta-variable @expr{b}.
26606 In other words, the default @var{def} is effectively quoted.
26608 @item condition(x,c)
26614 This matches the pattern @expr{x}, with the attached condition
26615 @expr{c}. It is the same as @samp{x :: c}.
26623 This matches anything that matches both pattern @expr{x} and
26624 pattern @expr{y}. It is the same as @samp{x &&& y}.
26625 @pxref{Composing Patterns in Rewrite Rules}.
26633 This matches anything that matches either pattern @expr{x} or
26634 pattern @expr{y}. It is the same as @w{@samp{x ||| y}}.
26642 This matches anything that does not match pattern @expr{x}.
26643 It is the same as @samp{!!! x}.
26649 @tindex cons (rewrites)
26650 This matches any vector of one or more elements. The first
26651 element is matched to @expr{h}; a vector of the remaining
26652 elements is matched to @expr{t}. Note that vectors of fixed
26653 length can also be matched as actual vectors: The rule
26654 @samp{cons(a,cons(b,[])) := cons(a+b,[])} is equivalent
26655 to the rule @samp{[a,b] := [a+b]}.
26661 @tindex rcons (rewrites)
26662 This is like @code{cons}, except that the @emph{last} element
26663 is matched to @expr{h}, with the remaining elements matched
26666 @item apply(f,args)
26670 @tindex apply (rewrites)
26671 This matches any function call. The name of the function, in
26672 the form of a variable, is matched to @expr{f}. The arguments
26673 of the function, as a vector of zero or more objects, are
26674 matched to @samp{args}. Constants, variables, and vectors
26675 do @emph{not} match an @code{apply} pattern. For example,
26676 @samp{apply(f,x)} matches any function call, @samp{apply(quote(f),x)}
26677 matches any call to the function @samp{f}, @samp{apply(f,[a,b])}
26678 matches any function call with exactly two arguments, and
26679 @samp{apply(quote(f), cons(a,cons(b,x)))} matches any call
26680 to the function @samp{f} with two or more arguments. Another
26681 way to implement the latter, if the rest of the rule does not
26682 need to refer to the first two arguments of @samp{f} by name,
26683 would be @samp{apply(quote(f), x :: vlen(x) >= 2)}.
26684 Here's a more interesting sample use of @code{apply}:
26687 apply(f,[x+n]) := n + apply(f,[x])
26688 :: in(f, [floor,ceil,round,trunc]) :: integer(n)
26691 Note, however, that this will be slower to match than a rule
26692 set with four separate rules. The reason is that Calc sorts
26693 the rules of a rule set according to top-level function name;
26694 if the top-level function is @code{apply}, Calc must try the
26695 rule for every single formula and sub-formula. If the top-level
26696 function in the pattern is, say, @code{floor}, then Calc invokes
26697 the rule only for sub-formulas which are calls to @code{floor}.
26699 Formulas normally written with operators like @code{+} are still
26700 considered function calls: @code{apply(f,x)} matches @samp{a+b}
26701 with @samp{f = add}, @samp{x = [a,b]}.
26703 You must use @code{apply} for meta-variables with function names
26704 on both sides of a rewrite rule: @samp{apply(f, [x]) := f(x+1)}
26705 is @emph{not} correct, because it rewrites @samp{spam(6)} into
26706 @samp{f(7)}. The righthand side should be @samp{apply(f, [x+1])}.
26707 Also note that you will have to use No-Simplify mode (@kbd{m O})
26708 when entering this rule so that the @code{apply} isn't
26709 evaluated immediately to get the new rule @samp{f(x) := f(x+1)}.
26710 Or, use @kbd{s e} to enter the rule without going through the stack,
26711 or enter the rule as @samp{apply(f, [x]) := apply(f, [x+1]) @w{:: 1}}.
26712 @xref{Conditional Rewrite Rules}.
26719 This is used for applying rules to formulas with selections;
26720 @pxref{Selections with Rewrite Rules}.
26723 Special functions for the righthand sides of rules are:
26727 The notation @samp{quote(x)} is changed to @samp{x} when the
26728 righthand side is used. As far as the rewrite rule is concerned,
26729 @code{quote} is invisible. However, @code{quote} has the special
26730 property in Calc that its argument is not evaluated. Thus,
26731 while it will not work to put the rule @samp{t(a) := typeof(a)}
26732 on the stack because @samp{typeof(a)} is evaluated immediately
26733 to produce @samp{t(a) := 100}, you can use @code{quote} to
26734 protect the righthand side: @samp{t(a) := quote(typeof(a))}.
26735 (@xref{Conditional Rewrite Rules}, for another trick for
26736 protecting rules from evaluation.)
26739 Special properties of and simplifications for the function call
26740 @expr{x} are not used. One interesting case where @code{plain}
26741 is useful is the rule, @samp{q(x) := quote(x)}, trying to expand a
26742 shorthand notation for the @code{quote} function. This rule will
26743 not work as shown; instead of replacing @samp{q(foo)} with
26744 @samp{quote(foo)}, it will replace it with @samp{foo}! The correct
26745 rule would be @samp{q(x) := plain(quote(x))}.
26748 Where @expr{t} is a vector, this is converted into an expanded
26749 vector during rewrite processing. Note that @code{cons} is a regular
26750 Calc function which normally does this anyway; the only way @code{cons}
26751 is treated specially by rewrites is that @code{cons} on the righthand
26752 side of a rule will be evaluated even if default simplifications
26753 have been turned off.
26756 Analogous to @code{cons} except putting @expr{h} at the @emph{end} of
26757 the vector @expr{t}.
26759 @item apply(f,args)
26760 Where @expr{f} is a variable and @var{args} is a vector, this
26761 is converted to a function call. Once again, note that @code{apply}
26762 is also a regular Calc function.
26769 The formula @expr{x} is handled in the usual way, then the
26770 default simplifications are applied to it even if they have
26771 been turned off normally. This allows you to treat any function
26772 similarly to the way @code{cons} and @code{apply} are always
26773 treated. However, there is a slight difference: @samp{cons(2+3, [])}
26774 with default simplifications off will be converted to @samp{[2+3]},
26775 whereas @samp{eval(cons(2+3, []))} will be converted to @samp{[5]}.
26782 The formula @expr{x} has meta-variables substituted in the usual
26783 way, then algebraically simplified as if by the @kbd{a s} command.
26785 @item evalextsimp(x)
26789 @tindex evalextsimp
26790 The formula @expr{x} has meta-variables substituted in the normal
26791 way, then ``extendedly'' simplified as if by the @kbd{a e} command.
26794 @xref{Selections with Rewrite Rules}.
26797 There are also some special functions you can use in conditions.
26805 The expression @expr{x} is evaluated with meta-variables substituted.
26806 The @kbd{a s} command's simplifications are @emph{not} applied by
26807 default, but @expr{x} can include calls to @code{evalsimp} or
26808 @code{evalextsimp} as described above to invoke higher levels
26809 of simplification. The
26810 result of @expr{x} is then bound to the meta-variable @expr{v}. As
26811 usual, if this meta-variable has already been matched to something
26812 else the two values must be equal; if the meta-variable is new then
26813 it is bound to the result of the expression. This variable can then
26814 appear in later conditions, and on the righthand side of the rule.
26815 In fact, @expr{v} may be any pattern in which case the result of
26816 evaluating @expr{x} is matched to that pattern, binding any
26817 meta-variables that appear in that pattern. Note that @code{let}
26818 can only appear by itself as a condition, or as one term of an
26819 @samp{&&} which is a whole condition: It cannot be inside
26820 an @samp{||} term or otherwise buried.
26822 The alternate, equivalent form @samp{let(v, x)} is also recognized.
26823 Note that the use of @samp{:=} by @code{let}, while still being
26824 assignment-like in character, is unrelated to the use of @samp{:=}
26825 in the main part of a rewrite rule.
26827 As an example, @samp{f(a) := g(ia) :: let(ia := 1/a) :: constant(ia)}
26828 replaces @samp{f(a)} with @samp{g} of the inverse of @samp{a}, if
26829 that inverse exists and is constant. For example, if @samp{a} is a
26830 singular matrix the operation @samp{1/a} is left unsimplified and
26831 @samp{constant(ia)} fails, but if @samp{a} is an invertible matrix
26832 then the rule succeeds. Without @code{let} there would be no way
26833 to express this rule that didn't have to invert the matrix twice.
26834 Note that, because the meta-variable @samp{ia} is otherwise unbound
26835 in this rule, the @code{let} condition itself always ``succeeds''
26836 because no matter what @samp{1/a} evaluates to, it can successfully
26837 be bound to @code{ia}.
26839 Here's another example, for integrating cosines of linear
26840 terms: @samp{myint(cos(y),x) := sin(y)/b :: let([a,b,x] := lin(y,x))}.
26841 The @code{lin} function returns a 3-vector if its argument is linear,
26842 or leaves itself unevaluated if not. But an unevaluated @code{lin}
26843 call will not match the 3-vector on the lefthand side of the @code{let},
26844 so this @code{let} both verifies that @code{y} is linear, and binds
26845 the coefficients @code{a} and @code{b} for use elsewhere in the rule.
26846 (It would have been possible to use @samp{sin(a x + b)/b} for the
26847 righthand side instead, but using @samp{sin(y)/b} avoids gratuitous
26848 rearrangement of the argument of the sine.)
26854 Similarly, here is a rule that implements an inverse-@code{erf}
26855 function. It uses @code{root} to search for a solution. If
26856 @code{root} succeeds, it will return a vector of two numbers
26857 where the first number is the desired solution. If no solution
26858 is found, @code{root} remains in symbolic form. So we use
26859 @code{let} to check that the result was indeed a vector.
26862 ierf(x) := y :: let([y,z] := root(erf(a) = x, a, .5))
26866 The meta-variable @var{v}, which must already have been matched
26867 to something elsewhere in the rule, is compared against pattern
26868 @var{p}. Since @code{matches} is a standard Calc function, it
26869 can appear anywhere in a condition. But if it appears alone or
26870 as a term of a top-level @samp{&&}, then you get the special
26871 extra feature that meta-variables which are bound to things
26872 inside @var{p} can be used elsewhere in the surrounding rewrite
26875 The only real difference between @samp{let(p := v)} and
26876 @samp{matches(v, p)} is that the former evaluates @samp{v} using
26877 the default simplifications, while the latter does not.
26881 This is actually a variable, not a function. If @code{remember}
26882 appears as a condition in a rule, then when that rule succeeds
26883 the original expression and rewritten expression are added to the
26884 front of the rule set that contained the rule. If the rule set
26885 was not stored in a variable, @code{remember} is ignored. The
26886 lefthand side is enclosed in @code{quote} in the added rule if it
26887 contains any variables.
26889 For example, the rule @samp{f(n) := n f(n-1) :: remember} applied
26890 to @samp{f(7)} will add the rule @samp{f(7) := 7 f(6)} to the front
26891 of the rule set. The rule set @code{EvalRules} works slightly
26892 differently: There, the evaluation of @samp{f(6)} will complete before
26893 the result is added to the rule set, in this case as @samp{f(7) := 5040}.
26894 Thus @code{remember} is most useful inside @code{EvalRules}.
26896 It is up to you to ensure that the optimization performed by
26897 @code{remember} is safe. For example, the rule @samp{foo(n) := n
26898 :: evalv(eatfoo) > 0 :: remember} is a bad idea (@code{evalv} is
26899 the function equivalent of the @kbd{=} command); if the variable
26900 @code{eatfoo} ever contains 1, rules like @samp{foo(7) := 7} will
26901 be added to the rule set and will continue to operate even if
26902 @code{eatfoo} is later changed to 0.
26909 Remember the match as described above, but only if condition @expr{c}
26910 is true. For example, @samp{remember(n % 4 = 0)} in the above factorial
26911 rule remembers only every fourth result. Note that @samp{remember(1)}
26912 is equivalent to @samp{remember}, and @samp{remember(0)} has no effect.
26915 @node Composing Patterns in Rewrite Rules, Nested Formulas with Rewrite Rules, Other Features of Rewrite Rules, Rewrite Rules
26916 @subsection Composing Patterns in Rewrite Rules
26919 There are three operators, @samp{&&&}, @samp{|||}, and @samp{!!!},
26920 that combine rewrite patterns to make larger patterns. The
26921 combinations are ``and,'' ``or,'' and ``not,'' respectively, and
26922 these operators are the pattern equivalents of @samp{&&}, @samp{||}
26923 and @samp{!} (which operate on zero-or-nonzero logical values).
26925 Note that @samp{&&&}, @samp{|||}, and @samp{!!!} are left in symbolic
26926 form by all regular Calc features; they have special meaning only in
26927 the context of rewrite rule patterns.
26929 The pattern @samp{@var{p1} &&& @var{p2}} matches anything that
26930 matches both @var{p1} and @var{p2}. One especially useful case is
26931 when one of @var{p1} or @var{p2} is a meta-variable. For example,
26932 here is a rule that operates on error forms:
26935 f(x &&& a +/- b, x) := g(x)
26938 This does the same thing, but is arguably simpler than, the rule
26941 f(a +/- b, a +/- b) := g(a +/- b)
26948 Here's another interesting example:
26951 ends(cons(a, x) &&& rcons(y, b)) := [a, b]
26955 which effectively clips out the middle of a vector leaving just
26956 the first and last elements. This rule will change a one-element
26957 vector @samp{[a]} to @samp{[a, a]}. The similar rule
26960 ends(cons(a, rcons(y, b))) := [a, b]
26964 would do the same thing except that it would fail to match a
26965 one-element vector.
26971 The pattern @samp{@var{p1} ||| @var{p2}} matches anything that
26972 matches either @var{p1} or @var{p2}. Calc first tries matching
26973 against @var{p1}; if that fails, it goes on to try @var{p2}.
26979 A simple example of @samp{|||} is
26982 curve(inf ||| -inf) := 0
26986 which converts both @samp{curve(inf)} and @samp{curve(-inf)} to zero.
26988 Here is a larger example:
26991 log(a, b) ||| (ln(a) :: let(b := e)) := mylog(a, b)
26994 This matches both generalized and natural logarithms in a single rule.
26995 Note that the @samp{::} term must be enclosed in parentheses because
26996 that operator has lower precedence than @samp{|||} or @samp{:=}.
26998 (In practice this rule would probably include a third alternative,
26999 omitted here for brevity, to take care of @code{log10}.)
27001 While Calc generally treats interior conditions exactly the same as
27002 conditions on the outside of a rule, it does guarantee that if all the
27003 variables in the condition are special names like @code{e}, or already
27004 bound in the pattern to which the condition is attached (say, if
27005 @samp{a} had appeared in this condition), then Calc will process this
27006 condition right after matching the pattern to the left of the @samp{::}.
27007 Thus, we know that @samp{b} will be bound to @samp{e} only if the
27008 @code{ln} branch of the @samp{|||} was taken.
27010 Note that this rule was careful to bind the same set of meta-variables
27011 on both sides of the @samp{|||}. Calc does not check this, but if
27012 you bind a certain meta-variable only in one branch and then use that
27013 meta-variable elsewhere in the rule, results are unpredictable:
27016 f(a,b) ||| g(b) := h(a,b)
27019 Here if the pattern matches @samp{g(17)}, Calc makes no promises about
27020 the value that will be substituted for @samp{a} on the righthand side.
27026 The pattern @samp{!!! @var{pat}} matches anything that does not
27027 match @var{pat}. Any meta-variables that are bound while matching
27028 @var{pat} remain unbound outside of @var{pat}.
27033 f(x &&& !!! a +/- b, !!![]) := g(x)
27037 converts @code{f} whose first argument is anything @emph{except} an
27038 error form, and whose second argument is not the empty vector, into
27039 a similar call to @code{g} (but without the second argument).
27041 If we know that the second argument will be a vector (empty or not),
27042 then an equivalent rule would be:
27045 f(x, y) := g(x) :: typeof(x) != 7 :: vlen(y) > 0
27049 where of course 7 is the @code{typeof} code for error forms.
27050 Another final condition, that works for any kind of @samp{y},
27051 would be @samp{!istrue(y == [])}. (The @code{istrue} function
27052 returns an explicit 0 if its argument was left in symbolic form;
27053 plain @samp{!(y == [])} or @samp{y != []} would not work to replace
27054 @samp{!!![]} since these would be left unsimplified, and thus cause
27055 the rule to fail, if @samp{y} was something like a variable name.)
27057 It is possible for a @samp{!!!} to refer to meta-variables bound
27058 elsewhere in the pattern. For example,
27065 matches any call to @code{f} with different arguments, changing
27066 this to @code{g} with only the first argument.
27068 If a function call is to be matched and one of the argument patterns
27069 contains a @samp{!!!} somewhere inside it, that argument will be
27077 will be careful to bind @samp{a} to the second argument of @code{f}
27078 before testing the first argument. If Calc had tried to match the
27079 first argument of @code{f} first, the results would have been
27080 disastrous: since @code{a} was unbound so far, the pattern @samp{a}
27081 would have matched anything at all, and the pattern @samp{!!!a}
27082 therefore would @emph{not} have matched anything at all!
27084 @node Nested Formulas with Rewrite Rules, Multi-Phase Rewrite Rules, Composing Patterns in Rewrite Rules, Rewrite Rules
27085 @subsection Nested Formulas with Rewrite Rules
27088 When @kbd{a r} (@code{calc-rewrite}) is used, it takes an expression from
27089 the top of the stack and attempts to match any of the specified rules
27090 to any part of the expression, starting with the whole expression
27091 and then, if that fails, trying deeper and deeper sub-expressions.
27092 For each part of the expression, the rules are tried in the order
27093 they appear in the rules vector. The first rule to match the first
27094 sub-expression wins; it replaces the matched sub-expression according
27095 to the @var{new} part of the rule.
27097 Often, the rule set will match and change the formula several times.
27098 The top-level formula is first matched and substituted repeatedly until
27099 it no longer matches the pattern; then, sub-formulas are tried, and
27100 so on. Once every part of the formula has gotten its chance, the
27101 rewrite mechanism starts over again with the top-level formula
27102 (in case a substitution of one of its arguments has caused it again
27103 to match). This continues until no further matches can be made
27104 anywhere in the formula.
27106 It is possible for a rule set to get into an infinite loop. The
27107 most obvious case, replacing a formula with itself, is not a problem
27108 because a rule is not considered to ``succeed'' unless the righthand
27109 side actually comes out to something different than the original
27110 formula or sub-formula that was matched. But if you accidentally
27111 had both @samp{ln(a b) := ln(a) + ln(b)} and the reverse
27112 @samp{ln(a) + ln(b) := ln(a b)} in your rule set, Calc would
27113 run forever switching a formula back and forth between the two
27116 To avoid disaster, Calc normally stops after 100 changes have been
27117 made to the formula. This will be enough for most multiple rewrites,
27118 but it will keep an endless loop of rewrites from locking up the
27119 computer forever. (On most systems, you can also type @kbd{C-g} to
27120 halt any Emacs command prematurely.)
27122 To change this limit, give a positive numeric prefix argument.
27123 In particular, @kbd{M-1 a r} applies only one rewrite at a time,
27124 useful when you are first testing your rule (or just if repeated
27125 rewriting is not what is called for by your application).
27134 You can also put a ``function call'' @samp{iterations(@var{n})}
27135 in place of a rule anywhere in your rules vector (but usually at
27136 the top). Then, @var{n} will be used instead of 100 as the default
27137 number of iterations for this rule set. You can use
27138 @samp{iterations(inf)} if you want no iteration limit by default.
27139 A prefix argument will override the @code{iterations} limit in the
27147 More precisely, the limit controls the number of ``iterations,''
27148 where each iteration is a successful matching of a rule pattern whose
27149 righthand side, after substituting meta-variables and applying the
27150 default simplifications, is different from the original sub-formula
27153 A prefix argument of zero sets the limit to infinity. Use with caution!
27155 Given a negative numeric prefix argument, @kbd{a r} will match and
27156 substitute the top-level expression up to that many times, but
27157 will not attempt to match the rules to any sub-expressions.
27159 In a formula, @code{rewrite(@var{expr}, @var{rules}, @var{n})}
27160 does a rewriting operation. Here @var{expr} is the expression
27161 being rewritten, @var{rules} is the rule, vector of rules, or
27162 variable containing the rules, and @var{n} is the optional
27163 iteration limit, which may be a positive integer, a negative
27164 integer, or @samp{inf} or @samp{-inf}. If @var{n} is omitted
27165 the @code{iterations} value from the rule set is used; if both
27166 are omitted, 100 is used.
27168 @node Multi-Phase Rewrite Rules, Selections with Rewrite Rules, Nested Formulas with Rewrite Rules, Rewrite Rules
27169 @subsection Multi-Phase Rewrite Rules
27172 It is possible to separate a rewrite rule set into several @dfn{phases}.
27173 During each phase, certain rules will be enabled while certain others
27174 will be disabled. A @dfn{phase schedule} controls the order in which
27175 phases occur during the rewriting process.
27182 If a call to the marker function @code{phase} appears in the rules
27183 vector in place of a rule, all rules following that point will be
27184 members of the phase(s) identified in the arguments to @code{phase}.
27185 Phases are given integer numbers. The markers @samp{phase()} and
27186 @samp{phase(all)} both mean the following rules belong to all phases;
27187 this is the default at the start of the rule set.
27189 If you do not explicitly schedule the phases, Calc sorts all phase
27190 numbers that appear in the rule set and executes the phases in
27191 ascending order. For example, the rule set
27208 has three phases, 1 through 3. Phase 1 consists of the @code{f0},
27209 @code{f1}, and @code{f4} rules (in that order). Phase 2 consists of
27210 @code{f0}, @code{f2}, and @code{f4}. Phase 3 consists of @code{f0}
27213 When Calc rewrites a formula using this rule set, it first rewrites
27214 the formula using only the phase 1 rules until no further changes are
27215 possible. Then it switches to the phase 2 rule set and continues
27216 until no further changes occur, then finally rewrites with phase 3.
27217 When no more phase 3 rules apply, rewriting finishes. (This is
27218 assuming @kbd{a r} with a large enough prefix argument to allow the
27219 rewriting to run to completion; the sequence just described stops
27220 early if the number of iterations specified in the prefix argument,
27221 100 by default, is reached.)
27223 During each phase, Calc descends through the nested levels of the
27224 formula as described previously. (@xref{Nested Formulas with Rewrite
27225 Rules}.) Rewriting starts at the top of the formula, then works its
27226 way down to the parts, then goes back to the top and works down again.
27227 The phase 2 rules do not begin until no phase 1 rules apply anywhere
27234 A @code{schedule} marker appearing in the rule set (anywhere, but
27235 conventionally at the top) changes the default schedule of phases.
27236 In the simplest case, @code{schedule} has a sequence of phase numbers
27237 for arguments; each phase number is invoked in turn until the
27238 arguments to @code{schedule} are exhausted. Thus adding
27239 @samp{schedule(3,2,1)} at the top of the above rule set would
27240 reverse the order of the phases; @samp{schedule(1,2,3)} would have
27241 no effect since this is the default schedule; and @samp{schedule(1,2,1,3)}
27242 would give phase 1 a second chance after phase 2 has completed, before
27243 moving on to phase 3.
27245 Any argument to @code{schedule} can instead be a vector of phase
27246 numbers (or even of sub-vectors). Then the sub-sequence of phases
27247 described by the vector are tried repeatedly until no change occurs
27248 in any phase in the sequence. For example, @samp{schedule([1, 2], 3)}
27249 tries phase 1, then phase 2, then, if either phase made any changes
27250 to the formula, repeats these two phases until they can make no
27251 further progress. Finally, it goes on to phase 3 for finishing
27254 Also, items in @code{schedule} can be variable names as well as
27255 numbers. A variable name is interpreted as the name of a function
27256 to call on the whole formula. For example, @samp{schedule(1, simplify)}
27257 says to apply the phase-1 rules (presumably, all of them), then to
27258 call @code{simplify} which is the function name equivalent of @kbd{a s}.
27259 Likewise, @samp{schedule([1, simplify])} says to alternate between
27260 phase 1 and @kbd{a s} until no further changes occur.
27262 Phases can be used purely to improve efficiency; if it is known that
27263 a certain group of rules will apply only at the beginning of rewriting,
27264 and a certain other group will apply only at the end, then rewriting
27265 will be faster if these groups are identified as separate phases.
27266 Once the phase 1 rules are done, Calc can put them aside and no longer
27267 spend any time on them while it works on phase 2.
27269 There are also some problems that can only be solved with several
27270 rewrite phases. For a real-world example of a multi-phase rule set,
27271 examine the set @code{FitRules}, which is used by the curve-fitting
27272 command to convert a model expression to linear form.
27273 @xref{Curve Fitting Details}. This set is divided into four phases.
27274 The first phase rewrites certain kinds of expressions to be more
27275 easily linearizable, but less computationally efficient. After the
27276 linear components have been picked out, the final phase includes the
27277 opposite rewrites to put each component back into an efficient form.
27278 If both sets of rules were included in one big phase, Calc could get
27279 into an infinite loop going back and forth between the two forms.
27281 Elsewhere in @code{FitRules}, the components are first isolated,
27282 then recombined where possible to reduce the complexity of the linear
27283 fit, then finally packaged one component at a time into vectors.
27284 If the packaging rules were allowed to begin before the recombining
27285 rules were finished, some components might be put away into vectors
27286 before they had a chance to recombine. By putting these rules in
27287 two separate phases, this problem is neatly avoided.
27289 @node Selections with Rewrite Rules, Matching Commands, Multi-Phase Rewrite Rules, Rewrite Rules
27290 @subsection Selections with Rewrite Rules
27293 If a sub-formula of the current formula is selected (as by @kbd{j s};
27294 @pxref{Selecting Subformulas}), the @kbd{a r} (@code{calc-rewrite})
27295 command applies only to that sub-formula. Together with a negative
27296 prefix argument, you can use this fact to apply a rewrite to one
27297 specific part of a formula without affecting any other parts.
27300 @pindex calc-rewrite-selection
27301 The @kbd{j r} (@code{calc-rewrite-selection}) command allows more
27302 sophisticated operations on selections. This command prompts for
27303 the rules in the same way as @kbd{a r}, but it then applies those
27304 rules to the whole formula in question even though a sub-formula
27305 of it has been selected. However, the selected sub-formula will
27306 first have been surrounded by a @samp{select( )} function call.
27307 (Calc's evaluator does not understand the function name @code{select};
27308 this is only a tag used by the @kbd{j r} command.)
27310 For example, suppose the formula on the stack is @samp{2 (a + b)^2}
27311 and the sub-formula @samp{a + b} is selected. This formula will
27312 be rewritten to @samp{2 select(a + b)^2} and then the rewrite
27313 rules will be applied in the usual way. The rewrite rules can
27314 include references to @code{select} to tell where in the pattern
27315 the selected sub-formula should appear.
27317 If there is still exactly one @samp{select( )} function call in
27318 the formula after rewriting is done, it indicates which part of
27319 the formula should be selected afterwards. Otherwise, the
27320 formula will be unselected.
27322 You can make @kbd{j r} act much like @kbd{a r} by enclosing both parts
27323 of the rewrite rule with @samp{select()}. However, @kbd{j r}
27324 allows you to use the current selection in more flexible ways.
27325 Suppose you wished to make a rule which removed the exponent from
27326 the selected term; the rule @samp{select(a)^x := select(a)} would
27327 work. In the above example, it would rewrite @samp{2 select(a + b)^2}
27328 to @samp{2 select(a + b)}. This would then be returned to the
27329 stack as @samp{2 (a + b)} with the @samp{a + b} selected.
27331 The @kbd{j r} command uses one iteration by default, unlike
27332 @kbd{a r} which defaults to 100 iterations. A numeric prefix
27333 argument affects @kbd{j r} in the same way as @kbd{a r}.
27334 @xref{Nested Formulas with Rewrite Rules}.
27336 As with other selection commands, @kbd{j r} operates on the stack
27337 entry that contains the cursor. (If the cursor is on the top-of-stack
27338 @samp{.} marker, it works as if the cursor were on the formula
27341 If you don't specify a set of rules, the rules are taken from the
27342 top of the stack, just as with @kbd{a r}. In this case, the
27343 cursor must indicate stack entry 2 or above as the formula to be
27344 rewritten (otherwise the same formula would be used as both the
27345 target and the rewrite rules).
27347 If the indicated formula has no selection, the cursor position within
27348 the formula temporarily selects a sub-formula for the purposes of this
27349 command. If the cursor is not on any sub-formula (e.g., it is in
27350 the line-number area to the left of the formula), the @samp{select( )}
27351 markers are ignored by the rewrite mechanism and the rules are allowed
27352 to apply anywhere in the formula.
27354 As a special feature, the normal @kbd{a r} command also ignores
27355 @samp{select( )} calls in rewrite rules. For example, if you used the
27356 above rule @samp{select(a)^x := select(a)} with @kbd{a r}, it would apply
27357 the rule as if it were @samp{a^x := a}. Thus, you can write general
27358 purpose rules with @samp{select( )} hints inside them so that they
27359 will ``do the right thing'' in both @kbd{a r} and @kbd{j r},
27360 both with and without selections.
27362 @node Matching Commands, Automatic Rewrites, Selections with Rewrite Rules, Rewrite Rules
27363 @subsection Matching Commands
27369 The @kbd{a m} (@code{calc-match}) [@code{match}] function takes a
27370 vector of formulas and a rewrite-rule-style pattern, and produces
27371 a vector of all formulas which match the pattern. The command
27372 prompts you to enter the pattern; as for @kbd{a r}, you can enter
27373 a single pattern (i.e., a formula with meta-variables), or a
27374 vector of patterns, or a variable which contains patterns, or
27375 you can give a blank response in which case the patterns are taken
27376 from the top of the stack. The pattern set will be compiled once
27377 and saved if it is stored in a variable. If there are several
27378 patterns in the set, vector elements are kept if they match any
27381 For example, @samp{match(a+b, [x, x+y, x-y, 7, x+y+z])}
27382 will return @samp{[x+y, x-y, x+y+z]}.
27384 The @code{import} mechanism is not available for pattern sets.
27386 The @kbd{a m} command can also be used to extract all vector elements
27387 which satisfy any condition: The pattern @samp{x :: x>0} will select
27388 all the positive vector elements.
27392 With the Inverse flag [@code{matchnot}], this command extracts all
27393 vector elements which do @emph{not} match the given pattern.
27399 There is also a function @samp{matches(@var{x}, @var{p})} which
27400 evaluates to 1 if expression @var{x} matches pattern @var{p}, or
27401 to 0 otherwise. This is sometimes useful for including into the
27402 conditional clauses of other rewrite rules.
27408 The function @code{vmatches} is just like @code{matches}, except
27409 that if the match succeeds it returns a vector of assignments to
27410 the meta-variables instead of the number 1. For example,
27411 @samp{vmatches(f(1,2), f(a,b))} returns @samp{[a := 1, b := 2]}.
27412 If the match fails, the function returns the number 0.
27414 @node Automatic Rewrites, Debugging Rewrites, Matching Commands, Rewrite Rules
27415 @subsection Automatic Rewrites
27418 @cindex @code{EvalRules} variable
27420 It is possible to get Calc to apply a set of rewrite rules on all
27421 results, effectively adding to the built-in set of default
27422 simplifications. To do this, simply store your rule set in the
27423 variable @code{EvalRules}. There is a convenient @kbd{s E} command
27424 for editing @code{EvalRules}; @pxref{Operations on Variables}.
27426 For example, suppose you want @samp{sin(a + b)} to be expanded out
27427 to @samp{sin(b) cos(a) + cos(b) sin(a)} wherever it appears, and
27428 similarly for @samp{cos(a + b)}. The corresponding rewrite rule
27433 [ sin(a + b) := cos(a) sin(b) + sin(a) cos(b),
27434 cos(a + b) := cos(a) cos(b) - sin(a) sin(b) ]
27438 To apply these manually, you could put them in a variable called
27439 @code{trigexp} and then use @kbd{a r trigexp} every time you wanted
27440 to expand trig functions. But if instead you store them in the
27441 variable @code{EvalRules}, they will automatically be applied to all
27442 sines and cosines of sums. Then, with @samp{2 x} and @samp{45} on
27443 the stack, typing @kbd{+ S} will (assuming Degrees mode) result in
27444 @samp{0.7071 sin(2 x) + 0.7071 cos(2 x)} automatically.
27446 As each level of a formula is evaluated, the rules from
27447 @code{EvalRules} are applied before the default simplifications.
27448 Rewriting continues until no further @code{EvalRules} apply.
27449 Note that this is different from the usual order of application of
27450 rewrite rules: @code{EvalRules} works from the bottom up, simplifying
27451 the arguments to a function before the function itself, while @kbd{a r}
27452 applies rules from the top down.
27454 Because the @code{EvalRules} are tried first, you can use them to
27455 override the normal behavior of any built-in Calc function.
27457 It is important not to write a rule that will get into an infinite
27458 loop. For example, the rule set @samp{[f(0) := 1, f(n) := n f(n-1)]}
27459 appears to be a good definition of a factorial function, but it is
27460 unsafe. Imagine what happens if @samp{f(2.5)} is simplified. Calc
27461 will continue to subtract 1 from this argument forever without reaching
27462 zero. A safer second rule would be @samp{f(n) := n f(n-1) :: n>0}.
27463 Another dangerous rule is @samp{g(x, y) := g(y, x)}. Rewriting
27464 @samp{g(2, 4)}, this would bounce back and forth between that and
27465 @samp{g(4, 2)} forever. If an infinite loop in @code{EvalRules}
27466 occurs, Emacs will eventually stop with a ``Computation got stuck
27467 or ran too long'' message.
27469 Another subtle difference between @code{EvalRules} and regular rewrites
27470 concerns rules that rewrite a formula into an identical formula. For
27471 example, @samp{f(n) := f(floor(n))} ``fails to match'' when @expr{n} is
27472 already an integer. But in @code{EvalRules} this case is detected only
27473 if the righthand side literally becomes the original formula before any
27474 further simplification. This means that @samp{f(n) := f(floor(n))} will
27475 get into an infinite loop if it occurs in @code{EvalRules}. Calc will
27476 replace @samp{f(6)} with @samp{f(floor(6))}, which is different from
27477 @samp{f(6)}, so it will consider the rule to have matched and will
27478 continue simplifying that formula; first the argument is simplified
27479 to get @samp{f(6)}, then the rule matches again to get @samp{f(floor(6))}
27480 again, ad infinitum. A much safer rule would check its argument first,
27481 say, with @samp{f(n) := f(floor(n)) :: !dint(n)}.
27483 (What really happens is that the rewrite mechanism substitutes the
27484 meta-variables in the righthand side of a rule, compares to see if the
27485 result is the same as the original formula and fails if so, then uses
27486 the default simplifications to simplify the result and compares again
27487 (and again fails if the formula has simplified back to its original
27488 form). The only special wrinkle for the @code{EvalRules} is that the
27489 same rules will come back into play when the default simplifications
27490 are used. What Calc wants to do is build @samp{f(floor(6))}, see that
27491 this is different from the original formula, simplify to @samp{f(6)},
27492 see that this is the same as the original formula, and thus halt the
27493 rewriting. But while simplifying, @samp{f(6)} will again trigger
27494 the same @code{EvalRules} rule and Calc will get into a loop inside
27495 the rewrite mechanism itself.)
27497 The @code{phase}, @code{schedule}, and @code{iterations} markers do
27498 not work in @code{EvalRules}. If the rule set is divided into phases,
27499 only the phase 1 rules are applied, and the schedule is ignored.
27500 The rules are always repeated as many times as possible.
27502 The @code{EvalRules} are applied to all function calls in a formula,
27503 but not to numbers (and other number-like objects like error forms),
27504 nor to vectors or individual variable names. (Though they will apply
27505 to @emph{components} of vectors and error forms when appropriate.) You
27506 might try to make a variable @code{phihat} which automatically expands
27507 to its definition without the need to press @kbd{=} by writing the
27508 rule @samp{quote(phihat) := (1-sqrt(5))/2}, but unfortunately this rule
27509 will not work as part of @code{EvalRules}.
27511 Finally, another limitation is that Calc sometimes calls its built-in
27512 functions directly rather than going through the default simplifications.
27513 When it does this, @code{EvalRules} will not be able to override those
27514 functions. For example, when you take the absolute value of the complex
27515 number @expr{(2, 3)}, Calc computes @samp{sqrt(2*2 + 3*3)} by calling
27516 the multiplication, addition, and square root functions directly rather
27517 than applying the default simplifications to this formula. So an
27518 @code{EvalRules} rule that (perversely) rewrites @samp{sqrt(13) := 6}
27519 would not apply. (However, if you put Calc into Symbolic mode so that
27520 @samp{sqrt(13)} will be left in symbolic form by the built-in square
27521 root function, your rule will be able to apply. But if the complex
27522 number were @expr{(3,4)}, so that @samp{sqrt(25)} must be calculated,
27523 then Symbolic mode will not help because @samp{sqrt(25)} can be
27524 evaluated exactly to 5.)
27526 One subtle restriction that normally only manifests itself with
27527 @code{EvalRules} is that while a given rewrite rule is in the process
27528 of being checked, that same rule cannot be recursively applied. Calc
27529 effectively removes the rule from its rule set while checking the rule,
27530 then puts it back once the match succeeds or fails. (The technical
27531 reason for this is that compiled pattern programs are not reentrant.)
27532 For example, consider the rule @samp{foo(x) := x :: foo(x/2) > 0}
27533 attempting to match @samp{foo(8)}. This rule will be inactive while
27534 the condition @samp{foo(4) > 0} is checked, even though it might be
27535 an integral part of evaluating that condition. Note that this is not
27536 a problem for the more usual recursive type of rule, such as
27537 @samp{foo(x) := foo(x/2)}, because there the rule has succeeded and
27538 been reactivated by the time the righthand side is evaluated.
27540 If @code{EvalRules} has no stored value (its default state), or if
27541 anything but a vector is stored in it, then it is ignored.
27543 Even though Calc's rewrite mechanism is designed to compare rewrite
27544 rules to formulas as quickly as possible, storing rules in
27545 @code{EvalRules} may make Calc run substantially slower. This is
27546 particularly true of rules where the top-level call is a commonly used
27547 function, or is not fixed. The rule @samp{f(n) := n f(n-1) :: n>0} will
27548 only activate the rewrite mechanism for calls to the function @code{f},
27549 but @samp{lg(n) + lg(m) := lg(n m)} will check every @samp{+} operator.
27552 apply(f, [a*b]) := apply(f, [a]) + apply(f, [b]) :: in(f, [ln, log10])
27556 may seem more ``efficient'' than two separate rules for @code{ln} and
27557 @code{log10}, but actually it is vastly less efficient because rules
27558 with @code{apply} as the top-level pattern must be tested against
27559 @emph{every} function call that is simplified.
27561 @cindex @code{AlgSimpRules} variable
27562 @vindex AlgSimpRules
27563 Suppose you want @samp{sin(a + b)} to be expanded out not all the time,
27564 but only when @kbd{a s} is used to simplify the formula. The variable
27565 @code{AlgSimpRules} holds rules for this purpose. The @kbd{a s} command
27566 will apply @code{EvalRules} and @code{AlgSimpRules} to the formula, as
27567 well as all of its built-in simplifications.
27569 Most of the special limitations for @code{EvalRules} don't apply to
27570 @code{AlgSimpRules}. Calc simply does an @kbd{a r AlgSimpRules}
27571 command with an infinite repeat count as the first step of @kbd{a s}.
27572 It then applies its own built-in simplifications throughout the
27573 formula, and then repeats these two steps (along with applying the
27574 default simplifications) until no further changes are possible.
27576 @cindex @code{ExtSimpRules} variable
27577 @cindex @code{UnitSimpRules} variable
27578 @vindex ExtSimpRules
27579 @vindex UnitSimpRules
27580 There are also @code{ExtSimpRules} and @code{UnitSimpRules} variables
27581 that are used by @kbd{a e} and @kbd{u s}, respectively; these commands
27582 also apply @code{EvalRules} and @code{AlgSimpRules}. The variable
27583 @code{IntegSimpRules} contains simplification rules that are used
27584 only during integration by @kbd{a i}.
27586 @node Debugging Rewrites, Examples of Rewrite Rules, Automatic Rewrites, Rewrite Rules
27587 @subsection Debugging Rewrites
27590 If a buffer named @samp{*Trace*} exists, the rewrite mechanism will
27591 record some useful information there as it operates. The original
27592 formula is written there, as is the result of each successful rewrite,
27593 and the final result of the rewriting. All phase changes are also
27596 Calc always appends to @samp{*Trace*}. You must empty this buffer
27597 yourself periodically if it is in danger of growing unwieldy.
27599 Note that the rewriting mechanism is substantially slower when the
27600 @samp{*Trace*} buffer exists, even if the buffer is not visible on
27601 the screen. Once you are done, you will probably want to kill this
27602 buffer (with @kbd{C-x k *Trace* @key{RET}}). If you leave it in
27603 existence and forget about it, all your future rewrite commands will
27604 be needlessly slow.
27606 @node Examples of Rewrite Rules, , Debugging Rewrites, Rewrite Rules
27607 @subsection Examples of Rewrite Rules
27610 Returning to the example of substituting the pattern
27611 @samp{sin(x)^2 + cos(x)^2} with 1, we saw that the rule
27612 @samp{opt(a) sin(x)^2 + opt(a) cos(x)^2 := a} does a good job of
27613 finding suitable cases. Another solution would be to use the rule
27614 @samp{cos(x)^2 := 1 - sin(x)^2}, followed by algebraic simplification
27615 if necessary. This rule will be the most effective way to do the job,
27616 but at the expense of making some changes that you might not desire.
27618 Another algebraic rewrite rule is @samp{exp(x+y) := exp(x) exp(y)}.
27619 To make this work with the @w{@kbd{j r}} command so that it can be
27620 easily targeted to a particular exponential in a large formula,
27621 you might wish to write the rule as @samp{select(exp(x+y)) :=
27622 select(exp(x) exp(y))}. The @samp{select} markers will be
27623 ignored by the regular @kbd{a r} command
27624 (@pxref{Selections with Rewrite Rules}).
27626 A surprisingly useful rewrite rule is @samp{a/(b-c) := a*(b+c)/(b^2-c^2)}.
27627 This will simplify the formula whenever @expr{b} and/or @expr{c} can
27628 be made simpler by squaring. For example, applying this rule to
27629 @samp{2 / (sqrt(2) + 3)} yields @samp{6:7 - 2:7 sqrt(2)} (assuming
27630 Symbolic mode has been enabled to keep the square root from being
27631 evaluated to a floating-point approximation). This rule is also
27632 useful when working with symbolic complex numbers, e.g.,
27633 @samp{(a + b i) / (c + d i)}.
27635 As another example, we could define our own ``triangular numbers'' function
27636 with the rules @samp{[tri(0) := 0, tri(n) := n + tri(n-1) :: n>0]}. Enter
27637 this vector and store it in a variable: @kbd{@w{s t} trirules}. Now, given
27638 a suitable formula like @samp{tri(5)} on the stack, type @samp{a r trirules}
27639 to apply these rules repeatedly. After six applications, @kbd{a r} will
27640 stop with 15 on the stack. Once these rules are debugged, it would probably
27641 be most useful to add them to @code{EvalRules} so that Calc will evaluate
27642 the new @code{tri} function automatically. We could then use @kbd{Z K} on
27643 the keyboard macro @kbd{' tri($) @key{RET}} to make a command that applies
27644 @code{tri} to the value on the top of the stack. @xref{Programming}.
27646 @cindex Quaternions
27647 The following rule set, contributed by
27648 @texline Fran\c cois
27650 Pinard, implements @dfn{quaternions}, a generalization of the concept of
27651 complex numbers. Quaternions have four components, and are here
27652 represented by function calls @samp{quat(@var{w}, [@var{x}, @var{y},
27653 @var{z}])} with ``real part'' @var{w} and the three ``imaginary'' parts
27654 collected into a vector. Various arithmetical operations on quaternions
27655 are supported. To use these rules, either add them to @code{EvalRules},
27656 or create a command based on @kbd{a r} for simplifying quaternion
27657 formulas. A convenient way to enter quaternions would be a command
27658 defined by a keyboard macro containing: @kbd{' quat($$$$, [$$$, $$, $])
27662 [ quat(w, x, y, z) := quat(w, [x, y, z]),
27663 quat(w, [0, 0, 0]) := w,
27664 abs(quat(w, v)) := hypot(w, v),
27665 -quat(w, v) := quat(-w, -v),
27666 r + quat(w, v) := quat(r + w, v) :: real(r),
27667 r - quat(w, v) := quat(r - w, -v) :: real(r),
27668 quat(w1, v1) + quat(w2, v2) := quat(w1 + w2, v1 + v2),
27669 r * quat(w, v) := quat(r * w, r * v) :: real(r),
27670 plain(quat(w1, v1) * quat(w2, v2))
27671 := quat(w1 * w2 - v1 * v2, w1 * v2 + w2 * v1 + cross(v1, v2)),
27672 quat(w1, v1) / r := quat(w1 / r, v1 / r) :: real(r),
27673 z / quat(w, v) := z * quatinv(quat(w, v)),
27674 quatinv(quat(w, v)) := quat(w, -v) / (w^2 + v^2),
27675 quatsqr(quat(w, v)) := quat(w^2 - v^2, 2 * w * v),
27676 quat(w, v)^k := quatsqr(quat(w, v)^(k / 2))
27677 :: integer(k) :: k > 0 :: k % 2 = 0,
27678 quat(w, v)^k := quatsqr(quat(w, v)^((k - 1) / 2)) * quat(w, v)
27679 :: integer(k) :: k > 2,
27680 quat(w, v)^-k := quatinv(quat(w, v)^k) :: integer(k) :: k > 0 ]
27683 Quaternions, like matrices, have non-commutative multiplication.
27684 In other words, @expr{q1 * q2 = q2 * q1} is not necessarily true if
27685 @expr{q1} and @expr{q2} are @code{quat} forms. The @samp{quat*quat}
27686 rule above uses @code{plain} to prevent Calc from rearranging the
27687 product. It may also be wise to add the line @samp{[quat(), matrix]}
27688 to the @code{Decls} matrix, to ensure that Calc's other algebraic
27689 operations will not rearrange a quaternion product. @xref{Declarations}.
27691 These rules also accept a four-argument @code{quat} form, converting
27692 it to the preferred form in the first rule. If you would rather see
27693 results in the four-argument form, just append the two items
27694 @samp{phase(2), quat(w, [x, y, z]) := quat(w, x, y, z)} to the end
27695 of the rule set. (But remember that multi-phase rule sets don't work
27696 in @code{EvalRules}.)
27698 @node Units, Store and Recall, Algebra, Top
27699 @chapter Operating on Units
27702 One special interpretation of algebraic formulas is as numbers with units.
27703 For example, the formula @samp{5 m / s^2} can be read ``five meters
27704 per second squared.'' The commands in this chapter help you
27705 manipulate units expressions in this form. Units-related commands
27706 begin with the @kbd{u} prefix key.
27709 * Basic Operations on Units::
27710 * The Units Table::
27711 * Predefined Units::
27712 * User-Defined Units::
27715 @node Basic Operations on Units, The Units Table, Units, Units
27716 @section Basic Operations on Units
27719 A @dfn{units expression} is a formula which is basically a number
27720 multiplied and/or divided by one or more @dfn{unit names}, which may
27721 optionally be raised to integer powers. Actually, the value part need not
27722 be a number; any product or quotient involving unit names is a units
27723 expression. Many of the units commands will also accept any formula,
27724 where the command applies to all units expressions which appear in the
27727 A unit name is a variable whose name appears in the @dfn{unit table},
27728 or a variable whose name is a prefix character like @samp{k} (for ``kilo'')
27729 or @samp{u} (for ``micro'') followed by a name in the unit table.
27730 A substantial table of built-in units is provided with Calc;
27731 @pxref{Predefined Units}. You can also define your own unit names;
27732 @pxref{User-Defined Units}.
27734 Note that if the value part of a units expression is exactly @samp{1},
27735 it will be removed by the Calculator's automatic algebra routines: The
27736 formula @samp{1 mm} is ``simplified'' to @samp{mm}. This is only a
27737 display anomaly, however; @samp{mm} will work just fine as a
27738 representation of one millimeter.
27740 You may find that Algebraic mode (@pxref{Algebraic Entry}) makes working
27741 with units expressions easier. Otherwise, you will have to remember
27742 to hit the apostrophe key every time you wish to enter units.
27745 @pindex calc-simplify-units
27747 @mindex usimpl@idots
27750 The @kbd{u s} (@code{calc-simplify-units}) [@code{usimplify}] command
27752 expression. It uses @kbd{a s} (@code{calc-simplify}) to simplify the
27753 expression first as a regular algebraic formula; it then looks for
27754 features that can be further simplified by converting one object's units
27755 to be compatible with another's. For example, @samp{5 m + 23 mm} will
27756 simplify to @samp{5.023 m}. When different but compatible units are
27757 added, the righthand term's units are converted to match those of the
27758 lefthand term. @xref{Simplification Modes}, for a way to have this done
27759 automatically at all times.
27761 Units simplification also handles quotients of two units with the same
27762 dimensionality, as in @w{@samp{2 in s/L cm}} to @samp{5.08 s/L}; fractional
27763 powers of unit expressions, as in @samp{sqrt(9 mm^2)} to @samp{3 mm} and
27764 @samp{sqrt(9 acre)} to a quantity in meters; and @code{floor},
27765 @code{ceil}, @code{round}, @code{rounde}, @code{roundu}, @code{trunc},
27766 @code{float}, @code{frac}, @code{abs}, and @code{clean}
27767 applied to units expressions, in which case
27768 the operation in question is applied only to the numeric part of the
27769 expression. Finally, trigonometric functions of quantities with units
27770 of angle are evaluated, regardless of the current angular mode.
27773 @pindex calc-convert-units
27774 The @kbd{u c} (@code{calc-convert-units}) command converts a units
27775 expression to new, compatible units. For example, given the units
27776 expression @samp{55 mph}, typing @kbd{u c m/s @key{RET}} produces
27777 @samp{24.5872 m/s}. If the units you request are inconsistent with
27778 the original units, the number will be converted into your units
27779 times whatever ``remainder'' units are left over. For example,
27780 converting @samp{55 mph} into acres produces @samp{6.08e-3 acre / m s}.
27781 (Recall that multiplication binds more strongly than division in Calc
27782 formulas, so the units here are acres per meter-second.) Remainder
27783 units are expressed in terms of ``fundamental'' units like @samp{m} and
27784 @samp{s}, regardless of the input units.
27786 One special exception is that if you specify a single unit name, and
27787 a compatible unit appears somewhere in the units expression, then
27788 that compatible unit will be converted to the new unit and the
27789 remaining units in the expression will be left alone. For example,
27790 given the input @samp{980 cm/s^2}, the command @kbd{u c ms} will
27791 change the @samp{s} to @samp{ms} to get @samp{9.8e-4 cm/ms^2}.
27792 The ``remainder unit'' @samp{cm} is left alone rather than being
27793 changed to the base unit @samp{m}.
27795 You can use explicit unit conversion instead of the @kbd{u s} command
27796 to gain more control over the units of the result of an expression.
27797 For example, given @samp{5 m + 23 mm}, you can type @kbd{u c m} or
27798 @kbd{u c mm} to express the result in either meters or millimeters.
27799 (For that matter, you could type @kbd{u c fath} to express the result
27800 in fathoms, if you preferred!)
27802 In place of a specific set of units, you can also enter one of the
27803 units system names @code{si}, @code{mks} (equivalent), or @code{cgs}.
27804 For example, @kbd{u c si @key{RET}} converts the expression into
27805 International System of Units (SI) base units. Also, @kbd{u c base}
27806 converts to Calc's base units, which are the same as @code{si} units
27807 except that @code{base} uses @samp{g} as the fundamental unit of mass
27808 whereas @code{si} uses @samp{kg}.
27810 @cindex Composite units
27811 The @kbd{u c} command also accepts @dfn{composite units}, which
27812 are expressed as the sum of several compatible unit names. For
27813 example, converting @samp{30.5 in} to units @samp{mi+ft+in} (miles,
27814 feet, and inches) produces @samp{2 ft + 6.5 in}. Calc first
27815 sorts the unit names into order of decreasing relative size.
27816 It then accounts for as much of the input quantity as it can
27817 using an integer number times the largest unit, then moves on
27818 to the next smaller unit, and so on. Only the smallest unit
27819 may have a non-integer amount attached in the result. A few
27820 standard unit names exist for common combinations, such as
27821 @code{mfi} for @samp{mi+ft+in}, and @code{tpo} for @samp{ton+lb+oz}.
27822 Composite units are expanded as if by @kbd{a x}, so that
27823 @samp{(ft+in)/hr} is first converted to @samp{ft/hr+in/hr}.
27825 If the value on the stack does not contain any units, @kbd{u c} will
27826 prompt first for the old units which this value should be considered
27827 to have, then for the new units. Assuming the old and new units you
27828 give are consistent with each other, the result also will not contain
27829 any units. For example, @kbd{@w{u c} cm @key{RET} in @key{RET}} converts the number
27830 2 on the stack to 5.08.
27833 @pindex calc-base-units
27834 The @kbd{u b} (@code{calc-base-units}) command is shorthand for
27835 @kbd{u c base}; it converts the units expression on the top of the
27836 stack into @code{base} units. If @kbd{u s} does not simplify a
27837 units expression as far as you would like, try @kbd{u b}.
27839 The @kbd{u c} and @kbd{u b} commands treat temperature units (like
27840 @samp{degC} and @samp{K}) as relative temperatures. For example,
27841 @kbd{u c} converts @samp{10 degC} to @samp{18 degF}: A change of 10
27842 degrees Celsius corresponds to a change of 18 degrees Fahrenheit.
27845 @pindex calc-convert-temperature
27846 @cindex Temperature conversion
27847 The @kbd{u t} (@code{calc-convert-temperature}) command converts
27848 absolute temperatures. The value on the stack must be a simple units
27849 expression with units of temperature only. This command would convert
27850 @samp{10 degC} to @samp{50 degF}, the equivalent temperature on the
27854 @pindex calc-remove-units
27856 @pindex calc-extract-units
27857 The @kbd{u r} (@code{calc-remove-units}) command removes units from the
27858 formula at the top of the stack. The @kbd{u x}
27859 (@code{calc-extract-units}) command extracts only the units portion of a
27860 formula. These commands essentially replace every term of the formula
27861 that does or doesn't (respectively) look like a unit name by the
27862 constant 1, then resimplify the formula.
27865 @pindex calc-autorange-units
27866 The @kbd{u a} (@code{calc-autorange-units}) command turns on and off a
27867 mode in which unit prefixes like @code{k} (``kilo'') are automatically
27868 applied to keep the numeric part of a units expression in a reasonable
27869 range. This mode affects @kbd{u s} and all units conversion commands
27870 except @kbd{u b}. For example, with autoranging on, @samp{12345 Hz}
27871 will be simplified to @samp{12.345 kHz}. Autoranging is useful for
27872 some kinds of units (like @code{Hz} and @code{m}), but is probably
27873 undesirable for non-metric units like @code{ft} and @code{tbsp}.
27874 (Composite units are more appropriate for those; see above.)
27876 Autoranging always applies the prefix to the leftmost unit name.
27877 Calc chooses the largest prefix that causes the number to be greater
27878 than or equal to 1.0. Thus an increasing sequence of adjusted times
27879 would be @samp{1 ms, 10 ms, 100 ms, 1 s, 10 s, 100 s, 1 ks}.
27880 Generally the rule of thumb is that the number will be adjusted
27881 to be in the interval @samp{[1 .. 1000)}, although there are several
27882 exceptions to this rule. First, if the unit has a power then this
27883 is not possible; @samp{0.1 s^2} simplifies to @samp{100000 ms^2}.
27884 Second, the ``centi-'' prefix is allowed to form @code{cm} (centimeters),
27885 but will not apply to other units. The ``deci-,'' ``deka-,'' and
27886 ``hecto-'' prefixes are never used. Thus the allowable interval is
27887 @samp{[1 .. 10)} for millimeters and @samp{[1 .. 100)} for centimeters.
27888 Finally, a prefix will not be added to a unit if the resulting name
27889 is also the actual name of another unit; @samp{1e-15 t} would normally
27890 be considered a ``femto-ton,'' but it is written as @samp{1000 at}
27891 (1000 atto-tons) instead because @code{ft} would be confused with feet.
27893 @node The Units Table, Predefined Units, Basic Operations on Units, Units
27894 @section The Units Table
27898 @pindex calc-enter-units-table
27899 The @kbd{u v} (@code{calc-enter-units-table}) command displays the units table
27900 in another buffer called @code{*Units Table*}. Each entry in this table
27901 gives the unit name as it would appear in an expression, the definition
27902 of the unit in terms of simpler units, and a full name or description of
27903 the unit. Fundamental units are defined as themselves; these are the
27904 units produced by the @kbd{u b} command. The fundamental units are
27905 meters, seconds, grams, kelvins, amperes, candelas, moles, radians,
27908 The Units Table buffer also displays the Unit Prefix Table. Note that
27909 two prefixes, ``kilo'' and ``hecto,'' accept either upper- or lower-case
27910 prefix letters. @samp{Meg} is also accepted as a synonym for the @samp{M}
27911 prefix. Whenever a unit name can be interpreted as either a built-in name
27912 or a prefix followed by another built-in name, the former interpretation
27913 wins. For example, @samp{2 pt} means two pints, not two pico-tons.
27915 The Units Table buffer, once created, is not rebuilt unless you define
27916 new units. To force the buffer to be rebuilt, give any numeric prefix
27917 argument to @kbd{u v}.
27920 @pindex calc-view-units-table
27921 The @kbd{u V} (@code{calc-view-units-table}) command is like @kbd{u v} except
27922 that the cursor is not moved into the Units Table buffer. You can
27923 type @kbd{u V} again to remove the Units Table from the display. To
27924 return from the Units Table buffer after a @kbd{u v}, type @kbd{M-# c}
27925 again or use the regular Emacs @w{@kbd{C-x o}} (@code{other-window})
27926 command. You can also kill the buffer with @kbd{C-x k} if you wish;
27927 the actual units table is safely stored inside the Calculator.
27930 @pindex calc-get-unit-definition
27931 The @kbd{u g} (@code{calc-get-unit-definition}) command retrieves a unit's
27932 defining expression and pushes it onto the Calculator stack. For example,
27933 @kbd{u g in} will produce the expression @samp{2.54 cm}. This is the
27934 same definition for the unit that would appear in the Units Table buffer.
27935 Note that this command works only for actual unit names; @kbd{u g km}
27936 will report that no such unit exists, for example, because @code{km} is
27937 really the unit @code{m} with a @code{k} (``kilo'') prefix. To see a
27938 definition of a unit in terms of base units, it is easier to push the
27939 unit name on the stack and then reduce it to base units with @kbd{u b}.
27942 @pindex calc-explain-units
27943 The @kbd{u e} (@code{calc-explain-units}) command displays an English
27944 description of the units of the expression on the stack. For example,
27945 for the expression @samp{62 km^2 g / s^2 mol K}, the description is
27946 ``Square-Kilometer Gram per (Second-squared Mole Degree-Kelvin).'' This
27947 command uses the English descriptions that appear in the righthand
27948 column of the Units Table.
27950 @node Predefined Units, User-Defined Units, The Units Table, Units
27951 @section Predefined Units
27954 Since the exact definitions of many kinds of units have evolved over the
27955 years, and since certain countries sometimes have local differences in
27956 their definitions, it is a good idea to examine Calc's definition of a
27957 unit before depending on its exact value. For example, there are three
27958 different units for gallons, corresponding to the US (@code{gal}),
27959 Canadian (@code{galC}), and British (@code{galUK}) definitions. Also,
27960 note that @code{oz} is a standard ounce of mass, @code{ozt} is a Troy
27961 ounce, and @code{ozfl} is a fluid ounce.
27963 The temperature units corresponding to degrees Kelvin and Centigrade
27964 (Celsius) are the same in this table, since most units commands treat
27965 temperatures as being relative. The @code{calc-convert-temperature}
27966 command has special rules for handling the different absolute magnitudes
27967 of the various temperature scales.
27969 The unit of volume ``liters'' can be referred to by either the lower-case
27970 @code{l} or the upper-case @code{L}.
27972 The unit @code{A} stands for Amperes; the name @code{Ang} is used
27980 The unit @code{pt} stands for pints; the name @code{point} stands for
27981 a typographical point, defined by @samp{72 point = 1 in}. There is
27982 also @code{tpt}, which stands for a printer's point as defined by the
27983 @TeX{} typesetting system: @samp{72.27 tpt = 1 in}.
27985 The unit @code{e} stands for the elementary (electron) unit of charge;
27986 because algebra command could mistake this for the special constant
27987 @expr{e}, Calc provides the alternate unit name @code{ech} which is
27988 preferable to @code{e}.
27990 The name @code{g} stands for one gram of mass; there is also @code{gf},
27991 one gram of force. (Likewise for @kbd{lb}, pounds, and @kbd{lbf}.)
27992 Meanwhile, one ``@expr{g}'' of acceleration is denoted @code{ga}.
27994 The unit @code{ton} is a U.S. ton of @samp{2000 lb}, and @code{t} is
27995 a metric ton of @samp{1000 kg}.
27997 The names @code{s} (or @code{sec}) and @code{min} refer to units of
27998 time; @code{arcsec} and @code{arcmin} are units of angle.
28000 Some ``units'' are really physical constants; for example, @code{c}
28001 represents the speed of light, and @code{h} represents Planck's
28002 constant. You can use these just like other units: converting
28003 @samp{.5 c} to @samp{m/s} expresses one-half the speed of light in
28004 meters per second. You can also use this merely as a handy reference;
28005 the @kbd{u g} command gets the definition of one of these constants
28006 in its normal terms, and @kbd{u b} expresses the definition in base
28009 Two units, @code{pi} and @code{fsc} (the fine structure constant,
28010 approximately @mathit{1/137}) are dimensionless. The units simplification
28011 commands simply treat these names as equivalent to their corresponding
28012 values. However you can, for example, use @kbd{u c} to convert a pure
28013 number into multiples of the fine structure constant, or @kbd{u b} to
28014 convert this back into a pure number. (When @kbd{u c} prompts for the
28015 ``old units,'' just enter a blank line to signify that the value
28016 really is unitless.)
28018 @c Describe angular units, luminosity vs. steradians problem.
28020 @node User-Defined Units, , Predefined Units, Units
28021 @section User-Defined Units
28024 Calc provides ways to get quick access to your selected ``favorite''
28025 units, as well as ways to define your own new units.
28028 @pindex calc-quick-units
28030 @cindex @code{Units} variable
28031 @cindex Quick units
28032 To select your favorite units, store a vector of unit names or
28033 expressions in the Calc variable @code{Units}. The @kbd{u 1}
28034 through @kbd{u 9} commands (@code{calc-quick-units}) provide access
28035 to these units. If the value on the top of the stack is a plain
28036 number (with no units attached), then @kbd{u 1} gives it the
28037 specified units. (Basically, it multiplies the number by the
28038 first item in the @code{Units} vector.) If the number on the
28039 stack @emph{does} have units, then @kbd{u 1} converts that number
28040 to the new units. For example, suppose the vector @samp{[in, ft]}
28041 is stored in @code{Units}. Then @kbd{30 u 1} will create the
28042 expression @samp{30 in}, and @kbd{u 2} will convert that expression
28045 The @kbd{u 0} command accesses the tenth element of @code{Units}.
28046 Only ten quick units may be defined at a time. If the @code{Units}
28047 variable has no stored value (the default), or if its value is not
28048 a vector, then the quick-units commands will not function. The
28049 @kbd{s U} command is a convenient way to edit the @code{Units}
28050 variable; @pxref{Operations on Variables}.
28053 @pindex calc-define-unit
28054 @cindex User-defined units
28055 The @kbd{u d} (@code{calc-define-unit}) command records the units
28056 expression on the top of the stack as the definition for a new,
28057 user-defined unit. For example, putting @samp{16.5 ft} on the stack and
28058 typing @kbd{u d rod} defines the new unit @samp{rod} to be equivalent to
28059 16.5 feet. The unit conversion and simplification commands will now
28060 treat @code{rod} just like any other unit of length. You will also be
28061 prompted for an optional English description of the unit, which will
28062 appear in the Units Table.
28065 @pindex calc-undefine-unit
28066 The @kbd{u u} (@code{calc-undefine-unit}) command removes a user-defined
28067 unit. It is not possible to remove one of the predefined units,
28070 If you define a unit with an existing unit name, your new definition
28071 will replace the original definition of that unit. If the unit was a
28072 predefined unit, the old definition will not be replaced, only
28073 ``shadowed.'' The built-in definition will reappear if you later use
28074 @kbd{u u} to remove the shadowing definition.
28076 To create a new fundamental unit, use either 1 or the unit name itself
28077 as the defining expression. Otherwise the expression can involve any
28078 other units that you like (except for composite units like @samp{mfi}).
28079 You can create a new composite unit with a sum of other units as the
28080 defining expression. The next unit operation like @kbd{u c} or @kbd{u v}
28081 will rebuild the internal unit table incorporating your modifications.
28082 Note that erroneous definitions (such as two units defined in terms of
28083 each other) will not be detected until the unit table is next rebuilt;
28084 @kbd{u v} is a convenient way to force this to happen.
28086 Temperature units are treated specially inside the Calculator; it is not
28087 possible to create user-defined temperature units.
28090 @pindex calc-permanent-units
28091 @cindex Calc init file, user-defined units
28092 The @kbd{u p} (@code{calc-permanent-units}) command stores the user-defined
28093 units in your Calc init file (the file given by the variable
28094 @code{calc-settings-file}, typically @file{~/.calc.el}), so that the
28095 units will still be available in subsequent Emacs sessions. If there
28096 was already a set of user-defined units in your Calc init file, it
28097 is replaced by the new set. (@xref{General Mode Commands}, for a way to
28098 tell Calc to use a different file for the Calc init file.)
28100 @node Store and Recall, Graphics, Units, Top
28101 @chapter Storing and Recalling
28104 Calculator variables are really just Lisp variables that contain numbers
28105 or formulas in a form that Calc can understand. The commands in this
28106 section allow you to manipulate variables conveniently. Commands related
28107 to variables use the @kbd{s} prefix key.
28110 * Storing Variables::
28111 * Recalling Variables::
28112 * Operations on Variables::
28114 * Evaluates-To Operator::
28117 @node Storing Variables, Recalling Variables, Store and Recall, Store and Recall
28118 @section Storing Variables
28123 @cindex Storing variables
28124 @cindex Quick variables
28127 The @kbd{s s} (@code{calc-store}) command stores the value at the top of
28128 the stack into a specified variable. It prompts you to enter the
28129 name of the variable. If you press a single digit, the value is stored
28130 immediately in one of the ``quick'' variables @code{q0} through
28131 @code{q9}. Or you can enter any variable name.
28134 @pindex calc-store-into
28135 The @kbd{s s} command leaves the stored value on the stack. There is
28136 also an @kbd{s t} (@code{calc-store-into}) command, which removes a
28137 value from the stack and stores it in a variable.
28139 If the top of stack value is an equation @samp{a = 7} or assignment
28140 @samp{a := 7} with a variable on the lefthand side, then Calc will
28141 assign that variable with that value by default, i.e., if you type
28142 @kbd{s s @key{RET}} or @kbd{s t @key{RET}}. In this example, the
28143 value 7 would be stored in the variable @samp{a}. (If you do type
28144 a variable name at the prompt, the top-of-stack value is stored in
28145 its entirety, even if it is an equation: @samp{s s b @key{RET}}
28146 with @samp{a := 7} on the stack stores @samp{a := 7} in @code{b}.)
28148 In fact, the top of stack value can be a vector of equations or
28149 assignments with different variables on their lefthand sides; the
28150 default will be to store all the variables with their corresponding
28151 righthand sides simultaneously.
28153 It is also possible to type an equation or assignment directly at
28154 the prompt for the @kbd{s s} or @kbd{s t} command: @kbd{s s foo = 7}.
28155 In this case the expression to the right of the @kbd{=} or @kbd{:=}
28156 symbol is evaluated as if by the @kbd{=} command, and that value is
28157 stored in the variable. No value is taken from the stack; @kbd{s s}
28158 and @kbd{s t} are equivalent when used in this way.
28162 The prefix keys @kbd{s} and @kbd{t} may be followed immediately by a
28163 digit; @kbd{s 9} is equivalent to @kbd{s s 9}, and @kbd{t 9} is
28164 equivalent to @kbd{s t 9}. (The @kbd{t} prefix is otherwise used
28165 for trail and time/date commands.)
28201 @pindex calc-store-plus
28202 @pindex calc-store-minus
28203 @pindex calc-store-times
28204 @pindex calc-store-div
28205 @pindex calc-store-power
28206 @pindex calc-store-concat
28207 @pindex calc-store-neg
28208 @pindex calc-store-inv
28209 @pindex calc-store-decr
28210 @pindex calc-store-incr
28211 There are also several ``arithmetic store'' commands. For example,
28212 @kbd{s +} removes a value from the stack and adds it to the specified
28213 variable. The other arithmetic stores are @kbd{s -}, @kbd{s *}, @kbd{s /},
28214 @kbd{s ^}, and @w{@kbd{s |}} (vector concatenation), plus @kbd{s n} and
28215 @kbd{s &} which negate or invert the value in a variable, and @w{@kbd{s [}}
28216 and @kbd{s ]} which decrease or increase a variable by one.
28218 All the arithmetic stores accept the Inverse prefix to reverse the
28219 order of the operands. If @expr{v} represents the contents of the
28220 variable, and @expr{a} is the value drawn from the stack, then regular
28221 @w{@kbd{s -}} assigns
28222 @texline @math{v \coloneq v - a},
28223 @infoline @expr{v := v - a},
28224 but @kbd{I s -} assigns
28225 @texline @math{v \coloneq a - v}.
28226 @infoline @expr{v := a - v}.
28227 While @kbd{I s *} might seem pointless, it is
28228 useful if matrix multiplication is involved. Actually, all the
28229 arithmetic stores use formulas designed to behave usefully both
28230 forwards and backwards:
28234 s + v := v + a v := a + v
28235 s - v := v - a v := a - v
28236 s * v := v * a v := a * v
28237 s / v := v / a v := a / v
28238 s ^ v := v ^ a v := a ^ v
28239 s | v := v | a v := a | v
28240 s n v := v / (-1) v := (-1) / v
28241 s & v := v ^ (-1) v := (-1) ^ v
28242 s [ v := v - 1 v := 1 - v
28243 s ] v := v - (-1) v := (-1) - v
28247 In the last four cases, a numeric prefix argument will be used in
28248 place of the number one. (For example, @kbd{M-2 s ]} increases
28249 a variable by 2, and @kbd{M-2 I s ]} replaces a variable by
28250 minus-two minus the variable.
28252 The first six arithmetic stores can also be typed @kbd{s t +}, @kbd{s t -},
28253 etc. The commands @kbd{s s +}, @kbd{s s -}, and so on are analogous
28254 arithmetic stores that don't remove the value @expr{a} from the stack.
28256 All arithmetic stores report the new value of the variable in the
28257 Trail for your information. They signal an error if the variable
28258 previously had no stored value. If default simplifications have been
28259 turned off, the arithmetic stores temporarily turn them on for numeric
28260 arguments only (i.e., they temporarily do an @kbd{m N} command).
28261 @xref{Simplification Modes}. Large vectors put in the trail by
28262 these commands always use abbreviated (@kbd{t .}) mode.
28265 @pindex calc-store-map
28266 The @kbd{s m} command is a general way to adjust a variable's value
28267 using any Calc function. It is a ``mapping'' command analogous to
28268 @kbd{V M}, @kbd{V R}, etc. @xref{Reducing and Mapping}, to see
28269 how to specify a function for a mapping command. Basically,
28270 all you do is type the Calc command key that would invoke that
28271 function normally. For example, @kbd{s m n} applies the @kbd{n}
28272 key to negate the contents of the variable, so @kbd{s m n} is
28273 equivalent to @kbd{s n}. Also, @kbd{s m Q} takes the square root
28274 of the value stored in a variable, @kbd{s m v v} uses @kbd{v v} to
28275 reverse the vector stored in the variable, and @kbd{s m H I S}
28276 takes the hyperbolic arcsine of the variable contents.
28278 If the mapping function takes two or more arguments, the additional
28279 arguments are taken from the stack; the old value of the variable
28280 is provided as the first argument. Thus @kbd{s m -} with @expr{a}
28281 on the stack computes @expr{v - a}, just like @kbd{s -}. With the
28282 Inverse prefix, the variable's original value becomes the @emph{last}
28283 argument instead of the first. Thus @kbd{I s m -} is also
28284 equivalent to @kbd{I s -}.
28287 @pindex calc-store-exchange
28288 The @kbd{s x} (@code{calc-store-exchange}) command exchanges the value
28289 of a variable with the value on the top of the stack. Naturally, the
28290 variable must already have a stored value for this to work.
28292 You can type an equation or assignment at the @kbd{s x} prompt. The
28293 command @kbd{s x a=6} takes no values from the stack; instead, it
28294 pushes the old value of @samp{a} on the stack and stores @samp{a = 6}.
28297 @pindex calc-unstore
28298 @cindex Void variables
28299 @cindex Un-storing variables
28300 Until you store something in them, most variables are ``void,'' that is,
28301 they contain no value at all. If they appear in an algebraic formula
28302 they will be left alone even if you press @kbd{=} (@code{calc-evaluate}).
28303 The @kbd{s u} (@code{calc-unstore}) command returns a variable to the
28307 @pindex calc-copy-variable
28308 The @kbd{s c} (@code{calc-copy-variable}) command copies the stored
28309 value of one variable to another. One way it differs from a simple
28310 @kbd{s r} followed by an @kbd{s t} (aside from saving keystrokes) is
28311 that the value never goes on the stack and thus is never rounded,
28312 evaluated, or simplified in any way; it is not even rounded down to the
28315 The only variables with predefined values are the ``special constants''
28316 @code{pi}, @code{e}, @code{i}, @code{phi}, and @code{gamma}. You are free
28317 to unstore these variables or to store new values into them if you like,
28318 although some of the algebraic-manipulation functions may assume these
28319 variables represent their standard values. Calc displays a warning if
28320 you change the value of one of these variables, or of one of the other
28321 special variables @code{inf}, @code{uinf}, and @code{nan} (which are
28324 Note that @code{pi} doesn't actually have 3.14159265359 stored in it,
28325 but rather a special magic value that evaluates to @cpi{} at the current
28326 precision. Likewise @code{e}, @code{i}, and @code{phi} evaluate
28327 according to the current precision or polar mode. If you recall a value
28328 from @code{pi} and store it back, this magic property will be lost. The
28329 magic property is preserved, however, when a variable is copied with
28333 @pindex calc-copy-special-constant
28334 If one of the ``special constants'' is redefined (or undefined) so that
28335 it no longer has its magic property, the property can be restored with
28336 @kbd{s k} (@code{calc-copy-special-constant}). This command will prompt
28337 for a special constant and a variable to store it in, and so a special
28338 constant can be stored in any variable. Here, the special constant that
28339 you enter doesn't depend on the value of the corresponding variable;
28340 @code{pi} will represent 3.14159@dots{} regardless of what is currently
28341 stored in the Calc variable @code{pi}. If one of the other special
28342 variables, @code{inf}, @code{uinf} or @code{nan}, is given a value, its
28343 original behavior can be restored by voiding it with @kbd{s u}.
28345 @node Recalling Variables, Operations on Variables, Storing Variables, Store and Recall
28346 @section Recalling Variables
28350 @pindex calc-recall
28351 @cindex Recalling variables
28352 The most straightforward way to extract the stored value from a variable
28353 is to use the @kbd{s r} (@code{calc-recall}) command. This command prompts
28354 for a variable name (similarly to @code{calc-store}), looks up the value
28355 of the specified variable, and pushes that value onto the stack. It is
28356 an error to try to recall a void variable.
28358 It is also possible to recall the value from a variable by evaluating a
28359 formula containing that variable. For example, @kbd{' a @key{RET} =} is
28360 the same as @kbd{s r a @key{RET}} except that if the variable is void, the
28361 former will simply leave the formula @samp{a} on the stack whereas the
28362 latter will produce an error message.
28365 The @kbd{r} prefix may be followed by a digit, so that @kbd{r 9} is
28366 equivalent to @kbd{s r 9}. (The @kbd{r} prefix is otherwise unused
28367 in the current version of Calc.)
28369 @node Operations on Variables, Let Command, Recalling Variables, Store and Recall
28370 @section Other Operations on Variables
28374 @pindex calc-edit-variable
28375 The @kbd{s e} (@code{calc-edit-variable}) command edits the stored
28376 value of a variable without ever putting that value on the stack
28377 or simplifying or evaluating the value. It prompts for the name of
28378 the variable to edit. If the variable has no stored value, the
28379 editing buffer will start out empty. If the editing buffer is
28380 empty when you press @kbd{C-c C-c} to finish, the variable will
28381 be made void. @xref{Editing Stack Entries}, for a general
28382 description of editing.
28384 The @kbd{s e} command is especially useful for creating and editing
28385 rewrite rules which are stored in variables. Sometimes these rules
28386 contain formulas which must not be evaluated until the rules are
28387 actually used. (For example, they may refer to @samp{deriv(x,y)},
28388 where @code{x} will someday become some expression involving @code{y};
28389 if you let Calc evaluate the rule while you are defining it, Calc will
28390 replace @samp{deriv(x,y)} with 0 because the formula @code{x} does
28391 not itself refer to @code{y}.) By contrast, recalling the variable,
28392 editing with @kbd{`}, and storing will evaluate the variable's value
28393 as a side effect of putting the value on the stack.
28441 @pindex calc-store-AlgSimpRules
28442 @pindex calc-store-Decls
28443 @pindex calc-store-EvalRules
28444 @pindex calc-store-FitRules
28445 @pindex calc-store-GenCount
28446 @pindex calc-store-Holidays
28447 @pindex calc-store-IntegLimit
28448 @pindex calc-store-LineStyles
28449 @pindex calc-store-PointStyles
28450 @pindex calc-store-PlotRejects
28451 @pindex calc-store-TimeZone
28452 @pindex calc-store-Units
28453 @pindex calc-store-ExtSimpRules
28454 There are several special-purpose variable-editing commands that
28455 use the @kbd{s} prefix followed by a shifted letter:
28459 Edit @code{AlgSimpRules}. @xref{Algebraic Simplifications}.
28461 Edit @code{Decls}. @xref{Declarations}.
28463 Edit @code{EvalRules}. @xref{Default Simplifications}.
28465 Edit @code{FitRules}. @xref{Curve Fitting}.
28467 Edit @code{GenCount}. @xref{Solving Equations}.
28469 Edit @code{Holidays}. @xref{Business Days}.
28471 Edit @code{IntegLimit}. @xref{Calculus}.
28473 Edit @code{LineStyles}. @xref{Graphics}.
28475 Edit @code{PointStyles}. @xref{Graphics}.
28477 Edit @code{PlotRejects}. @xref{Graphics}.
28479 Edit @code{TimeZone}. @xref{Time Zones}.
28481 Edit @code{Units}. @xref{User-Defined Units}.
28483 Edit @code{ExtSimpRules}. @xref{Unsafe Simplifications}.
28486 These commands are just versions of @kbd{s e} that use fixed variable
28487 names rather than prompting for the variable name.
28490 @pindex calc-permanent-variable
28491 @cindex Storing variables
28492 @cindex Permanent variables
28493 @cindex Calc init file, variables
28494 The @kbd{s p} (@code{calc-permanent-variable}) command saves a
28495 variable's value permanently in your Calc init file (the file given by
28496 the variable @code{calc-settings-file}, typically @file{~/.calc.el}), so
28497 that its value will still be available in future Emacs sessions. You
28498 can re-execute @w{@kbd{s p}} later on to update the saved value, but the
28499 only way to remove a saved variable is to edit your calc init file
28500 by hand. (@xref{General Mode Commands}, for a way to tell Calc to
28501 use a different file for the Calc init file.)
28503 If you do not specify the name of a variable to save (i.e.,
28504 @kbd{s p @key{RET}}), all Calc variables with defined values
28505 are saved except for the special constants @code{pi}, @code{e},
28506 @code{i}, @code{phi}, and @code{gamma}; the variables @code{TimeZone}
28507 and @code{PlotRejects};
28508 @code{FitRules}, @code{DistribRules}, and other built-in rewrite
28509 rules; and @code{PlotData@var{n}} variables generated
28510 by the graphics commands. (You can still save these variables by
28511 explicitly naming them in an @kbd{s p} command.)
28514 @pindex calc-insert-variables
28515 The @kbd{s i} (@code{calc-insert-variables}) command writes
28516 the values of all Calc variables into a specified buffer.
28517 The variables are written with the prefix @code{var-} in the form of
28518 Lisp @code{setq} commands
28519 which store the values in string form. You can place these commands
28520 in your Calc init file (or @file{.emacs}) if you wish, though in this case it
28521 would be easier to use @kbd{s p @key{RET}}. (Note that @kbd{s i}
28522 omits the same set of variables as @w{@kbd{s p @key{RET}}}; the difference
28523 is that @kbd{s i} will store the variables in any buffer, and it also
28524 stores in a more human-readable format.)
28526 @node Let Command, Evaluates-To Operator, Operations on Variables, Store and Recall
28527 @section The Let Command
28532 @cindex Variables, temporary assignment
28533 @cindex Temporary assignment to variables
28534 If you have an expression like @samp{a+b^2} on the stack and you wish to
28535 compute its value where @expr{b=3}, you can simply store 3 in @expr{b} and
28536 then press @kbd{=} to reevaluate the formula. This has the side-effect
28537 of leaving the stored value of 3 in @expr{b} for future operations.
28539 The @kbd{s l} (@code{calc-let}) command evaluates a formula under a
28540 @emph{temporary} assignment of a variable. It stores the value on the
28541 top of the stack into the specified variable, then evaluates the
28542 second-to-top stack entry, then restores the original value (or lack of one)
28543 in the variable. Thus after @kbd{'@w{ }a+b^2 @key{RET} 3 s l b @key{RET}},
28544 the stack will contain the formula @samp{a + 9}. The subsequent command
28545 @kbd{@w{5 s l a} @key{RET}} will replace this formula with the number 14.
28546 The variables @samp{a} and @samp{b} are not permanently affected in any way
28549 The value on the top of the stack may be an equation or assignment, or
28550 a vector of equations or assignments, in which case the default will be
28551 analogous to the case of @kbd{s t @key{RET}}. @xref{Storing Variables}.
28553 Also, you can answer the variable-name prompt with an equation or
28554 assignment: @kbd{s l b=3 @key{RET}} is the same as storing 3 on the stack
28555 and typing @kbd{s l b @key{RET}}.
28557 The @kbd{a b} (@code{calc-substitute}) command is another way to substitute
28558 a variable with a value in a formula. It does an actual substitution
28559 rather than temporarily assigning the variable and evaluating. For
28560 example, letting @expr{n=2} in @samp{f(n pi)} with @kbd{a b} will
28561 produce @samp{f(2 pi)}, whereas @kbd{s l} would give @samp{f(6.28)}
28562 since the evaluation step will also evaluate @code{pi}.
28564 @node Evaluates-To Operator, , Let Command, Store and Recall
28565 @section The Evaluates-To Operator
28570 @cindex Evaluates-to operator
28571 @cindex @samp{=>} operator
28572 The special algebraic symbol @samp{=>} is known as the @dfn{evaluates-to
28573 operator}. (It will show up as an @code{evalto} function call in
28574 other language modes like Pascal and La@TeX{}.) This is a binary
28575 operator, that is, it has a lefthand and a righthand argument,
28576 although it can be entered with the righthand argument omitted.
28578 A formula like @samp{@var{a} => @var{b}} is evaluated by Calc as
28579 follows: First, @var{a} is not simplified or modified in any
28580 way. The previous value of argument @var{b} is thrown away; the
28581 formula @var{a} is then copied and evaluated as if by the @kbd{=}
28582 command according to all current modes and stored variable values,
28583 and the result is installed as the new value of @var{b}.
28585 For example, suppose you enter the algebraic formula @samp{2 + 3 => 17}.
28586 The number 17 is ignored, and the lefthand argument is left in its
28587 unevaluated form; the result is the formula @samp{2 + 3 => 5}.
28590 @pindex calc-evalto
28591 You can enter an @samp{=>} formula either directly using algebraic
28592 entry (in which case the righthand side may be omitted since it is
28593 going to be replaced right away anyhow), or by using the @kbd{s =}
28594 (@code{calc-evalto}) command, which takes @var{a} from the stack
28595 and replaces it with @samp{@var{a} => @var{b}}.
28597 Calc keeps track of all @samp{=>} operators on the stack, and
28598 recomputes them whenever anything changes that might affect their
28599 values, i.e., a mode setting or variable value. This occurs only
28600 if the @samp{=>} operator is at the top level of the formula, or
28601 if it is part of a top-level vector. In other words, pushing
28602 @samp{2 + (a => 17)} will change the 17 to the actual value of
28603 @samp{a} when you enter the formula, but the result will not be
28604 dynamically updated when @samp{a} is changed later because the
28605 @samp{=>} operator is buried inside a sum. However, a vector
28606 of @samp{=>} operators will be recomputed, since it is convenient
28607 to push a vector like @samp{[a =>, b =>, c =>]} on the stack to
28608 make a concise display of all the variables in your problem.
28609 (Another way to do this would be to use @samp{[a, b, c] =>},
28610 which provides a slightly different format of display. You
28611 can use whichever you find easiest to read.)
28614 @pindex calc-auto-recompute
28615 The @kbd{m C} (@code{calc-auto-recompute}) command allows you to
28616 turn this automatic recomputation on or off. If you turn
28617 recomputation off, you must explicitly recompute an @samp{=>}
28618 operator on the stack in one of the usual ways, such as by
28619 pressing @kbd{=}. Turning recomputation off temporarily can save
28620 a lot of time if you will be changing several modes or variables
28621 before you look at the @samp{=>} entries again.
28623 Most commands are not especially useful with @samp{=>} operators
28624 as arguments. For example, given @samp{x + 2 => 17}, it won't
28625 work to type @kbd{1 +} to get @samp{x + 3 => 18}. If you want
28626 to operate on the lefthand side of the @samp{=>} operator on
28627 the top of the stack, type @kbd{j 1} (that's the digit ``one'')
28628 to select the lefthand side, execute your commands, then type
28629 @kbd{j u} to unselect.
28631 All current modes apply when an @samp{=>} operator is computed,
28632 including the current simplification mode. Recall that the
28633 formula @samp{x + y + x} is not handled by Calc's default
28634 simplifications, but the @kbd{a s} command will reduce it to
28635 the simpler form @samp{y + 2 x}. You can also type @kbd{m A}
28636 to enable an Algebraic Simplification mode in which the
28637 equivalent of @kbd{a s} is used on all of Calc's results.
28638 If you enter @samp{x + y + x =>} normally, the result will
28639 be @samp{x + y + x => x + y + x}. If you change to
28640 Algebraic Simplification mode, the result will be
28641 @samp{x + y + x => y + 2 x}. However, just pressing @kbd{a s}
28642 once will have no effect on @samp{x + y + x => x + y + x},
28643 because the righthand side depends only on the lefthand side
28644 and the current mode settings, and the lefthand side is not
28645 affected by commands like @kbd{a s}.
28647 The ``let'' command (@kbd{s l}) has an interesting interaction
28648 with the @samp{=>} operator. The @kbd{s l} command evaluates the
28649 second-to-top stack entry with the top stack entry supplying
28650 a temporary value for a given variable. As you might expect,
28651 if that stack entry is an @samp{=>} operator its righthand
28652 side will temporarily show this value for the variable. In
28653 fact, all @samp{=>}s on the stack will be updated if they refer
28654 to that variable. But this change is temporary in the sense
28655 that the next command that causes Calc to look at those stack
28656 entries will make them revert to the old variable value.
28660 2: a => a 2: a => 17 2: a => a
28661 1: a + 1 => a + 1 1: a + 1 => 18 1: a + 1 => a + 1
28664 17 s l a @key{RET} p 8 @key{RET}
28668 Here the @kbd{p 8} command changes the current precision,
28669 thus causing the @samp{=>} forms to be recomputed after the
28670 influence of the ``let'' is gone. The @kbd{d @key{SPC}} command
28671 (@code{calc-refresh}) is a handy way to force the @samp{=>}
28672 operators on the stack to be recomputed without any other
28676 @pindex calc-assign
28679 Embedded mode also uses @samp{=>} operators. In Embedded mode,
28680 the lefthand side of an @samp{=>} operator can refer to variables
28681 assigned elsewhere in the file by @samp{:=} operators. The
28682 assignment operator @samp{a := 17} does not actually do anything
28683 by itself. But Embedded mode recognizes it and marks it as a sort
28684 of file-local definition of the variable. You can enter @samp{:=}
28685 operators in Algebraic mode, or by using the @kbd{s :}
28686 (@code{calc-assign}) [@code{assign}] command which takes a variable
28687 and value from the stack and replaces them with an assignment.
28689 @xref{TeX and LaTeX Language Modes}, for the way @samp{=>} appears in
28690 @TeX{} language output. The @dfn{eqn} mode gives similar
28691 treatment to @samp{=>}.
28693 @node Graphics, Kill and Yank, Store and Recall, Top
28697 The commands for graphing data begin with the @kbd{g} prefix key. Calc
28698 uses GNUPLOT 2.0 or later to do graphics. These commands will only work
28699 if GNUPLOT is available on your system. (While GNUPLOT sounds like
28700 a relative of GNU Emacs, it is actually completely unrelated.
28701 However, it is free software. It can be obtained from
28702 @samp{http://www.gnuplot.info}.)
28704 @vindex calc-gnuplot-name
28705 If you have GNUPLOT installed on your system but Calc is unable to
28706 find it, you may need to set the @code{calc-gnuplot-name} variable
28707 in your Calc init file or @file{.emacs}. You may also need to set some Lisp
28708 variables to show Calc how to run GNUPLOT on your system; these
28709 are described under @kbd{g D} and @kbd{g O} below. If you are
28710 using the X window system, Calc will configure GNUPLOT for you
28711 automatically. If you have GNUPLOT 3.0 or later and you are not using X,
28712 Calc will configure GNUPLOT to display graphs using simple character
28713 graphics that will work on any terminal.
28717 * Three Dimensional Graphics::
28718 * Managing Curves::
28719 * Graphics Options::
28723 @node Basic Graphics, Three Dimensional Graphics, Graphics, Graphics
28724 @section Basic Graphics
28728 @pindex calc-graph-fast
28729 The easiest graphics command is @kbd{g f} (@code{calc-graph-fast}).
28730 This command takes two vectors of equal length from the stack.
28731 The vector at the top of the stack represents the ``y'' values of
28732 the various data points. The vector in the second-to-top position
28733 represents the corresponding ``x'' values. This command runs
28734 GNUPLOT (if it has not already been started by previous graphing
28735 commands) and displays the set of data points. The points will
28736 be connected by lines, and there will also be some kind of symbol
28737 to indicate the points themselves.
28739 The ``x'' entry may instead be an interval form, in which case suitable
28740 ``x'' values are interpolated between the minimum and maximum values of
28741 the interval (whether the interval is open or closed is ignored).
28743 The ``x'' entry may also be a number, in which case Calc uses the
28744 sequence of ``x'' values @expr{x}, @expr{x+1}, @expr{x+2}, etc.
28745 (Generally the number 0 or 1 would be used for @expr{x} in this case.)
28747 The ``y'' entry may be any formula instead of a vector. Calc effectively
28748 uses @kbd{N} (@code{calc-eval-num}) to evaluate variables in the formula;
28749 the result of this must be a formula in a single (unassigned) variable.
28750 The formula is plotted with this variable taking on the various ``x''
28751 values. Graphs of formulas by default use lines without symbols at the
28752 computed data points. Note that if neither ``x'' nor ``y'' is a vector,
28753 Calc guesses at a reasonable number of data points to use. See the
28754 @kbd{g N} command below. (The ``x'' values must be either a vector
28755 or an interval if ``y'' is a formula.)
28761 If ``y'' is (or evaluates to) a formula of the form
28762 @samp{xy(@var{x}, @var{y})} then the result is a
28763 parametric plot. The two arguments of the fictitious @code{xy} function
28764 are used as the ``x'' and ``y'' coordinates of the curve, respectively.
28765 In this case the ``x'' vector or interval you specified is not directly
28766 visible in the graph. For example, if ``x'' is the interval @samp{[0..360]}
28767 and ``y'' is the formula @samp{xy(sin(t), cos(t))}, the resulting graph
28770 Also, ``x'' and ``y'' may each be variable names, in which case Calc
28771 looks for suitable vectors, intervals, or formulas stored in those
28774 The ``x'' and ``y'' values for the data points (as pulled from the vectors,
28775 calculated from the formulas, or interpolated from the intervals) should
28776 be real numbers (integers, fractions, or floats). If either the ``x''
28777 value or the ``y'' value of a given data point is not a real number, that
28778 data point will be omitted from the graph. The points on either side
28779 of the invalid point will @emph{not} be connected by a line.
28781 See the documentation for @kbd{g a} below for a description of the way
28782 numeric prefix arguments affect @kbd{g f}.
28784 @cindex @code{PlotRejects} variable
28785 @vindex PlotRejects
28786 If you store an empty vector in the variable @code{PlotRejects}
28787 (i.e., @kbd{[ ] s t PlotRejects}), Calc will append information to
28788 this vector for every data point which was rejected because its
28789 ``x'' or ``y'' values were not real numbers. The result will be
28790 a matrix where each row holds the curve number, data point number,
28791 ``x'' value, and ``y'' value for a rejected data point.
28792 @xref{Evaluates-To Operator}, for a handy way to keep tabs on the
28793 current value of @code{PlotRejects}. @xref{Operations on Variables},
28794 for the @kbd{s R} command which is another easy way to examine
28795 @code{PlotRejects}.
28798 @pindex calc-graph-clear
28799 To clear the graphics display, type @kbd{g c} (@code{calc-graph-clear}).
28800 If the GNUPLOT output device is an X window, the window will go away.
28801 Effects on other kinds of output devices will vary. You don't need
28802 to use @kbd{g c} if you don't want to---if you give another @kbd{g f}
28803 or @kbd{g p} command later on, it will reuse the existing graphics
28804 window if there is one.
28806 @node Three Dimensional Graphics, Managing Curves, Basic Graphics, Graphics
28807 @section Three-Dimensional Graphics
28810 @pindex calc-graph-fast-3d
28811 The @kbd{g F} (@code{calc-graph-fast-3d}) command makes a three-dimensional
28812 graph. It works only if you have GNUPLOT 3.0 or later; with GNUPLOT 2.0,
28813 you will see a GNUPLOT error message if you try this command.
28815 The @kbd{g F} command takes three values from the stack, called ``x'',
28816 ``y'', and ``z'', respectively. As was the case for 2D graphs, there
28817 are several options for these values.
28819 In the first case, ``x'' and ``y'' are each vectors (not necessarily of
28820 the same length); either or both may instead be interval forms. The
28821 ``z'' value must be a matrix with the same number of rows as elements
28822 in ``x'', and the same number of columns as elements in ``y''. The
28823 result is a surface plot where
28824 @texline @math{z_{ij}}
28825 @infoline @expr{z_ij}
28826 is the height of the point
28827 at coordinate @expr{(x_i, y_j)} on the surface. The 3D graph will
28828 be displayed from a certain default viewpoint; you can change this
28829 viewpoint by adding a @samp{set view} to the @samp{*Gnuplot Commands*}
28830 buffer as described later. See the GNUPLOT documentation for a
28831 description of the @samp{set view} command.
28833 Each point in the matrix will be displayed as a dot in the graph,
28834 and these points will be connected by a grid of lines (@dfn{isolines}).
28836 In the second case, ``x'', ``y'', and ``z'' are all vectors of equal
28837 length. The resulting graph displays a 3D line instead of a surface,
28838 where the coordinates of points along the line are successive triplets
28839 of values from the input vectors.
28841 In the third case, ``x'' and ``y'' are vectors or interval forms, and
28842 ``z'' is any formula involving two variables (not counting variables
28843 with assigned values). These variables are sorted into alphabetical
28844 order; the first takes on values from ``x'' and the second takes on
28845 values from ``y'' to form a matrix of results that are graphed as a
28852 If the ``z'' formula evaluates to a call to the fictitious function
28853 @samp{xyz(@var{x}, @var{y}, @var{z})}, then the result is a
28854 ``parametric surface.'' In this case, the axes of the graph are
28855 taken from the @var{x} and @var{y} values in these calls, and the
28856 ``x'' and ``y'' values from the input vectors or intervals are used only
28857 to specify the range of inputs to the formula. For example, plotting
28858 @samp{[0..360], [0..180], xyz(sin(x)*sin(y), cos(x)*sin(y), cos(y))}
28859 will draw a sphere. (Since the default resolution for 3D plots is
28860 5 steps in each of ``x'' and ``y'', this will draw a very crude
28861 sphere. You could use the @kbd{g N} command, described below, to
28862 increase this resolution, or specify the ``x'' and ``y'' values as
28863 vectors with more than 5 elements.
28865 It is also possible to have a function in a regular @kbd{g f} plot
28866 evaluate to an @code{xyz} call. Since @kbd{g f} plots a line, not
28867 a surface, the result will be a 3D parametric line. For example,
28868 @samp{[[0..720], xyz(sin(x), cos(x), x)]} will plot two turns of a
28869 helix (a three-dimensional spiral).
28871 As for @kbd{g f}, each of ``x'', ``y'', and ``z'' may instead be
28872 variables containing the relevant data.
28874 @node Managing Curves, Graphics Options, Three Dimensional Graphics, Graphics
28875 @section Managing Curves
28878 The @kbd{g f} command is really shorthand for the following commands:
28879 @kbd{C-u g d g a g p}. Likewise, @w{@kbd{g F}} is shorthand for
28880 @kbd{C-u g d g A g p}. You can gain more control over your graph
28881 by using these commands directly.
28884 @pindex calc-graph-add
28885 The @kbd{g a} (@code{calc-graph-add}) command adds the ``curve''
28886 represented by the two values on the top of the stack to the current
28887 graph. You can have any number of curves in the same graph. When
28888 you give the @kbd{g p} command, all the curves will be drawn superimposed
28891 The @kbd{g a} command (and many others that affect the current graph)
28892 will cause a special buffer, @samp{*Gnuplot Commands*}, to be displayed
28893 in another window. This buffer is a template of the commands that will
28894 be sent to GNUPLOT when it is time to draw the graph. The first
28895 @kbd{g a} command adds a @code{plot} command to this buffer. Succeeding
28896 @kbd{g a} commands add extra curves onto that @code{plot} command.
28897 Other graph-related commands put other GNUPLOT commands into this
28898 buffer. In normal usage you never need to work with this buffer
28899 directly, but you can if you wish. The only constraint is that there
28900 must be only one @code{plot} command, and it must be the last command
28901 in the buffer. If you want to save and later restore a complete graph
28902 configuration, you can use regular Emacs commands to save and restore
28903 the contents of the @samp{*Gnuplot Commands*} buffer.
28907 If the values on the stack are not variable names, @kbd{g a} will invent
28908 variable names for them (of the form @samp{PlotData@var{n}}) and store
28909 the values in those variables. The ``x'' and ``y'' variables are what
28910 go into the @code{plot} command in the template. If you add a curve
28911 that uses a certain variable and then later change that variable, you
28912 can replot the graph without having to delete and re-add the curve.
28913 That's because the variable name, not the vector, interval or formula
28914 itself, is what was added by @kbd{g a}.
28916 A numeric prefix argument on @kbd{g a} or @kbd{g f} changes the way
28917 stack entries are interpreted as curves. With a positive prefix
28918 argument @expr{n}, the top @expr{n} stack entries are ``y'' values
28919 for @expr{n} different curves which share a common ``x'' value in
28920 the @expr{n+1}st stack entry. (Thus @kbd{g a} with no prefix
28921 argument is equivalent to @kbd{C-u 1 g a}.)
28923 A prefix of zero or plain @kbd{C-u} means to take two stack entries,
28924 ``x'' and ``y'' as usual, but to interpret ``y'' as a vector of
28925 ``y'' values for several curves that share a common ``x''.
28927 A negative prefix argument tells Calc to read @expr{n} vectors from
28928 the stack; each vector @expr{[x, y]} describes an independent curve.
28929 This is the only form of @kbd{g a} that creates several curves at once
28930 that don't have common ``x'' values. (Of course, the range of ``x''
28931 values covered by all the curves ought to be roughly the same if
28932 they are to look nice on the same graph.)
28934 For example, to plot
28935 @texline @math{\sin n x}
28936 @infoline @expr{sin(n x)}
28937 for integers @expr{n}
28938 from 1 to 5, you could use @kbd{v x} to create a vector of integers
28939 (@expr{n}), then @kbd{V M '} or @kbd{V M $} to map @samp{sin(n x)}
28940 across this vector. The resulting vector of formulas is suitable
28941 for use as the ``y'' argument to a @kbd{C-u g a} or @kbd{C-u g f}
28945 @pindex calc-graph-add-3d
28946 The @kbd{g A} (@code{calc-graph-add-3d}) command adds a 3D curve
28947 to the graph. It is not valid to intermix 2D and 3D curves in a
28948 single graph. This command takes three arguments, ``x'', ``y'',
28949 and ``z'', from the stack. With a positive prefix @expr{n}, it
28950 takes @expr{n+2} arguments (common ``x'' and ``y'', plus @expr{n}
28951 separate ``z''s). With a zero prefix, it takes three stack entries
28952 but the ``z'' entry is a vector of curve values. With a negative
28953 prefix @expr{-n}, it takes @expr{n} vectors of the form @expr{[x, y, z]}.
28954 The @kbd{g A} command works by adding a @code{splot} (surface-plot)
28955 command to the @samp{*Gnuplot Commands*} buffer.
28957 (Although @kbd{g a} adds a 2D @code{plot} command to the
28958 @samp{*Gnuplot Commands*} buffer, Calc changes this to @code{splot}
28959 before sending it to GNUPLOT if it notices that the data points are
28960 evaluating to @code{xyz} calls. It will not work to mix 2D and 3D
28961 @kbd{g a} curves in a single graph, although Calc does not currently
28965 @pindex calc-graph-delete
28966 The @kbd{g d} (@code{calc-graph-delete}) command deletes the most
28967 recently added curve from the graph. It has no effect if there are
28968 no curves in the graph. With a numeric prefix argument of any kind,
28969 it deletes all of the curves from the graph.
28972 @pindex calc-graph-hide
28973 The @kbd{g H} (@code{calc-graph-hide}) command ``hides'' or ``unhides''
28974 the most recently added curve. A hidden curve will not appear in
28975 the actual plot, but information about it such as its name and line and
28976 point styles will be retained.
28979 @pindex calc-graph-juggle
28980 The @kbd{g j} (@code{calc-graph-juggle}) command moves the curve
28981 at the end of the list (the ``most recently added curve'') to the
28982 front of the list. The next-most-recent curve is thus exposed for
28983 @w{@kbd{g d}} or similar commands to use. With @kbd{g j} you can work
28984 with any curve in the graph even though curve-related commands only
28985 affect the last curve in the list.
28988 @pindex calc-graph-plot
28989 The @kbd{g p} (@code{calc-graph-plot}) command uses GNUPLOT to draw
28990 the graph described in the @samp{*Gnuplot Commands*} buffer. Any
28991 GNUPLOT parameters which are not defined by commands in this buffer
28992 are reset to their default values. The variables named in the @code{plot}
28993 command are written to a temporary data file and the variable names
28994 are then replaced by the file name in the template. The resulting
28995 plotting commands are fed to the GNUPLOT program. See the documentation
28996 for the GNUPLOT program for more specific information. All temporary
28997 files are removed when Emacs or GNUPLOT exits.
28999 If you give a formula for ``y'', Calc will remember all the values that
29000 it calculates for the formula so that later plots can reuse these values.
29001 Calc throws out these saved values when you change any circumstances
29002 that may affect the data, such as switching from Degrees to Radians
29003 mode, or changing the value of a parameter in the formula. You can
29004 force Calc to recompute the data from scratch by giving a negative
29005 numeric prefix argument to @kbd{g p}.
29007 Calc uses a fairly rough step size when graphing formulas over intervals.
29008 This is to ensure quick response. You can ``refine'' a plot by giving
29009 a positive numeric prefix argument to @kbd{g p}. Calc goes through
29010 the data points it has computed and saved from previous plots of the
29011 function, and computes and inserts a new data point midway between
29012 each of the existing points. You can refine a plot any number of times,
29013 but beware that the amount of calculation involved doubles each time.
29015 Calc does not remember computed values for 3D graphs. This means the
29016 numerix prefix argument, if any, to @kbd{g p} is effectively ignored if
29017 the current graph is three-dimensional.
29020 @pindex calc-graph-print
29021 The @kbd{g P} (@code{calc-graph-print}) command is like @kbd{g p},
29022 except that it sends the output to a printer instead of to the
29023 screen. More precisely, @kbd{g p} looks for @samp{set terminal}
29024 or @samp{set output} commands in the @samp{*Gnuplot Commands*} buffer;
29025 lacking these it uses the default settings. However, @kbd{g P}
29026 ignores @samp{set terminal} and @samp{set output} commands and
29027 uses a different set of default values. All of these values are
29028 controlled by the @kbd{g D} and @kbd{g O} commands discussed below.
29029 Provided everything is set up properly, @kbd{g p} will plot to
29030 the screen unless you have specified otherwise and @kbd{g P} will
29031 always plot to the printer.
29033 @node Graphics Options, Devices, Managing Curves, Graphics
29034 @section Graphics Options
29038 @pindex calc-graph-grid
29039 The @kbd{g g} (@code{calc-graph-grid}) command turns the ``grid''
29040 on and off. It is off by default; tick marks appear only at the
29041 edges of the graph. With the grid turned on, dotted lines appear
29042 across the graph at each tick mark. Note that this command only
29043 changes the setting in @samp{*Gnuplot Commands*}; to see the effects
29044 of the change you must give another @kbd{g p} command.
29047 @pindex calc-graph-border
29048 The @kbd{g b} (@code{calc-graph-border}) command turns the border
29049 (the box that surrounds the graph) on and off. It is on by default.
29050 This command will only work with GNUPLOT 3.0 and later versions.
29053 @pindex calc-graph-key
29054 The @kbd{g k} (@code{calc-graph-key}) command turns the ``key''
29055 on and off. The key is a chart in the corner of the graph that
29056 shows the correspondence between curves and line styles. It is
29057 off by default, and is only really useful if you have several
29058 curves on the same graph.
29061 @pindex calc-graph-num-points
29062 The @kbd{g N} (@code{calc-graph-num-points}) command allows you
29063 to select the number of data points in the graph. This only affects
29064 curves where neither ``x'' nor ``y'' is specified as a vector.
29065 Enter a blank line to revert to the default value (initially 15).
29066 With no prefix argument, this command affects only the current graph.
29067 With a positive prefix argument this command changes or, if you enter
29068 a blank line, displays the default number of points used for all
29069 graphs created by @kbd{g a} that don't specify the resolution explicitly.
29070 With a negative prefix argument, this command changes or displays
29071 the default value (initially 5) used for 3D graphs created by @kbd{g A}.
29072 Note that a 3D setting of 5 means that a total of @expr{5^2 = 25} points
29073 will be computed for the surface.
29075 Data values in the graph of a function are normally computed to a
29076 precision of five digits, regardless of the current precision at the
29077 time. This is usually more than adequate, but there are cases where
29078 it will not be. For example, plotting @expr{1 + x} with @expr{x} in the
29079 interval @samp{[0 ..@: 1e-6]} will round all the data points down
29080 to 1.0! Putting the command @samp{set precision @var{n}} in the
29081 @samp{*Gnuplot Commands*} buffer will cause the data to be computed
29082 at precision @var{n} instead of 5. Since this is such a rare case,
29083 there is no keystroke-based command to set the precision.
29086 @pindex calc-graph-header
29087 The @kbd{g h} (@code{calc-graph-header}) command sets the title
29088 for the graph. This will show up centered above the graph.
29089 The default title is blank (no title).
29092 @pindex calc-graph-name
29093 The @kbd{g n} (@code{calc-graph-name}) command sets the title of an
29094 individual curve. Like the other curve-manipulating commands, it
29095 affects the most recently added curve, i.e., the last curve on the
29096 list in the @samp{*Gnuplot Commands*} buffer. To set the title of
29097 the other curves you must first juggle them to the end of the list
29098 with @kbd{g j}, or edit the @samp{*Gnuplot Commands*} buffer by hand.
29099 Curve titles appear in the key; if the key is turned off they are
29104 @pindex calc-graph-title-x
29105 @pindex calc-graph-title-y
29106 The @kbd{g t} (@code{calc-graph-title-x}) and @kbd{g T}
29107 (@code{calc-graph-title-y}) commands set the titles on the ``x''
29108 and ``y'' axes, respectively. These titles appear next to the
29109 tick marks on the left and bottom edges of the graph, respectively.
29110 Calc does not have commands to control the tick marks themselves,
29111 but you can edit them into the @samp{*Gnuplot Commands*} buffer if
29112 you wish. See the GNUPLOT documentation for details.
29116 @pindex calc-graph-range-x
29117 @pindex calc-graph-range-y
29118 The @kbd{g r} (@code{calc-graph-range-x}) and @kbd{g R}
29119 (@code{calc-graph-range-y}) commands set the range of values on the
29120 ``x'' and ``y'' axes, respectively. You are prompted to enter a
29121 suitable range. This should be either a pair of numbers of the
29122 form, @samp{@var{min}:@var{max}}, or a blank line to revert to the
29123 default behavior of setting the range based on the range of values
29124 in the data, or @samp{$} to take the range from the top of the stack.
29125 Ranges on the stack can be represented as either interval forms or
29126 vectors: @samp{[@var{min} ..@: @var{max}]} or @samp{[@var{min}, @var{max}]}.
29130 @pindex calc-graph-log-x
29131 @pindex calc-graph-log-y
29132 The @kbd{g l} (@code{calc-graph-log-x}) and @kbd{g L} (@code{calc-graph-log-y})
29133 commands allow you to set either or both of the axes of the graph to
29134 be logarithmic instead of linear.
29139 @pindex calc-graph-log-z
29140 @pindex calc-graph-range-z
29141 @pindex calc-graph-title-z
29142 For 3D plots, @kbd{g C-t}, @kbd{g C-r}, and @kbd{g C-l} (those are
29143 letters with the Control key held down) are the corresponding commands
29144 for the ``z'' axis.
29148 @pindex calc-graph-zero-x
29149 @pindex calc-graph-zero-y
29150 The @kbd{g z} (@code{calc-graph-zero-x}) and @kbd{g Z}
29151 (@code{calc-graph-zero-y}) commands control whether a dotted line is
29152 drawn to indicate the ``x'' and/or ``y'' zero axes. (These are the same
29153 dotted lines that would be drawn there anyway if you used @kbd{g g} to
29154 turn the ``grid'' feature on.) Zero-axis lines are on by default, and
29155 may be turned off only in GNUPLOT 3.0 and later versions. They are
29156 not available for 3D plots.
29159 @pindex calc-graph-line-style
29160 The @kbd{g s} (@code{calc-graph-line-style}) command turns the connecting
29161 lines on or off for the most recently added curve, and optionally selects
29162 the style of lines to be used for that curve. Plain @kbd{g s} simply
29163 toggles the lines on and off. With a numeric prefix argument, @kbd{g s}
29164 turns lines on and sets a particular line style. Line style numbers
29165 start at one and their meanings vary depending on the output device.
29166 GNUPLOT guarantees that there will be at least six different line styles
29167 available for any device.
29170 @pindex calc-graph-point-style
29171 The @kbd{g S} (@code{calc-graph-point-style}) command similarly turns
29172 the symbols at the data points on or off, or sets the point style.
29173 If you turn both lines and points off, the data points will show as
29176 @cindex @code{LineStyles} variable
29177 @cindex @code{PointStyles} variable
29179 @vindex PointStyles
29180 Another way to specify curve styles is with the @code{LineStyles} and
29181 @code{PointStyles} variables. These variables initially have no stored
29182 values, but if you store a vector of integers in one of these variables,
29183 the @kbd{g a} and @kbd{g f} commands will use those style numbers
29184 instead of the defaults for new curves that are added to the graph.
29185 An entry should be a positive integer for a specific style, or 0 to let
29186 the style be chosen automatically, or @mathit{-1} to turn off lines or points
29187 altogether. If there are more curves than elements in the vector, the
29188 last few curves will continue to have the default styles. Of course,
29189 you can later use @kbd{g s} and @kbd{g S} to change any of these styles.
29191 For example, @kbd{'[2 -1 3] @key{RET} s t LineStyles} causes the first curve
29192 to have lines in style number 2, the second curve to have no connecting
29193 lines, and the third curve to have lines in style 3. Point styles will
29194 still be assigned automatically, but you could store another vector in
29195 @code{PointStyles} to define them, too.
29197 @node Devices, , Graphics Options, Graphics
29198 @section Graphical Devices
29202 @pindex calc-graph-device
29203 The @kbd{g D} (@code{calc-graph-device}) command sets the device name
29204 (or ``terminal name'' in GNUPLOT lingo) to be used by @kbd{g p} commands
29205 on this graph. It does not affect the permanent default device name.
29206 If you enter a blank name, the device name reverts to the default.
29207 Enter @samp{?} to see a list of supported devices.
29209 With a positive numeric prefix argument, @kbd{g D} instead sets
29210 the default device name, used by all plots in the future which do
29211 not override it with a plain @kbd{g D} command. If you enter a
29212 blank line this command shows you the current default. The special
29213 name @code{default} signifies that Calc should choose @code{x11} if
29214 the X window system is in use (as indicated by the presence of a
29215 @code{DISPLAY} environment variable), or otherwise @code{dumb} under
29216 GNUPLOT 3.0 and later, or @code{postscript} under GNUPLOT 2.0.
29217 This is the initial default value.
29219 The @code{dumb} device is an interface to ``dumb terminals,'' i.e.,
29220 terminals with no special graphics facilities. It writes a crude
29221 picture of the graph composed of characters like @code{-} and @code{|}
29222 to a buffer called @samp{*Gnuplot Trail*}, which Calc then displays.
29223 The graph is made the same size as the Emacs screen, which on most
29224 dumb terminals will be
29225 @texline @math{80\times24}
29227 characters. The graph is displayed in
29228 an Emacs ``recursive edit''; type @kbd{q} or @kbd{C-c C-c} to exit
29229 the recursive edit and return to Calc. Note that the @code{dumb}
29230 device is present only in GNUPLOT 3.0 and later versions.
29232 The word @code{dumb} may be followed by two numbers separated by
29233 spaces. These are the desired width and height of the graph in
29234 characters. Also, the device name @code{big} is like @code{dumb}
29235 but creates a graph four times the width and height of the Emacs
29236 screen. You will then have to scroll around to view the entire
29237 graph. In the @samp{*Gnuplot Trail*} buffer, @key{SPC}, @key{DEL},
29238 @kbd{<}, and @kbd{>} are defined to scroll by one screenful in each
29239 of the four directions.
29241 With a negative numeric prefix argument, @kbd{g D} sets or displays
29242 the device name used by @kbd{g P} (@code{calc-graph-print}). This
29243 is initially @code{postscript}. If you don't have a PostScript
29244 printer, you may decide once again to use @code{dumb} to create a
29245 plot on any text-only printer.
29248 @pindex calc-graph-output
29249 The @kbd{g O} (@code{calc-graph-output}) command sets the name of
29250 the output file used by GNUPLOT. For some devices, notably @code{x11},
29251 there is no output file and this information is not used. Many other
29252 ``devices'' are really file formats like @code{postscript}; in these
29253 cases the output in the desired format goes into the file you name
29254 with @kbd{g O}. Type @kbd{g O stdout @key{RET}} to set GNUPLOT to write
29255 to its standard output stream, i.e., to @samp{*Gnuplot Trail*}.
29256 This is the default setting.
29258 Another special output name is @code{tty}, which means that GNUPLOT
29259 is going to write graphics commands directly to its standard output,
29260 which you wish Emacs to pass through to your terminal. Tektronix
29261 graphics terminals, among other devices, operate this way. Calc does
29262 this by telling GNUPLOT to write to a temporary file, then running a
29263 sub-shell executing the command @samp{cat tempfile >/dev/tty}. On
29264 typical Unix systems, this will copy the temporary file directly to
29265 the terminal, bypassing Emacs entirely. You will have to type @kbd{C-l}
29266 to Emacs afterwards to refresh the screen.
29268 Once again, @kbd{g O} with a positive or negative prefix argument
29269 sets the default or printer output file names, respectively. In each
29270 case you can specify @code{auto}, which causes Calc to invent a temporary
29271 file name for each @kbd{g p} (or @kbd{g P}) command. This temporary file
29272 will be deleted once it has been displayed or printed. If the output file
29273 name is not @code{auto}, the file is not automatically deleted.
29275 The default and printer devices and output files can be saved
29276 permanently by the @kbd{m m} (@code{calc-save-modes}) command. The
29277 default number of data points (see @kbd{g N}) and the X geometry
29278 (see @kbd{g X}) are also saved. Other graph information is @emph{not}
29279 saved; you can save a graph's configuration simply by saving the contents
29280 of the @samp{*Gnuplot Commands*} buffer.
29282 @vindex calc-gnuplot-plot-command
29283 @vindex calc-gnuplot-default-device
29284 @vindex calc-gnuplot-default-output
29285 @vindex calc-gnuplot-print-command
29286 @vindex calc-gnuplot-print-device
29287 @vindex calc-gnuplot-print-output
29288 You may wish to configure the default and
29289 printer devices and output files for the whole system. The relevant
29290 Lisp variables are @code{calc-gnuplot-default-device} and @code{-output},
29291 and @code{calc-gnuplot-print-device} and @code{-output}. The output
29292 file names must be either strings as described above, or Lisp
29293 expressions which are evaluated on the fly to get the output file names.
29295 Other important Lisp variables are @code{calc-gnuplot-plot-command} and
29296 @code{calc-gnuplot-print-command}, which give the system commands to
29297 display or print the output of GNUPLOT, respectively. These may be
29298 @code{nil} if no command is necessary, or strings which can include
29299 @samp{%s} to signify the name of the file to be displayed or printed.
29300 Or, these variables may contain Lisp expressions which are evaluated
29301 to display or print the output. These variables are customizable
29302 (@pxref{Customizable Variables}).
29305 @pindex calc-graph-display
29306 The @kbd{g x} (@code{calc-graph-display}) command lets you specify
29307 on which X window system display your graphs should be drawn. Enter
29308 a blank line to see the current display name. This command has no
29309 effect unless the current device is @code{x11}.
29312 @pindex calc-graph-geometry
29313 The @kbd{g X} (@code{calc-graph-geometry}) command is a similar
29314 command for specifying the position and size of the X window.
29315 The normal value is @code{default}, which generally means your
29316 window manager will let you place the window interactively.
29317 Entering @samp{800x500+0+0} would create an 800-by-500 pixel
29318 window in the upper-left corner of the screen.
29320 The buffer called @samp{*Gnuplot Trail*} holds a transcript of the
29321 session with GNUPLOT. This shows the commands Calc has ``typed'' to
29322 GNUPLOT and the responses it has received. Calc tries to notice when an
29323 error message has appeared here and display the buffer for you when
29324 this happens. You can check this buffer yourself if you suspect
29325 something has gone wrong.
29328 @pindex calc-graph-command
29329 The @kbd{g C} (@code{calc-graph-command}) command prompts you to
29330 enter any line of text, then simply sends that line to the current
29331 GNUPLOT process. The @samp{*Gnuplot Trail*} buffer looks deceptively
29332 like a Shell buffer but you can't type commands in it yourself.
29333 Instead, you must use @kbd{g C} for this purpose.
29337 @pindex calc-graph-view-commands
29338 @pindex calc-graph-view-trail
29339 The @kbd{g v} (@code{calc-graph-view-commands}) and @kbd{g V}
29340 (@code{calc-graph-view-trail}) commands display the @samp{*Gnuplot Commands*}
29341 and @samp{*Gnuplot Trail*} buffers, respectively, in another window.
29342 This happens automatically when Calc thinks there is something you
29343 will want to see in either of these buffers. If you type @kbd{g v}
29344 or @kbd{g V} when the relevant buffer is already displayed, the
29345 buffer is hidden again.
29347 One reason to use @kbd{g v} is to add your own commands to the
29348 @samp{*Gnuplot Commands*} buffer. Press @kbd{g v}, then use
29349 @kbd{C-x o} to switch into that window. For example, GNUPLOT has
29350 @samp{set label} and @samp{set arrow} commands that allow you to
29351 annotate your plots. Since Calc doesn't understand these commands,
29352 you have to add them to the @samp{*Gnuplot Commands*} buffer
29353 yourself, then use @w{@kbd{g p}} to replot using these new commands. Note
29354 that your commands must appear @emph{before} the @code{plot} command.
29355 To get help on any GNUPLOT feature, type, e.g., @kbd{g C help set label}.
29356 You may have to type @kbd{g C @key{RET}} a few times to clear the
29357 ``press return for more'' or ``subtopic of @dots{}'' requests.
29358 Note that Calc always sends commands (like @samp{set nolabel}) to
29359 reset all plotting parameters to the defaults before each plot, so
29360 to delete a label all you need to do is delete the @samp{set label}
29361 line you added (or comment it out with @samp{#}) and then replot
29365 @pindex calc-graph-quit
29366 You can use @kbd{g q} (@code{calc-graph-quit}) to kill the GNUPLOT
29367 process that is running. The next graphing command you give will
29368 start a fresh GNUPLOT process. The word @samp{Graph} appears in
29369 the Calc window's mode line whenever a GNUPLOT process is currently
29370 running. The GNUPLOT process is automatically killed when you
29371 exit Emacs if you haven't killed it manually by then.
29374 @pindex calc-graph-kill
29375 The @kbd{g K} (@code{calc-graph-kill}) command is like @kbd{g q}
29376 except that it also views the @samp{*Gnuplot Trail*} buffer so that
29377 you can see the process being killed. This is better if you are
29378 killing GNUPLOT because you think it has gotten stuck.
29380 @node Kill and Yank, Keypad Mode, Graphics, Top
29381 @chapter Kill and Yank Functions
29384 The commands in this chapter move information between the Calculator and
29385 other Emacs editing buffers.
29387 In many cases Embedded mode is an easier and more natural way to
29388 work with Calc from a regular editing buffer. @xref{Embedded Mode}.
29391 * Killing From Stack::
29392 * Yanking Into Stack::
29393 * Grabbing From Buffers::
29394 * Yanking Into Buffers::
29395 * X Cut and Paste::
29398 @node Killing From Stack, Yanking Into Stack, Kill and Yank, Kill and Yank
29399 @section Killing from the Stack
29405 @pindex calc-copy-as-kill
29407 @pindex calc-kill-region
29409 @pindex calc-copy-region-as-kill
29411 @dfn{Kill} commands are Emacs commands that insert text into the
29412 ``kill ring,'' from which it can later be ``yanked'' by a @kbd{C-y}
29413 command. Three common kill commands in normal Emacs are @kbd{C-k}, which
29414 kills one line, @kbd{C-w}, which kills the region between mark and point,
29415 and @kbd{M-w}, which puts the region into the kill ring without actually
29416 deleting it. All of these commands work in the Calculator, too. Also,
29417 @kbd{M-k} has been provided to complete the set; it puts the current line
29418 into the kill ring without deleting anything.
29420 The kill commands are unusual in that they pay attention to the location
29421 of the cursor in the Calculator buffer. If the cursor is on or below the
29422 bottom line, the kill commands operate on the top of the stack. Otherwise,
29423 they operate on whatever stack element the cursor is on. Calc's kill
29424 commands always operate on whole stack entries. (They act the same as their
29425 standard Emacs cousins except they ``round up'' the specified region to
29426 encompass full lines.) The text is copied into the kill ring exactly as
29427 it appears on the screen, including line numbers if they are enabled.
29429 A numeric prefix argument to @kbd{C-k} or @kbd{M-k} affects the number
29430 of lines killed. A positive argument kills the current line and @expr{n-1}
29431 lines below it. A negative argument kills the @expr{-n} lines above the
29432 current line. Again this mirrors the behavior of the standard Emacs
29433 @kbd{C-k} command. Although a whole line is always deleted, @kbd{C-k}
29434 with no argument copies only the number itself into the kill ring, whereas
29435 @kbd{C-k} with a prefix argument of 1 copies the number with its trailing
29438 @node Yanking Into Stack, Grabbing From Buffers, Killing From Stack, Kill and Yank
29439 @section Yanking into the Stack
29444 The @kbd{C-y} command yanks the most recently killed text back into the
29445 Calculator. It pushes this value onto the top of the stack regardless of
29446 the cursor position. In general it re-parses the killed text as a number
29447 or formula (or a list of these separated by commas or newlines). However if
29448 the thing being yanked is something that was just killed from the Calculator
29449 itself, its full internal structure is yanked. For example, if you have
29450 set the floating-point display mode to show only four significant digits,
29451 then killing and re-yanking 3.14159 (which displays as 3.142) will yank the
29452 full 3.14159, even though yanking it into any other buffer would yank the
29453 number in its displayed form, 3.142. (Since the default display modes
29454 show all objects to their full precision, this feature normally makes no
29457 @node Grabbing From Buffers, Yanking Into Buffers, Yanking Into Stack, Kill and Yank
29458 @section Grabbing from Other Buffers
29462 @pindex calc-grab-region
29463 The @kbd{M-# g} (@code{calc-grab-region}) command takes the text between
29464 point and mark in the current buffer and attempts to parse it as a
29465 vector of values. Basically, it wraps the text in vector brackets
29466 @samp{[ ]} unless the text already is enclosed in vector brackets,
29467 then reads the text as if it were an algebraic entry. The contents
29468 of the vector may be numbers, formulas, or any other Calc objects.
29469 If the @kbd{M-# g} command works successfully, it does an automatic
29470 @kbd{M-# c} to enter the Calculator buffer.
29472 A numeric prefix argument grabs the specified number of lines around
29473 point, ignoring the mark. A positive prefix grabs from point to the
29474 @expr{n}th following newline (so that @kbd{M-1 M-# g} grabs from point
29475 to the end of the current line); a negative prefix grabs from point
29476 back to the @expr{n+1}st preceding newline. In these cases the text
29477 that is grabbed is exactly the same as the text that @kbd{C-k} would
29478 delete given that prefix argument.
29480 A prefix of zero grabs the current line; point may be anywhere on the
29483 A plain @kbd{C-u} prefix interprets the region between point and mark
29484 as a single number or formula rather than a vector. For example,
29485 @kbd{M-# g} on the text @samp{2 a b} produces the vector of three
29486 values @samp{[2, a, b]}, but @kbd{C-u M-# g} on the same region
29487 reads a formula which is a product of three things: @samp{2 a b}.
29488 (The text @samp{a + b}, on the other hand, will be grabbed as a
29489 vector of one element by plain @kbd{M-# g} because the interpretation
29490 @samp{[a, +, b]} would be a syntax error.)
29492 If a different language has been specified (@pxref{Language Modes}),
29493 the grabbed text will be interpreted according to that language.
29496 @pindex calc-grab-rectangle
29497 The @kbd{M-# r} (@code{calc-grab-rectangle}) command takes the text between
29498 point and mark and attempts to parse it as a matrix. If point and mark
29499 are both in the leftmost column, the lines in between are parsed in their
29500 entirety. Otherwise, point and mark define the corners of a rectangle
29501 whose contents are parsed.
29503 Each line of the grabbed area becomes a row of the matrix. The result
29504 will actually be a vector of vectors, which Calc will treat as a matrix
29505 only if every row contains the same number of values.
29507 If a line contains a portion surrounded by square brackets (or curly
29508 braces), that portion is interpreted as a vector which becomes a row
29509 of the matrix. Any text surrounding the bracketed portion on the line
29512 Otherwise, the entire line is interpreted as a row vector as if it
29513 were surrounded by square brackets. Leading line numbers (in the
29514 format used in the Calc stack buffer) are ignored. If you wish to
29515 force this interpretation (even if the line contains bracketed
29516 portions), give a negative numeric prefix argument to the
29517 @kbd{M-# r} command.
29519 If you give a numeric prefix argument of zero or plain @kbd{C-u}, each
29520 line is instead interpreted as a single formula which is converted into
29521 a one-element vector. Thus the result of @kbd{C-u M-# r} will be a
29522 one-column matrix. For example, suppose one line of the data is the
29523 expression @samp{2 a}. A plain @w{@kbd{M-# r}} will interpret this as
29524 @samp{[2 a]}, which in turn is read as a two-element vector that forms
29525 one row of the matrix. But a @kbd{C-u M-# r} will interpret this row
29528 If you give a positive numeric prefix argument @var{n}, then each line
29529 will be split up into columns of width @var{n}; each column is parsed
29530 separately as a matrix element. If a line contained
29531 @w{@samp{2 +/- 3 4 +/- 5}}, then grabbing with a prefix argument of 8
29532 would correctly split the line into two error forms.
29534 @xref{Matrix Functions}, to see how to pull the matrix apart into its
29535 constituent rows and columns. (If it is a
29536 @texline @math{1\times1}
29538 matrix, just hit @kbd{v u} (@code{calc-unpack}) twice.)
29542 @pindex calc-grab-sum-across
29543 @pindex calc-grab-sum-down
29544 @cindex Summing rows and columns of data
29545 The @kbd{M-# :} (@code{calc-grab-sum-down}) command is a handy way to
29546 grab a rectangle of data and sum its columns. It is equivalent to
29547 typing @kbd{M-# r}, followed by @kbd{V R : +} (the vector reduction
29548 command that sums the columns of a matrix; @pxref{Reducing}). The
29549 result of the command will be a vector of numbers, one for each column
29550 in the input data. The @kbd{M-# _} (@code{calc-grab-sum-across}) command
29551 similarly grabs a rectangle and sums its rows by executing @w{@kbd{V R _ +}}.
29553 As well as being more convenient, @kbd{M-# :} and @kbd{M-# _} are also
29554 much faster because they don't actually place the grabbed vector on
29555 the stack. In a @kbd{M-# r V R : +} sequence, formatting the vector
29556 for display on the stack takes a large fraction of the total time
29557 (unless you have planned ahead and used @kbd{v .} and @kbd{t .} modes).
29559 For example, suppose we have a column of numbers in a file which we
29560 wish to sum. Go to one corner of the column and press @kbd{C-@@} to
29561 set the mark; go to the other corner and type @kbd{M-# :}. Since there
29562 is only one column, the result will be a vector of one number, the sum.
29563 (You can type @kbd{v u} to unpack this vector into a plain number if
29564 you want to do further arithmetic with it.)
29566 To compute the product of the column of numbers, we would have to do
29567 it ``by hand'' since there's no special grab-and-multiply command.
29568 Use @kbd{M-# r} to grab the column of numbers into the calculator in
29569 the form of a column matrix. The statistics command @kbd{u *} is a
29570 handy way to find the product of a vector or matrix of numbers.
29571 @xref{Statistical Operations}. Another approach would be to use
29572 an explicit column reduction command, @kbd{V R : *}.
29574 @node Yanking Into Buffers, X Cut and Paste, Grabbing From Buffers, Kill and Yank
29575 @section Yanking into Other Buffers
29579 @pindex calc-copy-to-buffer
29580 The plain @kbd{y} (@code{calc-copy-to-buffer}) command inserts the number
29581 at the top of the stack into the most recently used normal editing buffer.
29582 (More specifically, this is the most recently used buffer which is displayed
29583 in a window and whose name does not begin with @samp{*}. If there is no
29584 such buffer, this is the most recently used buffer except for Calculator
29585 and Calc Trail buffers.) The number is inserted exactly as it appears and
29586 without a newline. (If line-numbering is enabled, the line number is
29587 normally not included.) The number is @emph{not} removed from the stack.
29589 With a prefix argument, @kbd{y} inserts several numbers, one per line.
29590 A positive argument inserts the specified number of values from the top
29591 of the stack. A negative argument inserts the @expr{n}th value from the
29592 top of the stack. An argument of zero inserts the entire stack. Note
29593 that @kbd{y} with an argument of 1 is slightly different from @kbd{y}
29594 with no argument; the former always copies full lines, whereas the
29595 latter strips off the trailing newline.
29597 With a lone @kbd{C-u} as a prefix argument, @kbd{y} @emph{replaces} the
29598 region in the other buffer with the yanked text, then quits the
29599 Calculator, leaving you in that buffer. A typical use would be to use
29600 @kbd{M-# g} to read a region of data into the Calculator, operate on the
29601 data to produce a new matrix, then type @kbd{C-u y} to replace the
29602 original data with the new data. One might wish to alter the matrix
29603 display style (@pxref{Vector and Matrix Formats}) or change the current
29604 display language (@pxref{Language Modes}) before doing this. Also, note
29605 that this command replaces a linear region of text (as grabbed by
29606 @kbd{M-# g}), not a rectangle (as grabbed by @kbd{M-# r}).
29608 If the editing buffer is in overwrite (as opposed to insert) mode,
29609 and the @kbd{C-u} prefix was not used, then the yanked number will
29610 overwrite the characters following point rather than being inserted
29611 before those characters. The usual conventions of overwrite mode
29612 are observed; for example, characters will be inserted at the end of
29613 a line rather than overflowing onto the next line. Yanking a multi-line
29614 object such as a matrix in overwrite mode overwrites the next @var{n}
29615 lines in the buffer, lengthening or shortening each line as necessary.
29616 Finally, if the thing being yanked is a simple integer or floating-point
29617 number (like @samp{-1.2345e-3}) and the characters following point also
29618 make up such a number, then Calc will replace that number with the new
29619 number, lengthening or shortening as necessary. The concept of
29620 ``overwrite mode'' has thus been generalized from overwriting characters
29621 to overwriting one complete number with another.
29624 The @kbd{M-# y} key sequence is equivalent to @kbd{y} except that
29625 it can be typed anywhere, not just in Calc. This provides an easy
29626 way to guarantee that Calc knows which editing buffer you want to use!
29628 @node X Cut and Paste, , Yanking Into Buffers, Kill and Yank
29629 @section X Cut and Paste
29632 If you are using Emacs with the X window system, there is an easier
29633 way to move small amounts of data into and out of the calculator:
29634 Use the mouse-oriented cut and paste facilities of X.
29636 The default bindings for a three-button mouse cause the left button
29637 to move the Emacs cursor to the given place, the right button to
29638 select the text between the cursor and the clicked location, and
29639 the middle button to yank the selection into the buffer at the
29640 clicked location. So, if you have a Calc window and an editing
29641 window on your Emacs screen, you can use left-click/right-click
29642 to select a number, vector, or formula from one window, then
29643 middle-click to paste that value into the other window. When you
29644 paste text into the Calc window, Calc interprets it as an algebraic
29645 entry. It doesn't matter where you click in the Calc window; the
29646 new value is always pushed onto the top of the stack.
29648 The @code{xterm} program that is typically used for general-purpose
29649 shell windows in X interprets the mouse buttons in the same way.
29650 So you can use the mouse to move data between Calc and any other
29651 Unix program. One nice feature of @code{xterm} is that a double
29652 left-click selects one word, and a triple left-click selects a
29653 whole line. So you can usually transfer a single number into Calc
29654 just by double-clicking on it in the shell, then middle-clicking
29655 in the Calc window.
29657 @node Keypad Mode, Embedded Mode, Kill and Yank, Top
29658 @chapter Keypad Mode
29662 @pindex calc-keypad
29663 The @kbd{M-# k} (@code{calc-keypad}) command starts the Calculator
29664 and displays a picture of a calculator-style keypad. If you are using
29665 the X window system, you can click on any of the ``keys'' in the
29666 keypad using the left mouse button to operate the calculator.
29667 The original window remains the selected window; in Keypad mode
29668 you can type in your file while simultaneously performing
29669 calculations with the mouse.
29671 @pindex full-calc-keypad
29672 If you have used @kbd{M-# b} first, @kbd{M-# k} instead invokes
29673 the @code{full-calc-keypad} command, which takes over the whole
29674 Emacs screen and displays the keypad, the Calc stack, and the Calc
29675 trail all at once. This mode would normally be used when running
29676 Calc standalone (@pxref{Standalone Operation}).
29678 If you aren't using the X window system, you must switch into
29679 the @samp{*Calc Keypad*} window, place the cursor on the desired
29680 ``key,'' and type @key{SPC} or @key{RET}. If you think this
29681 is easier than using Calc normally, go right ahead.
29683 Calc commands are more or less the same in Keypad mode. Certain
29684 keypad keys differ slightly from the corresponding normal Calc
29685 keystrokes; all such deviations are described below.
29687 Keypad mode includes many more commands than will fit on the keypad
29688 at once. Click the right mouse button [@code{calc-keypad-menu}]
29689 to switch to the next menu. The bottom five rows of the keypad
29690 stay the same; the top three rows change to a new set of commands.
29691 To return to earlier menus, click the middle mouse button
29692 [@code{calc-keypad-menu-back}] or simply advance through the menus
29693 until you wrap around. Typing @key{TAB} inside the keypad window
29694 is equivalent to clicking the right mouse button there.
29696 You can always click the @key{EXEC} button and type any normal
29697 Calc key sequence. This is equivalent to switching into the
29698 Calc buffer, typing the keys, then switching back to your
29702 * Keypad Main Menu::
29703 * Keypad Functions Menu::
29704 * Keypad Binary Menu::
29705 * Keypad Vectors Menu::
29706 * Keypad Modes Menu::
29709 @node Keypad Main Menu, Keypad Functions Menu, Keypad Mode, Keypad Mode
29714 |----+-----Calc 2.1------+----1
29715 |FLR |CEIL|RND |TRNC|CLN2|FLT |
29716 |----+----+----+----+----+----|
29717 | LN |EXP | |ABS |IDIV|MOD |
29718 |----+----+----+----+----+----|
29719 |SIN |COS |TAN |SQRT|y^x |1/x |
29720 |----+----+----+----+----+----|
29721 | ENTER |+/- |EEX |UNDO| <- |
29722 |-----+---+-+--+--+-+---++----|
29723 | INV | 7 | 8 | 9 | / |
29724 |-----+-----+-----+-----+-----|
29725 | HYP | 4 | 5 | 6 | * |
29726 |-----+-----+-----+-----+-----|
29727 |EXEC | 1 | 2 | 3 | - |
29728 |-----+-----+-----+-----+-----|
29729 | OFF | 0 | . | PI | + |
29730 |-----+-----+-----+-----+-----+
29735 This is the menu that appears the first time you start Keypad mode.
29736 It will show up in a vertical window on the right side of your screen.
29737 Above this menu is the traditional Calc stack display. On a 24-line
29738 screen you will be able to see the top three stack entries.
29740 The ten digit keys, decimal point, and @key{EEX} key are used for
29741 entering numbers in the obvious way. @key{EEX} begins entry of an
29742 exponent in scientific notation. Just as with regular Calc, the
29743 number is pushed onto the stack as soon as you press @key{ENTER}
29744 or any other function key.
29746 The @key{+/-} key corresponds to normal Calc's @kbd{n} key. During
29747 numeric entry it changes the sign of the number or of the exponent.
29748 At other times it changes the sign of the number on the top of the
29751 The @key{INV} and @key{HYP} keys modify other keys. As well as
29752 having the effects described elsewhere in this manual, Keypad mode
29753 defines several other ``inverse'' operations. These are described
29754 below and in the following sections.
29756 The @key{ENTER} key finishes the current numeric entry, or otherwise
29757 duplicates the top entry on the stack.
29759 The @key{UNDO} key undoes the most recent Calc operation.
29760 @kbd{INV UNDO} is the ``redo'' command, and @kbd{HYP UNDO} is
29761 ``last arguments'' (@kbd{M-@key{RET}}).
29763 The @key{<-} key acts as a ``backspace'' during numeric entry.
29764 At other times it removes the top stack entry. @kbd{INV <-}
29765 clears the entire stack. @kbd{HYP <-} takes an integer from
29766 the stack, then removes that many additional stack elements.
29768 The @key{EXEC} key prompts you to enter any keystroke sequence
29769 that would normally work in Calc mode. This can include a
29770 numeric prefix if you wish. It is also possible simply to
29771 switch into the Calc window and type commands in it; there is
29772 nothing ``magic'' about this window when Keypad mode is active.
29774 The other keys in this display perform their obvious calculator
29775 functions. @key{CLN2} rounds the top-of-stack by temporarily
29776 reducing the precision by 2 digits. @key{FLT} converts an
29777 integer or fraction on the top of the stack to floating-point.
29779 The @key{INV} and @key{HYP} keys combined with several of these keys
29780 give you access to some common functions even if the appropriate menu
29781 is not displayed. Obviously you don't need to learn these keys
29782 unless you find yourself wasting time switching among the menus.
29786 is the same as @key{1/x}.
29788 is the same as @key{SQRT}.
29790 is the same as @key{CONJ}.
29792 is the same as @key{y^x}.
29794 is the same as @key{INV y^x} (the @expr{x}th root of @expr{y}).
29796 are the same as @key{SIN} / @kbd{INV SIN}.
29798 are the same as @key{COS} / @kbd{INV COS}.
29800 are the same as @key{TAN} / @kbd{INV TAN}.
29802 are the same as @key{LN} / @kbd{HYP LN}.
29804 are the same as @key{EXP} / @kbd{HYP EXP}.
29806 is the same as @key{ABS}.
29808 is the same as @key{RND} (@code{calc-round}).
29810 is the same as @key{CLN2}.
29812 is the same as @key{FLT} (@code{calc-float}).
29814 is the same as @key{IMAG}.
29816 is the same as @key{PREC}.
29818 is the same as @key{SWAP}.
29820 is the same as @key{RLL3}.
29821 @item INV HYP ENTER
29822 is the same as @key{OVER}.
29824 packs the top two stack entries as an error form.
29826 packs the top two stack entries as a modulo form.
29828 creates an interval form; this removes an integer which is one
29829 of 0 @samp{[]}, 1 @samp{[)}, 2 @samp{(]} or 3 @samp{()}, followed
29830 by the two limits of the interval.
29833 The @kbd{OFF} key turns Calc off; typing @kbd{M-# k} or @kbd{M-# M-#}
29834 again has the same effect. This is analogous to typing @kbd{q} or
29835 hitting @kbd{M-# c} again in the normal calculator. If Calc is
29836 running standalone (the @code{full-calc-keypad} command appeared in the
29837 command line that started Emacs), then @kbd{OFF} is replaced with
29838 @kbd{EXIT}; clicking on this actually exits Emacs itself.
29840 @node Keypad Functions Menu, Keypad Binary Menu, Keypad Main Menu, Keypad Mode
29841 @section Functions Menu
29845 |----+----+----+----+----+----2
29846 |IGAM|BETA|IBET|ERF |BESJ|BESY|
29847 |----+----+----+----+----+----|
29848 |IMAG|CONJ| RE |ATN2|RAND|RAGN|
29849 |----+----+----+----+----+----|
29850 |GCD |FACT|DFCT|BNOM|PERM|NXTP|
29851 |----+----+----+----+----+----|
29856 This menu provides various operations from the @kbd{f} and @kbd{k}
29859 @key{IMAG} multiplies the number on the stack by the imaginary
29860 number @expr{i = (0, 1)}.
29862 @key{RE} extracts the real part a complex number. @kbd{INV RE}
29863 extracts the imaginary part.
29865 @key{RAND} takes a number from the top of the stack and computes
29866 a random number greater than or equal to zero but less than that
29867 number. (@xref{Random Numbers}.) @key{RAGN} is the ``random
29868 again'' command; it computes another random number using the
29869 same limit as last time.
29871 @key{INV GCD} computes the LCM (least common multiple) function.
29873 @key{INV FACT} is the gamma function.
29874 @texline @math{\Gamma(x) = (x-1)!}.
29875 @infoline @expr{gamma(x) = (x-1)!}.
29877 @key{PERM} is the number-of-permutations function, which is on the
29878 @kbd{H k c} key in normal Calc.
29880 @key{NXTP} finds the next prime after a number. @kbd{INV NXTP}
29881 finds the previous prime.
29883 @node Keypad Binary Menu, Keypad Vectors Menu, Keypad Functions Menu, Keypad Mode
29884 @section Binary Menu
29888 |----+----+----+----+----+----3
29889 |AND | OR |XOR |NOT |LSH |RSH |
29890 |----+----+----+----+----+----|
29891 |DEC |HEX |OCT |BIN |WSIZ|ARSH|
29892 |----+----+----+----+----+----|
29893 | A | B | C | D | E | F |
29894 |----+----+----+----+----+----|
29899 The keys in this menu perform operations on binary integers.
29900 Note that both logical and arithmetic right-shifts are provided.
29901 @key{INV LSH} rotates one bit to the left.
29903 The ``difference'' function (normally on @kbd{b d}) is on @key{INV AND}.
29904 The ``clip'' function (normally on @w{@kbd{b c}}) is on @key{INV NOT}.
29906 The @key{DEC}, @key{HEX}, @key{OCT}, and @key{BIN} keys select the
29907 current radix for display and entry of numbers: Decimal, hexadecimal,
29908 octal, or binary. The six letter keys @key{A} through @key{F} are used
29909 for entering hexadecimal numbers.
29911 The @key{WSIZ} key displays the current word size for binary operations
29912 and allows you to enter a new word size. You can respond to the prompt
29913 using either the keyboard or the digits and @key{ENTER} from the keypad.
29914 The initial word size is 32 bits.
29916 @node Keypad Vectors Menu, Keypad Modes Menu, Keypad Binary Menu, Keypad Mode
29917 @section Vectors Menu
29921 |----+----+----+----+----+----4
29922 |SUM |PROD|MAX |MAP*|MAP^|MAP$|
29923 |----+----+----+----+----+----|
29924 |MINV|MDET|MTRN|IDNT|CRSS|"x" |
29925 |----+----+----+----+----+----|
29926 |PACK|UNPK|INDX|BLD |LEN |... |
29927 |----+----+----+----+----+----|
29932 The keys in this menu operate on vectors and matrices.
29934 @key{PACK} removes an integer @var{n} from the top of the stack;
29935 the next @var{n} stack elements are removed and packed into a vector,
29936 which is replaced onto the stack. Thus the sequence
29937 @kbd{1 ENTER 3 ENTER 5 ENTER 3 PACK} enters the vector
29938 @samp{[1, 3, 5]} onto the stack. To enter a matrix, build each row
29939 on the stack as a vector, then use a final @key{PACK} to collect the
29940 rows into a matrix.
29942 @key{UNPK} unpacks the vector on the stack, pushing each of its
29943 components separately.
29945 @key{INDX} removes an integer @var{n}, then builds a vector of
29946 integers from 1 to @var{n}. @kbd{INV INDX} takes three numbers
29947 from the stack: The vector size @var{n}, the starting number,
29948 and the increment. @kbd{BLD} takes an integer @var{n} and any
29949 value @var{x} and builds a vector of @var{n} copies of @var{x}.
29951 @key{IDNT} removes an integer @var{n}, then builds an @var{n}-by-@var{n}
29954 @key{LEN} replaces a vector by its length, an integer.
29956 @key{...} turns on or off ``abbreviated'' display mode for large vectors.
29958 @key{MINV}, @key{MDET}, @key{MTRN}, and @key{CROSS} are the matrix
29959 inverse, determinant, and transpose, and vector cross product.
29961 @key{SUM} replaces a vector by the sum of its elements. It is
29962 equivalent to @kbd{u +} in normal Calc (@pxref{Statistical Operations}).
29963 @key{PROD} computes the product of the elements of a vector, and
29964 @key{MAX} computes the maximum of all the elements of a vector.
29966 @key{INV SUM} computes the alternating sum of the first element
29967 minus the second, plus the third, minus the fourth, and so on.
29968 @key{INV MAX} computes the minimum of the vector elements.
29970 @key{HYP SUM} computes the mean of the vector elements.
29971 @key{HYP PROD} computes the sample standard deviation.
29972 @key{HYP MAX} computes the median.
29974 @key{MAP*} multiplies two vectors elementwise. It is equivalent
29975 to the @kbd{V M *} command. @key{MAP^} computes powers elementwise.
29976 The arguments must be vectors of equal length, or one must be a vector
29977 and the other must be a plain number. For example, @kbd{2 MAP^} squares
29978 all the elements of a vector.
29980 @key{MAP$} maps the formula on the top of the stack across the
29981 vector in the second-to-top position. If the formula contains
29982 several variables, Calc takes that many vectors starting at the
29983 second-to-top position and matches them to the variables in
29984 alphabetical order. The result is a vector of the same size as
29985 the input vectors, whose elements are the formula evaluated with
29986 the variables set to the various sets of numbers in those vectors.
29987 For example, you could simulate @key{MAP^} using @key{MAP$} with
29988 the formula @samp{x^y}.
29990 The @kbd{"x"} key pushes the variable name @expr{x} onto the
29991 stack. To build the formula @expr{x^2 + 6}, you would use the
29992 key sequence @kbd{"x" 2 y^x 6 +}. This formula would then be
29993 suitable for use with the @key{MAP$} key described above.
29994 With @key{INV}, @key{HYP}, or @key{INV} and @key{HYP}, the
29995 @kbd{"x"} key pushes the variable names @expr{y}, @expr{z}, and
29996 @expr{t}, respectively.
29998 @node Keypad Modes Menu, , Keypad Vectors Menu, Keypad Mode
29999 @section Modes Menu
30003 |----+----+----+----+----+----5
30004 |FLT |FIX |SCI |ENG |GRP | |
30005 |----+----+----+----+----+----|
30006 |RAD |DEG |FRAC|POLR|SYMB|PREC|
30007 |----+----+----+----+----+----|
30008 |SWAP|RLL3|RLL4|OVER|STO |RCL |
30009 |----+----+----+----+----+----|
30014 The keys in this menu manipulate modes, variables, and the stack.
30016 The @key{FLT}, @key{FIX}, @key{SCI}, and @key{ENG} keys select
30017 floating-point, fixed-point, scientific, or engineering notation.
30018 @key{FIX} displays two digits after the decimal by default; the
30019 others display full precision. With the @key{INV} prefix, these
30020 keys pop a number-of-digits argument from the stack.
30022 The @key{GRP} key turns grouping of digits with commas on or off.
30023 @kbd{INV GRP} enables grouping to the right of the decimal point as
30024 well as to the left.
30026 The @key{RAD} and @key{DEG} keys switch between radians and degrees
30027 for trigonometric functions.
30029 The @key{FRAC} key turns Fraction mode on or off. This affects
30030 whether commands like @kbd{/} with integer arguments produce
30031 fractional or floating-point results.
30033 The @key{POLR} key turns Polar mode on or off, determining whether
30034 polar or rectangular complex numbers are used by default.
30036 The @key{SYMB} key turns Symbolic mode on or off, in which
30037 operations that would produce inexact floating-point results
30038 are left unevaluated as algebraic formulas.
30040 The @key{PREC} key selects the current precision. Answer with
30041 the keyboard or with the keypad digit and @key{ENTER} keys.
30043 The @key{SWAP} key exchanges the top two stack elements.
30044 The @key{RLL3} key rotates the top three stack elements upwards.
30045 The @key{RLL4} key rotates the top four stack elements upwards.
30046 The @key{OVER} key duplicates the second-to-top stack element.
30048 The @key{STO} and @key{RCL} keys are analogous to @kbd{s t} and
30049 @kbd{s r} in regular Calc. @xref{Store and Recall}. Click the
30050 @key{STO} or @key{RCL} key, then one of the ten digits. (Named
30051 variables are not available in Keypad mode.) You can also use,
30052 for example, @kbd{STO + 3} to add to register 3.
30054 @node Embedded Mode, Programming, Keypad Mode, Top
30055 @chapter Embedded Mode
30058 Embedded mode in Calc provides an alternative to copying numbers
30059 and formulas back and forth between editing buffers and the Calc
30060 stack. In Embedded mode, your editing buffer becomes temporarily
30061 linked to the stack and this copying is taken care of automatically.
30064 * Basic Embedded Mode::
30065 * More About Embedded Mode::
30066 * Assignments in Embedded Mode::
30067 * Mode Settings in Embedded Mode::
30068 * Customizing Embedded Mode::
30071 @node Basic Embedded Mode, More About Embedded Mode, Embedded Mode, Embedded Mode
30072 @section Basic Embedded Mode
30076 @pindex calc-embedded
30077 To enter Embedded mode, position the Emacs point (cursor) on a
30078 formula in any buffer and press @kbd{M-# e} (@code{calc-embedded}).
30079 Note that @kbd{M-# e} is not to be used in the Calc stack buffer
30080 like most Calc commands, but rather in regular editing buffers that
30081 are visiting your own files.
30083 Calc will try to guess an appropriate language based on the major mode
30084 of the editing buffer. (@xref{Language Modes}.) If the current buffer is
30085 in @code{latex-mode}, for example, Calc will set its language to La@TeX{}.
30086 Similarly, Calc will use @TeX{} language for @code{tex-mode},
30087 @code{plain-tex-mode} and @code{context-mode}, C language for
30088 @code{c-mode} and @code{c++-mode}, FORTRAN language for
30089 @code{fortran-mode} and @code{f90-mode}, Pascal for @code{pascal-mode},
30090 and eqn for @code{nroff-mode} (@pxref{Customizable Variables}).
30091 These can be overridden with Calc's mode
30092 changing commands (@pxref{Mode Settings in Embedded Mode}). If no
30093 suitable language is available, Calc will continue with its current language.
30095 Calc normally scans backward and forward in the buffer for the
30096 nearest opening and closing @dfn{formula delimiters}. The simplest
30097 delimiters are blank lines. Other delimiters that Embedded mode
30102 The @TeX{} and La@TeX{} math delimiters @samp{$ $}, @samp{$$ $$},
30103 @samp{\[ \]}, and @samp{\( \)};
30105 Lines beginning with @samp{\begin} and @samp{\end} (except matrix delimiters);
30107 Lines beginning with @samp{@@} (Texinfo delimiters).
30109 Lines beginning with @samp{.EQ} and @samp{.EN} (@dfn{eqn} delimiters);
30111 Lines containing a single @samp{%} or @samp{.\"} symbol and nothing else.
30114 @xref{Customizing Embedded Mode}, to see how to make Calc recognize
30115 your own favorite delimiters. Delimiters like @samp{$ $} can appear
30116 on their own separate lines or in-line with the formula.
30118 If you give a positive or negative numeric prefix argument, Calc
30119 instead uses the current point as one end of the formula, and includes
30120 that many lines forward or backward (respectively, including the current
30121 line). Explicit delimiters are not necessary in this case.
30123 With a prefix argument of zero, Calc uses the current region (delimited
30124 by point and mark) instead of formula delimiters. With a prefix
30125 argument of @kbd{C-u} only, Calc uses the current line as the formula.
30128 @pindex calc-embedded-word
30129 The @kbd{M-# w} (@code{calc-embedded-word}) command will start Embedded
30130 mode on the current ``word''; in this case Calc will scan for the first
30131 non-numeric character (i.e., the first character that is not a digit,
30132 sign, decimal point, or upper- or lower-case @samp{e}) forward and
30133 backward to delimit the formula.
30135 When you enable Embedded mode for a formula, Calc reads the text
30136 between the delimiters and tries to interpret it as a Calc formula.
30137 Calc can generally identify @TeX{} formulas and
30138 Big-style formulas even if the language mode is wrong. If Calc
30139 can't make sense of the formula, it beeps and refuses to enter
30140 Embedded mode. But if the current language is wrong, Calc can
30141 sometimes parse the formula successfully (but incorrectly);
30142 for example, the C expression @samp{atan(a[1])} can be parsed
30143 in Normal language mode, but the @code{atan} won't correspond to
30144 the built-in @code{arctan} function, and the @samp{a[1]} will be
30145 interpreted as @samp{a} times the vector @samp{[1]}!
30147 If you press @kbd{M-# e} or @kbd{M-# w} to activate an embedded
30148 formula which is blank, say with the cursor on the space between
30149 the two delimiters @samp{$ $}, Calc will immediately prompt for
30150 an algebraic entry.
30152 Only one formula in one buffer can be enabled at a time. If you
30153 move to another area of the current buffer and give Calc commands,
30154 Calc turns Embedded mode off for the old formula and then tries
30155 to restart Embedded mode at the new position. Other buffers are
30156 not affected by Embedded mode.
30158 When Embedded mode begins, Calc pushes the current formula onto
30159 the stack. No Calc stack window is created; however, Calc copies
30160 the top-of-stack position into the original buffer at all times.
30161 You can create a Calc window by hand with @kbd{M-# o} if you
30162 find you need to see the entire stack.
30164 For example, typing @kbd{M-# e} while somewhere in the formula
30165 @samp{n>2} in the following line enables Embedded mode on that
30169 We define $F_n = F_(n-1)+F_(n-2)$ for all $n>2$.
30173 The formula @expr{n>2} will be pushed onto the Calc stack, and
30174 the top of stack will be copied back into the editing buffer.
30175 This means that spaces will appear around the @samp{>} symbol
30176 to match Calc's usual display style:
30179 We define $F_n = F_(n-1)+F_(n-2)$ for all $n > 2$.
30183 No spaces have appeared around the @samp{+} sign because it's
30184 in a different formula, one which we have not yet touched with
30187 Now that Embedded mode is enabled, keys you type in this buffer
30188 are interpreted as Calc commands. At this point we might use
30189 the ``commute'' command @kbd{j C} to reverse the inequality.
30190 This is a selection-based command for which we first need to
30191 move the cursor onto the operator (@samp{>} in this case) that
30192 needs to be commuted.
30195 We define $F_n = F_(n-1)+F_(n-2)$ for all $2 < n$.
30198 The @kbd{M-# o} command is a useful way to open a Calc window
30199 without actually selecting that window. Giving this command
30200 verifies that @samp{2 < n} is also on the Calc stack. Typing
30201 @kbd{17 @key{RET}} would produce:
30204 We define $F_n = F_(n-1)+F_(n-2)$ for all $17$.
30208 with @samp{2 < n} and @samp{17} on the stack; typing @key{TAB}
30209 at this point will exchange the two stack values and restore
30210 @samp{2 < n} to the embedded formula. Even though you can't
30211 normally see the stack in Embedded mode, it is still there and
30212 it still operates in the same way. But, as with old-fashioned
30213 RPN calculators, you can only see the value at the top of the
30214 stack at any given time (unless you use @kbd{M-# o}).
30216 Typing @kbd{M-# e} again turns Embedded mode off. The Calc
30217 window reveals that the formula @w{@samp{2 < n}} is automatically
30218 removed from the stack, but the @samp{17} is not. Entering
30219 Embedded mode always pushes one thing onto the stack, and
30220 leaving Embedded mode always removes one thing. Anything else
30221 that happens on the stack is entirely your business as far as
30222 Embedded mode is concerned.
30224 If you press @kbd{M-# e} in the wrong place by accident, it is
30225 possible that Calc will be able to parse the nearby text as a
30226 formula and will mangle that text in an attempt to redisplay it
30227 ``properly'' in the current language mode. If this happens,
30228 press @kbd{M-# e} again to exit Embedded mode, then give the
30229 regular Emacs ``undo'' command (@kbd{C-_} or @kbd{C-x u}) to put
30230 the text back the way it was before Calc edited it. Note that Calc's
30231 own Undo command (typed before you turn Embedded mode back off)
30232 will not do you any good, because as far as Calc is concerned
30233 you haven't done anything with this formula yet.
30235 @node More About Embedded Mode, Assignments in Embedded Mode, Basic Embedded Mode, Embedded Mode
30236 @section More About Embedded Mode
30239 When Embedded mode ``activates'' a formula, i.e., when it examines
30240 the formula for the first time since the buffer was created or
30241 loaded, Calc tries to sense the language in which the formula was
30242 written. If the formula contains any La@TeX{}-like @samp{\} sequences,
30243 it is parsed (i.e., read) in La@TeX{} mode. If the formula appears to
30244 be written in multi-line Big mode, it is parsed in Big mode. Otherwise,
30245 it is parsed according to the current language mode.
30247 Note that Calc does not change the current language mode according
30248 the formula it reads in. Even though it can read a La@TeX{} formula when
30249 not in La@TeX{} mode, it will immediately rewrite this formula using
30250 whatever language mode is in effect.
30257 @pindex calc-show-plain
30258 Calc's parser is unable to read certain kinds of formulas. For
30259 example, with @kbd{v ]} (@code{calc-matrix-brackets}) you can
30260 specify matrix display styles which the parser is unable to
30261 recognize as matrices. The @kbd{d p} (@code{calc-show-plain})
30262 command turns on a mode in which a ``plain'' version of a
30263 formula is placed in front of the fully-formatted version.
30264 When Calc reads a formula that has such a plain version in
30265 front, it reads the plain version and ignores the formatted
30268 Plain formulas are preceded and followed by @samp{%%%} signs
30269 by default. This notation has the advantage that the @samp{%}
30270 character begins a comment in @TeX{} and La@TeX{}, so if your formula is
30271 embedded in a @TeX{} or La@TeX{} document its plain version will be
30272 invisible in the final printed copy. Certain major modes have different
30273 delimiters to ensure that the ``plain'' version will be
30274 in a comment for those modes, also.
30275 See @ref{Customizing Embedded Mode} to see how to change the ``plain''
30276 formula delimiters.
30278 There are several notations which Calc's parser for ``big''
30279 formatted formulas can't yet recognize. In particular, it can't
30280 read the large symbols for @code{sum}, @code{prod}, and @code{integ},
30281 and it can't handle @samp{=>} with the righthand argument omitted.
30282 Also, Calc won't recognize special formats you have defined with
30283 the @kbd{Z C} command (@pxref{User-Defined Compositions}). In
30284 these cases it is important to use ``plain'' mode to make sure
30285 Calc will be able to read your formula later.
30287 Another example where ``plain'' mode is important is if you have
30288 specified a float mode with few digits of precision. Normally
30289 any digits that are computed but not displayed will simply be
30290 lost when you save and re-load your embedded buffer, but ``plain''
30291 mode allows you to make sure that the complete number is present
30292 in the file as well as the rounded-down number.
30298 Embedded buffers remember active formulas for as long as they
30299 exist in Emacs memory. Suppose you have an embedded formula
30300 which is @cpi{} to the normal 12 decimal places, and then
30301 type @w{@kbd{C-u 5 d n}} to display only five decimal places.
30302 If you then type @kbd{d n}, all 12 places reappear because the
30303 full number is still there on the Calc stack. More surprisingly,
30304 even if you exit Embedded mode and later re-enter it for that
30305 formula, typing @kbd{d n} will restore all 12 places because
30306 each buffer remembers all its active formulas. However, if you
30307 save the buffer in a file and reload it in a new Emacs session,
30308 all non-displayed digits will have been lost unless you used
30315 In some applications of Embedded mode, you will want to have a
30316 sequence of copies of a formula that show its evolution as you
30317 work on it. For example, you might want to have a sequence
30318 like this in your file (elaborating here on the example from
30319 the ``Getting Started'' chapter):
30328 @r{(the derivative of }ln(ln(x))@r{)}
30330 whose value at x = 2 is
30340 @pindex calc-embedded-duplicate
30341 The @kbd{M-# d} (@code{calc-embedded-duplicate}) command is a
30342 handy way to make sequences like this. If you type @kbd{M-# d},
30343 the formula under the cursor (which may or may not have Embedded
30344 mode enabled for it at the time) is copied immediately below and
30345 Embedded mode is then enabled for that copy.
30347 For this example, you would start with just
30356 and press @kbd{M-# d} with the cursor on this formula. The result
30369 with the second copy of the formula enabled in Embedded mode.
30370 You can now press @kbd{a d x @key{RET}} to take the derivative, and
30371 @kbd{M-# d M-# d} to make two more copies of the derivative.
30372 To complete the computations, type @kbd{3 s l x @key{RET}} to evaluate
30373 the last formula, then move up to the second-to-last formula
30374 and type @kbd{2 s l x @key{RET}}.
30376 Finally, you would want to press @kbd{M-# e} to exit Embedded
30377 mode, then go up and insert the necessary text in between the
30378 various formulas and numbers.
30386 @pindex calc-embedded-new-formula
30387 The @kbd{M-# f} (@code{calc-embedded-new-formula}) command
30388 creates a new embedded formula at the current point. It inserts
30389 some default delimiters, which are usually just blank lines,
30390 and then does an algebraic entry to get the formula (which is
30391 then enabled for Embedded mode). This is just shorthand for
30392 typing the delimiters yourself, positioning the cursor between
30393 the new delimiters, and pressing @kbd{M-# e}. The key sequence
30394 @kbd{M-# '} is equivalent to @kbd{M-# f}.
30398 @pindex calc-embedded-next
30399 @pindex calc-embedded-previous
30400 The @kbd{M-# n} (@code{calc-embedded-next}) and @kbd{M-# p}
30401 (@code{calc-embedded-previous}) commands move the cursor to the
30402 next or previous active embedded formula in the buffer. They
30403 can take positive or negative prefix arguments to move by several
30404 formulas. Note that these commands do not actually examine the
30405 text of the buffer looking for formulas; they only see formulas
30406 which have previously been activated in Embedded mode. In fact,
30407 @kbd{M-# n} and @kbd{M-# p} are a useful way to tell which
30408 embedded formulas are currently active. Also, note that these
30409 commands do not enable Embedded mode on the next or previous
30410 formula, they just move the cursor. (By the way, @kbd{M-# n} is
30411 not as awkward to type as it may seem, because @kbd{M-#} ignores
30412 Shift and Meta on the second keystroke: @kbd{M-# M-N} can be typed
30413 by holding down Shift and Meta and alternately typing two keys.)
30416 @pindex calc-embedded-edit
30417 The @kbd{M-# `} (@code{calc-embedded-edit}) command edits the
30418 embedded formula at the current point as if by @kbd{`} (@code{calc-edit}).
30419 Embedded mode does not have to be enabled for this to work. Press
30420 @kbd{C-c C-c} to finish the edit, or @kbd{C-x k} to cancel.
30422 @node Assignments in Embedded Mode, Mode Settings in Embedded Mode, More About Embedded Mode, Embedded Mode
30423 @section Assignments in Embedded Mode
30426 The @samp{:=} (assignment) and @samp{=>} (``evaluates-to'') operators
30427 are especially useful in Embedded mode. They allow you to make
30428 a definition in one formula, then refer to that definition in
30429 other formulas embedded in the same buffer.
30431 An embedded formula which is an assignment to a variable, as in
30438 records @expr{5} as the stored value of @code{foo} for the
30439 purposes of Embedded mode operations in the current buffer. It
30440 does @emph{not} actually store @expr{5} as the ``global'' value
30441 of @code{foo}, however. Regular Calc operations, and Embedded
30442 formulas in other buffers, will not see this assignment.
30444 One way to use this assigned value is simply to create an
30445 Embedded formula elsewhere that refers to @code{foo}, and to press
30446 @kbd{=} in that formula. However, this permanently replaces the
30447 @code{foo} in the formula with its current value. More interesting
30448 is to use @samp{=>} elsewhere:
30454 @xref{Evaluates-To Operator}, for a general discussion of @samp{=>}.
30456 If you move back and change the assignment to @code{foo}, any
30457 @samp{=>} formulas which refer to it are automatically updated.
30465 The obvious question then is, @emph{how} can one easily change the
30466 assignment to @code{foo}? If you simply select the formula in
30467 Embedded mode and type 17, the assignment itself will be replaced
30468 by the 17. The effect on the other formula will be that the
30469 variable @code{foo} becomes unassigned:
30477 The right thing to do is first to use a selection command (@kbd{j 2}
30478 will do the trick) to select the righthand side of the assignment.
30479 Then, @kbd{17 @key{TAB} @key{DEL}} will swap the 17 into place (@pxref{Selecting
30480 Subformulas}, to see how this works).
30483 @pindex calc-embedded-select
30484 The @kbd{M-# j} (@code{calc-embedded-select}) command provides an
30485 easy way to operate on assignments. It is just like @kbd{M-# e},
30486 except that if the enabled formula is an assignment, it uses
30487 @kbd{j 2} to select the righthand side. If the enabled formula
30488 is an evaluates-to, it uses @kbd{j 1} to select the lefthand side.
30489 A formula can also be a combination of both:
30492 bar := foo + 3 => 20
30496 in which case @kbd{M-# j} will select the middle part (@samp{foo + 3}).
30498 The formula is automatically deselected when you leave Embedded
30503 @pindex calc-embedded-update-formula
30504 Another way to change the assignment to @code{foo} would simply be
30505 to edit the number using regular Emacs editing rather than Embedded
30506 mode. Then, we have to find a way to get Embedded mode to notice
30507 the change. The @kbd{M-# u} or @kbd{M-# =}
30508 (@code{calc-embedded-update-formula}) command is a convenient way
30517 Pressing @kbd{M-# u} is much like pressing @kbd{M-# e = M-# e}, that
30518 is, temporarily enabling Embedded mode for the formula under the
30519 cursor and then evaluating it with @kbd{=}. But @kbd{M-# u} does
30520 not actually use @kbd{M-# e}, and in fact another formula somewhere
30521 else can be enabled in Embedded mode while you use @kbd{M-# u} and
30522 that formula will not be disturbed.
30524 With a numeric prefix argument, @kbd{M-# u} updates all active
30525 @samp{=>} formulas in the buffer. Formulas which have not yet
30526 been activated in Embedded mode, and formulas which do not have
30527 @samp{=>} as their top-level operator, are not affected by this.
30528 (This is useful only if you have used @kbd{m C}; see below.)
30530 With a plain @kbd{C-u} prefix, @kbd{C-u M-# u} updates only in the
30531 region between mark and point rather than in the whole buffer.
30533 @kbd{M-# u} is also a handy way to activate a formula, such as an
30534 @samp{=>} formula that has freshly been typed in or loaded from a
30538 @pindex calc-embedded-activate
30539 The @kbd{M-# a} (@code{calc-embedded-activate}) command scans
30540 through the current buffer and activates all embedded formulas
30541 that contain @samp{:=} or @samp{=>} symbols. This does not mean
30542 that Embedded mode is actually turned on, but only that the
30543 formulas' positions are registered with Embedded mode so that
30544 the @samp{=>} values can be properly updated as assignments are
30547 It is a good idea to type @kbd{M-# a} right after loading a file
30548 that uses embedded @samp{=>} operators. Emacs includes a nifty
30549 ``buffer-local variables'' feature that you can use to do this
30550 automatically. The idea is to place near the end of your file
30551 a few lines that look like this:
30554 --- Local Variables: ---
30555 --- eval:(calc-embedded-activate) ---
30560 where the leading and trailing @samp{---} can be replaced by
30561 any suitable strings (which must be the same on all three lines)
30562 or omitted altogether; in a @TeX{} or La@TeX{} file, @samp{%} would be a good
30563 leading string and no trailing string would be necessary. In a
30564 C program, @samp{/*} and @samp{*/} would be good leading and
30567 When Emacs loads a file into memory, it checks for a Local Variables
30568 section like this one at the end of the file. If it finds this
30569 section, it does the specified things (in this case, running
30570 @kbd{M-# a} automatically) before editing of the file begins.
30571 The Local Variables section must be within 3000 characters of the
30572 end of the file for Emacs to find it, and it must be in the last
30573 page of the file if the file has any page separators.
30574 @xref{File Variables, , Local Variables in Files, emacs, the
30577 Note that @kbd{M-# a} does not update the formulas it finds.
30578 To do this, type, say, @kbd{M-1 M-# u} after @w{@kbd{M-# a}}.
30579 Generally this should not be a problem, though, because the
30580 formulas will have been up-to-date already when the file was
30583 Normally, @kbd{M-# a} activates all the formulas it finds, but
30584 any previous active formulas remain active as well. With a
30585 positive numeric prefix argument, @kbd{M-# a} first deactivates
30586 all current active formulas, then actives the ones it finds in
30587 its scan of the buffer. With a negative prefix argument,
30588 @kbd{M-# a} simply deactivates all formulas.
30590 Embedded mode has two symbols, @samp{Active} and @samp{~Active},
30591 which it puts next to the major mode name in a buffer's mode line.
30592 It puts @samp{Active} if it has reason to believe that all
30593 formulas in the buffer are active, because you have typed @kbd{M-# a}
30594 and Calc has not since had to deactivate any formulas (which can
30595 happen if Calc goes to update an @samp{=>} formula somewhere because
30596 a variable changed, and finds that the formula is no longer there
30597 due to some kind of editing outside of Embedded mode). Calc puts
30598 @samp{~Active} in the mode line if some, but probably not all,
30599 formulas in the buffer are active. This happens if you activate
30600 a few formulas one at a time but never use @kbd{M-# a}, or if you
30601 used @kbd{M-# a} but then Calc had to deactivate a formula
30602 because it lost track of it. If neither of these symbols appears
30603 in the mode line, no embedded formulas are active in the buffer
30604 (e.g., before Embedded mode has been used, or after a @kbd{M-- M-# a}).
30606 Embedded formulas can refer to assignments both before and after them
30607 in the buffer. If there are several assignments to a variable, the
30608 nearest preceding assignment is used if there is one, otherwise the
30609 following assignment is used.
30623 As well as simple variables, you can also assign to subscript
30624 expressions of the form @samp{@var{var}_@var{number}} (as in
30625 @code{x_0}), or @samp{@var{var}_@var{var}} (as in @code{x_max}).
30626 Assignments to other kinds of objects can be represented by Calc,
30627 but the automatic linkage between assignments and references works
30628 only for plain variables and these two kinds of subscript expressions.
30630 If there are no assignments to a given variable, the global
30631 stored value for the variable is used (@pxref{Storing Variables}),
30632 or, if no value is stored, the variable is left in symbolic form.
30633 Note that global stored values will be lost when the file is saved
30634 and loaded in a later Emacs session, unless you have used the
30635 @kbd{s p} (@code{calc-permanent-variable}) command to save them;
30636 @pxref{Operations on Variables}.
30638 The @kbd{m C} (@code{calc-auto-recompute}) command turns automatic
30639 recomputation of @samp{=>} forms on and off. If you turn automatic
30640 recomputation off, you will have to use @kbd{M-# u} to update these
30641 formulas manually after an assignment has been changed. If you
30642 plan to change several assignments at once, it may be more efficient
30643 to type @kbd{m C}, change all the assignments, then use @kbd{M-1 M-# u}
30644 to update the entire buffer afterwards. The @kbd{m C} command also
30645 controls @samp{=>} formulas on the stack; @pxref{Evaluates-To
30646 Operator}. When you turn automatic recomputation back on, the
30647 stack will be updated but the Embedded buffer will not; you must
30648 use @kbd{M-# u} to update the buffer by hand.
30650 @node Mode Settings in Embedded Mode, Customizing Embedded Mode, Assignments in Embedded Mode, Embedded Mode
30651 @section Mode Settings in Embedded Mode
30654 @pindex calc-embedded-preserve-modes
30656 The mode settings can be changed while Calc is in embedded mode, but
30657 by default they will revert to their original values when embedded mode
30658 is ended. However, the modes saved when the mode-recording mode is
30659 @code{Save} (see below) and the modes in effect when the @kbd{m e}
30660 (@code{calc-embedded-preserve-modes}) command is given
30661 will be preserved when embedded mode is ended.
30663 Embedded mode has a rather complicated mechanism for handling mode
30664 settings in Embedded formulas. It is possible to put annotations
30665 in the file that specify mode settings either global to the entire
30666 file or local to a particular formula or formulas. In the latter
30667 case, different modes can be specified for use when a formula
30668 is the enabled Embedded mode formula.
30670 When you give any mode-setting command, like @kbd{m f} (for Fraction
30671 mode) or @kbd{d s} (for scientific notation), Embedded mode adds
30672 a line like the following one to the file just before the opening
30673 delimiter of the formula.
30676 % [calc-mode: fractions: t]
30677 % [calc-mode: float-format: (sci 0)]
30680 When Calc interprets an embedded formula, it scans the text before
30681 the formula for mode-setting annotations like these and sets the
30682 Calc buffer to match these modes. Modes not explicitly described
30683 in the file are not changed. Calc scans all the way to the top of
30684 the file, or up to a line of the form
30691 which you can insert at strategic places in the file if this backward
30692 scan is getting too slow, or just to provide a barrier between one
30693 ``zone'' of mode settings and another.
30695 If the file contains several annotations for the same mode, the
30696 closest one before the formula is used. Annotations after the
30697 formula are never used (except for global annotations, described
30700 The scan does not look for the leading @samp{% }, only for the
30701 square brackets and the text they enclose. In fact, the leading
30702 characters are different for different major modes. You can edit the
30703 mode annotations to a style that works better in context if you wish.
30704 @xref{Customizing Embedded Mode}, to see how to change the style
30705 that Calc uses when it generates the annotations. You can write
30706 mode annotations into the file yourself if you know the syntax;
30707 the easiest way to find the syntax for a given mode is to let
30708 Calc write the annotation for it once and see what it does.
30710 If you give a mode-changing command for a mode that already has
30711 a suitable annotation just above the current formula, Calc will
30712 modify that annotation rather than generating a new, conflicting
30715 Mode annotations have three parts, separated by colons. (Spaces
30716 after the colons are optional.) The first identifies the kind
30717 of mode setting, the second is a name for the mode itself, and
30718 the third is the value in the form of a Lisp symbol, number,
30719 or list. Annotations with unrecognizable text in the first or
30720 second parts are ignored. The third part is not checked to make
30721 sure the value is of a valid type or range; if you write an
30722 annotation by hand, be sure to give a proper value or results
30723 will be unpredictable. Mode-setting annotations are case-sensitive.
30725 While Embedded mode is enabled, the word @code{Local} appears in
30726 the mode line. This is to show that mode setting commands generate
30727 annotations that are ``local'' to the current formula or set of
30728 formulas. The @kbd{m R} (@code{calc-mode-record-mode}) command
30729 causes Calc to generate different kinds of annotations. Pressing
30730 @kbd{m R} repeatedly cycles through the possible modes.
30732 @code{LocEdit} and @code{LocPerm} modes generate annotations
30733 that look like this, respectively:
30736 % [calc-edit-mode: float-format: (sci 0)]
30737 % [calc-perm-mode: float-format: (sci 5)]
30740 The first kind of annotation will be used only while a formula
30741 is enabled in Embedded mode. The second kind will be used only
30742 when the formula is @emph{not} enabled. (Whether the formula
30743 is ``active'' or not, i.e., whether Calc has seen this formula
30744 yet, is not relevant here.)
30746 @code{Global} mode generates an annotation like this at the end
30750 % [calc-global-mode: fractions t]
30753 Global mode annotations affect all formulas throughout the file,
30754 and may appear anywhere in the file. This allows you to tuck your
30755 mode annotations somewhere out of the way, say, on a new page of
30756 the file, as long as those mode settings are suitable for all
30757 formulas in the file.
30759 Enabling a formula with @kbd{M-# e} causes a fresh scan for local
30760 mode annotations; you will have to use this after adding annotations
30761 above a formula by hand to get the formula to notice them. Updating
30762 a formula with @kbd{M-# u} will also re-scan the local modes, but
30763 global modes are only re-scanned by @kbd{M-# a}.
30765 Another way that modes can get out of date is if you add a local
30766 mode annotation to a formula that has another formula after it.
30767 In this example, we have used the @kbd{d s} command while the
30768 first of the two embedded formulas is active. But the second
30769 formula has not changed its style to match, even though by the
30770 rules of reading annotations the @samp{(sci 0)} applies to it, too.
30773 % [calc-mode: float-format: (sci 0)]
30779 We would have to go down to the other formula and press @kbd{M-# u}
30780 on it in order to get it to notice the new annotation.
30782 Two more mode-recording modes selectable by @kbd{m R} are available
30783 which are also available outside of Embedded mode.
30784 (@pxref{General Mode Commands}.) They are @code{Save}, in which mode
30785 settings are recorded permanently in your Calc init file (the file given
30786 by the variable @code{calc-settings-file}, typically @file{~/.calc.el})
30787 rather than by annotating the current document, and no-recording
30788 mode (where there is no symbol like @code{Save} or @code{Local} in
30789 the mode line), in which mode-changing commands do not leave any
30790 annotations at all.
30792 When Embedded mode is not enabled, mode-recording modes except
30793 for @code{Save} have no effect.
30795 @node Customizing Embedded Mode, , Mode Settings in Embedded Mode, Embedded Mode
30796 @section Customizing Embedded Mode
30799 You can modify Embedded mode's behavior by setting various Lisp
30800 variables described here. These variables are customizable
30801 (@pxref{Customizable Variables}), or you can use @kbd{M-x set-variable}
30802 or @kbd{M-x edit-options} to adjust a variable on the fly.
30803 (Another possibility would be to use a file-local variable annotation at
30804 the end of the file;
30805 @pxref{File Variables, , Local Variables in Files, emacs, the Emacs manual}.)
30806 Many of the variables given mentioned here can be set to depend on the
30807 major mode of the editing buffer (@pxref{Customizable Variables}).
30809 @vindex calc-embedded-open-formula
30810 The @code{calc-embedded-open-formula} variable holds a regular
30811 expression for the opening delimiter of a formula. @xref{Regexp Search,
30812 , Regular Expression Search, emacs, the Emacs manual}, to see
30813 how regular expressions work. Basically, a regular expression is a
30814 pattern that Calc can search for. A regular expression that considers
30815 blank lines, @samp{$}, and @samp{$$} to be opening delimiters is
30816 @code{"\\`\\|^\n\\|\\$\\$?"}. Just in case the meaning of this
30817 regular expression is not completely plain, let's go through it
30820 The surrounding @samp{" "} marks quote the text between them as a
30821 Lisp string. If you left them off, @code{set-variable} or
30822 @code{edit-options} would try to read the regular expression as a
30825 The most obvious property of this regular expression is that it
30826 contains indecently many backslashes. There are actually two levels
30827 of backslash usage going on here. First, when Lisp reads a quoted
30828 string, all pairs of characters beginning with a backslash are
30829 interpreted as special characters. Here, @code{\n} changes to a
30830 new-line character, and @code{\\} changes to a single backslash.
30831 So the actual regular expression seen by Calc is
30832 @samp{\`\|^ @r{(newline)} \|\$\$?}.
30834 Regular expressions also consider pairs beginning with backslash
30835 to have special meanings. Sometimes the backslash is used to quote
30836 a character that otherwise would have a special meaning in a regular
30837 expression, like @samp{$}, which normally means ``end-of-line,''
30838 or @samp{?}, which means that the preceding item is optional. So
30839 @samp{\$\$?} matches either one or two dollar signs.
30841 The other codes in this regular expression are @samp{^}, which matches
30842 ``beginning-of-line,'' @samp{\|}, which means ``or,'' and @samp{\`},
30843 which matches ``beginning-of-buffer.'' So the whole pattern means
30844 that a formula begins at the beginning of the buffer, or on a newline
30845 that occurs at the beginning of a line (i.e., a blank line), or at
30846 one or two dollar signs.
30848 The default value of @code{calc-embedded-open-formula} looks just
30849 like this example, with several more alternatives added on to
30850 recognize various other common kinds of delimiters.
30852 By the way, the reason to use @samp{^\n} rather than @samp{^$}
30853 or @samp{\n\n}, which also would appear to match blank lines,
30854 is that the former expression actually ``consumes'' only one
30855 newline character as @emph{part of} the delimiter, whereas the
30856 latter expressions consume zero or two newlines, respectively.
30857 The former choice gives the most natural behavior when Calc
30858 must operate on a whole formula including its delimiters.
30860 See the Emacs manual for complete details on regular expressions.
30861 But just for your convenience, here is a list of all characters
30862 which must be quoted with backslash (like @samp{\$}) to avoid
30863 some special interpretation: @samp{. * + ? [ ] ^ $ \}. (Note
30864 the backslash in this list; for example, to match @samp{\[} you
30865 must use @code{"\\\\\\["}. An exercise for the reader is to
30866 account for each of these six backslashes!)
30868 @vindex calc-embedded-close-formula
30869 The @code{calc-embedded-close-formula} variable holds a regular
30870 expression for the closing delimiter of a formula. A closing
30871 regular expression to match the above example would be
30872 @code{"\\'\\|\n$\\|\\$\\$?"}. This is almost the same as the
30873 other one, except it now uses @samp{\'} (``end-of-buffer'') and
30874 @samp{\n$} (newline occurring at end of line, yet another way
30875 of describing a blank line that is more appropriate for this
30878 @vindex calc-embedded-open-word
30879 @vindex calc-embedded-close-word
30880 The @code{calc-embedded-open-word} and @code{calc-embedded-close-word}
30881 variables are similar expressions used when you type @kbd{M-# w}
30882 instead of @kbd{M-# e} to enable Embedded mode.
30884 @vindex calc-embedded-open-plain
30885 The @code{calc-embedded-open-plain} variable is a string which
30886 begins a ``plain'' formula written in front of the formatted
30887 formula when @kbd{d p} mode is turned on. Note that this is an
30888 actual string, not a regular expression, because Calc must be able
30889 to write this string into a buffer as well as to recognize it.
30890 The default string is @code{"%%% "} (note the trailing space), but may
30891 be different for certain major modes.
30893 @vindex calc-embedded-close-plain
30894 The @code{calc-embedded-close-plain} variable is a string which
30895 ends a ``plain'' formula. The default is @code{" %%%\n"}, but may be
30896 different for different major modes. Without
30897 the trailing newline here, the first line of a Big mode formula
30898 that followed might be shifted over with respect to the other lines.
30900 @vindex calc-embedded-open-new-formula
30901 The @code{calc-embedded-open-new-formula} variable is a string
30902 which is inserted at the front of a new formula when you type
30903 @kbd{M-# f}. Its default value is @code{"\n\n"}. If this
30904 string begins with a newline character and the @kbd{M-# f} is
30905 typed at the beginning of a line, @kbd{M-# f} will skip this
30906 first newline to avoid introducing unnecessary blank lines in
30909 @vindex calc-embedded-close-new-formula
30910 The @code{calc-embedded-close-new-formula} variable is the corresponding
30911 string which is inserted at the end of a new formula. Its default
30912 value is also @code{"\n\n"}. The final newline is omitted by
30913 @w{@kbd{M-# f}} if typed at the end of a line. (It follows that if
30914 @kbd{M-# f} is typed on a blank line, both a leading opening
30915 newline and a trailing closing newline are omitted.)
30917 @vindex calc-embedded-announce-formula
30918 The @code{calc-embedded-announce-formula} variable is a regular
30919 expression which is sure to be followed by an embedded formula.
30920 The @kbd{M-# a} command searches for this pattern as well as for
30921 @samp{=>} and @samp{:=} operators. Note that @kbd{M-# a} will
30922 not activate just anything surrounded by formula delimiters; after
30923 all, blank lines are considered formula delimiters by default!
30924 But if your language includes a delimiter which can only occur
30925 actually in front of a formula, you can take advantage of it here.
30926 The default pattern is @code{"%Embed\n\\(% .*\n\\)*"}, but may be
30927 different for different major modes.
30928 This pattern will check for @samp{%Embed} followed by any number of
30929 lines beginning with @samp{%} and a space. This last is important to
30930 make Calc consider mode annotations part of the pattern, so that the
30931 formula's opening delimiter really is sure to follow the pattern.
30933 @vindex calc-embedded-open-mode
30934 The @code{calc-embedded-open-mode} variable is a string (not a
30935 regular expression) which should precede a mode annotation.
30936 Calc never scans for this string; Calc always looks for the
30937 annotation itself. But this is the string that is inserted before
30938 the opening bracket when Calc adds an annotation on its own.
30939 The default is @code{"% "}, but may be different for different major
30942 @vindex calc-embedded-close-mode
30943 The @code{calc-embedded-close-mode} variable is a string which
30944 follows a mode annotation written by Calc. Its default value
30945 is simply a newline, @code{"\n"}, but may be different for different
30946 major modes. If you change this, it is a good idea still to end with a
30947 newline so that mode annotations will appear on lines by themselves.
30949 @node Programming, Customizable Variables, Embedded Mode, Top
30950 @chapter Programming
30953 There are several ways to ``program'' the Emacs Calculator, depending
30954 on the nature of the problem you need to solve.
30958 @dfn{Keyboard macros} allow you to record a sequence of keystrokes
30959 and play them back at a later time. This is just the standard Emacs
30960 keyboard macro mechanism, dressed up with a few more features such
30961 as loops and conditionals.
30964 @dfn{Algebraic definitions} allow you to use any formula to define a
30965 new function. This function can then be used in algebraic formulas or
30966 as an interactive command.
30969 @dfn{Rewrite rules} are discussed in the section on algebra commands.
30970 @xref{Rewrite Rules}. If you put your rewrite rules in the variable
30971 @code{EvalRules}, they will be applied automatically to all Calc
30972 results in just the same way as an internal ``rule'' is applied to
30973 evaluate @samp{sqrt(9)} to 3 and so on. @xref{Automatic Rewrites}.
30976 @dfn{Lisp} is the programming language that Calc (and most of Emacs)
30977 is written in. If the above techniques aren't powerful enough, you
30978 can write Lisp functions to do anything that built-in Calc commands
30979 can do. Lisp code is also somewhat faster than keyboard macros or
30984 Programming features are available through the @kbd{z} and @kbd{Z}
30985 prefix keys. New commands that you define are two-key sequences
30986 beginning with @kbd{z}. Commands for managing these definitions
30987 use the shift-@kbd{Z} prefix. (The @kbd{Z T} (@code{calc-timing})
30988 command is described elsewhere; @pxref{Troubleshooting Commands}.
30989 The @kbd{Z C} (@code{calc-user-define-composition}) command is also
30990 described elsewhere; @pxref{User-Defined Compositions}.)
30993 * Creating User Keys::
30994 * Keyboard Macros::
30995 * Invocation Macros::
30996 * Algebraic Definitions::
30997 * Lisp Definitions::
31000 @node Creating User Keys, Keyboard Macros, Programming, Programming
31001 @section Creating User Keys
31005 @pindex calc-user-define
31006 Any Calculator command may be bound to a key using the @kbd{Z D}
31007 (@code{calc-user-define}) command. Actually, it is bound to a two-key
31008 sequence beginning with the lower-case @kbd{z} prefix.
31010 The @kbd{Z D} command first prompts for the key to define. For example,
31011 press @kbd{Z D a} to define the new key sequence @kbd{z a}. You are then
31012 prompted for the name of the Calculator command that this key should
31013 run. For example, the @code{calc-sincos} command is not normally
31014 available on a key. Typing @kbd{Z D s sincos @key{RET}} programs the
31015 @kbd{z s} key sequence to run @code{calc-sincos}. This definition will remain
31016 in effect for the rest of this Emacs session, or until you redefine
31017 @kbd{z s} to be something else.
31019 You can actually bind any Emacs command to a @kbd{z} key sequence by
31020 backspacing over the @samp{calc-} when you are prompted for the command name.
31022 As with any other prefix key, you can type @kbd{z ?} to see a list of
31023 all the two-key sequences you have defined that start with @kbd{z}.
31024 Initially, no @kbd{z} sequences (except @kbd{z ?} itself) are defined.
31026 User keys are typically letters, but may in fact be any key.
31027 (@key{META}-keys are not permitted, nor are a terminal's special
31028 function keys which generate multi-character sequences when pressed.)
31029 You can define different commands on the shifted and unshifted versions
31030 of a letter if you wish.
31033 @pindex calc-user-undefine
31034 The @kbd{Z U} (@code{calc-user-undefine}) command unbinds a user key.
31035 For example, the key sequence @kbd{Z U s} will undefine the @code{sincos}
31036 key we defined above.
31039 @pindex calc-user-define-permanent
31040 @cindex Storing user definitions
31041 @cindex Permanent user definitions
31042 @cindex Calc init file, user-defined commands
31043 The @kbd{Z P} (@code{calc-user-define-permanent}) command makes a key
31044 binding permanent so that it will remain in effect even in future Emacs
31045 sessions. (It does this by adding a suitable bit of Lisp code into
31046 your Calc init file; that is, the file given by the variable
31047 @code{calc-settings-file}, typically @file{~/.calc.el}.) For example,
31048 @kbd{Z P s} would register our @code{sincos} command permanently. If
31049 you later wish to unregister this command you must edit your Calc init
31050 file by hand. (@xref{General Mode Commands}, for a way to tell Calc to
31051 use a different file for the Calc init file.)
31053 The @kbd{Z P} command also saves the user definition, if any, for the
31054 command bound to the key. After @kbd{Z F} and @kbd{Z C}, a given user
31055 key could invoke a command, which in turn calls an algebraic function,
31056 which might have one or more special display formats. A single @kbd{Z P}
31057 command will save all of these definitions.
31058 To save an algebraic function, type @kbd{'} (the apostrophe)
31059 when prompted for a key, and type the function name. To save a command
31060 without its key binding, type @kbd{M-x} and enter a function name. (The
31061 @samp{calc-} prefix will automatically be inserted for you.)
31062 (If the command you give implies a function, the function will be saved,
31063 and if the function has any display formats, those will be saved, but
31064 not the other way around: Saving a function will not save any commands
31065 or key bindings associated with the function.)
31068 @pindex calc-user-define-edit
31069 @cindex Editing user definitions
31070 The @kbd{Z E} (@code{calc-user-define-edit}) command edits the definition
31071 of a user key. This works for keys that have been defined by either
31072 keyboard macros or formulas; further details are contained in the relevant
31073 following sections.
31075 @node Keyboard Macros, Invocation Macros, Creating User Keys, Programming
31076 @section Programming with Keyboard Macros
31080 @cindex Programming with keyboard macros
31081 @cindex Keyboard macros
31082 The easiest way to ``program'' the Emacs Calculator is to use standard
31083 keyboard macros. Press @w{@kbd{C-x (}} to begin recording a macro. From
31084 this point on, keystrokes you type will be saved away as well as
31085 performing their usual functions. Press @kbd{C-x )} to end recording.
31086 Press shift-@kbd{X} (or the standard Emacs key sequence @kbd{C-x e}) to
31087 execute your keyboard macro by replaying the recorded keystrokes.
31088 @xref{Keyboard Macros, , , emacs, the Emacs Manual}, for further
31091 When you use @kbd{X} to invoke a keyboard macro, the entire macro is
31092 treated as a single command by the undo and trail features. The stack
31093 display buffer is not updated during macro execution, but is instead
31094 fixed up once the macro completes. Thus, commands defined with keyboard
31095 macros are convenient and efficient. The @kbd{C-x e} command, on the
31096 other hand, invokes the keyboard macro with no special treatment: Each
31097 command in the macro will record its own undo information and trail entry,
31098 and update the stack buffer accordingly. If your macro uses features
31099 outside of Calc's control to operate on the contents of the Calc stack
31100 buffer, or if it includes Undo, Redo, or last-arguments commands, you
31101 must use @kbd{C-x e} to make sure the buffer and undo list are up-to-date
31102 at all times. You could also consider using @kbd{K} (@code{calc-keep-args})
31103 instead of @kbd{M-@key{RET}} (@code{calc-last-args}).
31105 Calc extends the standard Emacs keyboard macros in several ways.
31106 Keyboard macros can be used to create user-defined commands. Keyboard
31107 macros can include conditional and iteration structures, somewhat
31108 analogous to those provided by a traditional programmable calculator.
31111 * Naming Keyboard Macros::
31112 * Conditionals in Macros::
31113 * Loops in Macros::
31114 * Local Values in Macros::
31115 * Queries in Macros::
31118 @node Naming Keyboard Macros, Conditionals in Macros, Keyboard Macros, Keyboard Macros
31119 @subsection Naming Keyboard Macros
31123 @pindex calc-user-define-kbd-macro
31124 Once you have defined a keyboard macro, you can bind it to a @kbd{z}
31125 key sequence with the @kbd{Z K} (@code{calc-user-define-kbd-macro}) command.
31126 This command prompts first for a key, then for a command name. For
31127 example, if you type @kbd{C-x ( n @key{TAB} n @key{TAB} C-x )} you will
31128 define a keyboard macro which negates the top two numbers on the stack
31129 (@key{TAB} swaps the top two stack elements). Now you can type
31130 @kbd{Z K n @key{RET}} to define this keyboard macro onto the @kbd{z n} key
31131 sequence. The default command name (if you answer the second prompt with
31132 just the @key{RET} key as in this example) will be something like
31133 @samp{calc-User-n}. The keyboard macro will now be available as both
31134 @kbd{z n} and @kbd{M-x calc-User-n}. You can backspace and enter a more
31135 descriptive command name if you wish.
31137 Macros defined by @kbd{Z K} act like single commands; they are executed
31138 in the same way as by the @kbd{X} key. If you wish to define the macro
31139 as a standard no-frills Emacs macro (to be executed as if by @kbd{C-x e}),
31140 give a negative prefix argument to @kbd{Z K}.
31142 Once you have bound your keyboard macro to a key, you can use
31143 @kbd{Z P} to register it permanently with Emacs. @xref{Creating User Keys}.
31145 @cindex Keyboard macros, editing
31146 The @kbd{Z E} (@code{calc-user-define-edit}) command on a key that has
31147 been defined by a keyboard macro tries to use the @code{edmacro} package
31148 edit the macro. Type @kbd{C-c C-c} to finish editing and update
31149 the definition stored on the key, or, to cancel the edit, kill the
31150 buffer with @kbd{C-x k}.
31151 The special characters @code{RET}, @code{LFD}, @code{TAB}, @code{SPC},
31152 @code{DEL}, and @code{NUL} must be entered as these three character
31153 sequences, written in all uppercase, as must the prefixes @code{C-} and
31154 @code{M-}. Spaces and line breaks are ignored. Other characters are
31155 copied verbatim into the keyboard macro. Basically, the notation is the
31156 same as is used in all of this manual's examples, except that the manual
31157 takes some liberties with spaces: When we say @kbd{' [1 2 3] @key{RET}},
31158 we take it for granted that it is clear we really mean
31159 @kbd{' [1 @key{SPC} 2 @key{SPC} 3] @key{RET}}.
31162 @pindex read-kbd-macro
31163 The @kbd{M-# m} (@code{read-kbd-macro}) command reads an Emacs ``region''
31164 of spelled-out keystrokes and defines it as the current keyboard macro.
31165 It is a convenient way to define a keyboard macro that has been stored
31166 in a file, or to define a macro without executing it at the same time.
31168 @node Conditionals in Macros, Loops in Macros, Naming Keyboard Macros, Keyboard Macros
31169 @subsection Conditionals in Keyboard Macros
31174 @pindex calc-kbd-if
31175 @pindex calc-kbd-else
31176 @pindex calc-kbd-else-if
31177 @pindex calc-kbd-end-if
31178 @cindex Conditional structures
31179 The @kbd{Z [} (@code{calc-kbd-if}) and @kbd{Z ]} (@code{calc-kbd-end-if})
31180 commands allow you to put simple tests in a keyboard macro. When Calc
31181 sees the @kbd{Z [}, it pops an object from the stack and, if the object is
31182 a non-zero value, continues executing keystrokes. But if the object is
31183 zero, or if it is not provably nonzero, Calc skips ahead to the matching
31184 @kbd{Z ]} keystroke. @xref{Logical Operations}, for a set of commands for
31185 performing tests which conveniently produce 1 for true and 0 for false.
31187 For example, @kbd{@key{RET} 0 a < Z [ n Z ]} implements an absolute-value
31188 function in the form of a keyboard macro. This macro duplicates the
31189 number on the top of the stack, pushes zero and compares using @kbd{a <}
31190 (@code{calc-less-than}), then, if the number was less than zero,
31191 executes @kbd{n} (@code{calc-change-sign}). Otherwise, the change-sign
31192 command is skipped.
31194 To program this macro, type @kbd{C-x (}, type the above sequence of
31195 keystrokes, then type @kbd{C-x )}. Note that the keystrokes will be
31196 executed while you are making the definition as well as when you later
31197 re-execute the macro by typing @kbd{X}. Thus you should make sure a
31198 suitable number is on the stack before defining the macro so that you
31199 don't get a stack-underflow error during the definition process.
31201 Conditionals can be nested arbitrarily. However, there should be exactly
31202 one @kbd{Z ]} for each @kbd{Z [} in a keyboard macro.
31205 The @kbd{Z :} (@code{calc-kbd-else}) command allows you to choose between
31206 two keystroke sequences. The general format is @kbd{@var{cond} Z [
31207 @var{then-part} Z : @var{else-part} Z ]}. If @var{cond} is true
31208 (i.e., if the top of stack contains a non-zero number after @var{cond}
31209 has been executed), the @var{then-part} will be executed and the
31210 @var{else-part} will be skipped. Otherwise, the @var{then-part} will
31211 be skipped and the @var{else-part} will be executed.
31214 The @kbd{Z |} (@code{calc-kbd-else-if}) command allows you to choose
31215 between any number of alternatives. For example,
31216 @kbd{@var{cond1} Z [ @var{part1} Z : @var{cond2} Z | @var{part2} Z :
31217 @var{part3} Z ]} will execute @var{part1} if @var{cond1} is true,
31218 otherwise it will execute @var{part2} if @var{cond2} is true, otherwise
31219 it will execute @var{part3}.
31221 More precisely, @kbd{Z [} pops a number and conditionally skips to the
31222 next matching @kbd{Z :} or @kbd{Z ]} key. @w{@kbd{Z ]}} has no effect when
31223 actually executed. @kbd{Z :} skips to the next matching @kbd{Z ]}.
31224 @kbd{Z |} pops a number and conditionally skips to the next matching
31225 @kbd{Z :} or @kbd{Z ]}; thus, @kbd{Z [} and @kbd{Z |} are functionally
31226 equivalent except that @kbd{Z [} participates in nesting but @kbd{Z |}
31229 Calc's conditional and looping constructs work by scanning the
31230 keyboard macro for occurrences of character sequences like @samp{Z:}
31231 and @samp{Z]}. One side-effect of this is that if you use these
31232 constructs you must be careful that these character pairs do not
31233 occur by accident in other parts of the macros. Since Calc rarely
31234 uses shift-@kbd{Z} for any purpose except as a prefix character, this
31235 is not likely to be a problem. Another side-effect is that it will
31236 not work to define your own custom key bindings for these commands.
31237 Only the standard shift-@kbd{Z} bindings will work correctly.
31240 If Calc gets stuck while skipping characters during the definition of a
31241 macro, type @kbd{Z C-g} to cancel the definition. (Typing plain @kbd{C-g}
31242 actually adds a @kbd{C-g} keystroke to the macro.)
31244 @node Loops in Macros, Local Values in Macros, Conditionals in Macros, Keyboard Macros
31245 @subsection Loops in Keyboard Macros
31250 @pindex calc-kbd-repeat
31251 @pindex calc-kbd-end-repeat
31252 @cindex Looping structures
31253 @cindex Iterative structures
31254 The @kbd{Z <} (@code{calc-kbd-repeat}) and @kbd{Z >}
31255 (@code{calc-kbd-end-repeat}) commands pop a number from the stack,
31256 which must be an integer, then repeat the keystrokes between the brackets
31257 the specified number of times. If the integer is zero or negative, the
31258 body is skipped altogether. For example, @kbd{1 @key{TAB} Z < 2 * Z >}
31259 computes two to a nonnegative integer power. First, we push 1 on the
31260 stack and then swap the integer argument back to the top. The @kbd{Z <}
31261 pops that argument leaving the 1 back on top of the stack. Then, we
31262 repeat a multiply-by-two step however many times.
31264 Once again, the keyboard macro is executed as it is being entered.
31265 In this case it is especially important to set up reasonable initial
31266 conditions before making the definition: Suppose the integer 1000 just
31267 happened to be sitting on the stack before we typed the above definition!
31268 Another approach is to enter a harmless dummy definition for the macro,
31269 then go back and edit in the real one with a @kbd{Z E} command. Yet
31270 another approach is to type the macro as written-out keystroke names
31271 in a buffer, then use @kbd{M-# m} (@code{read-kbd-macro}) to read the
31276 The @kbd{Z /} (@code{calc-kbd-break}) command allows you to break out
31277 of a keyboard macro loop prematurely. It pops an object from the stack;
31278 if that object is true (a non-zero number), control jumps out of the
31279 innermost enclosing @kbd{Z <} @dots{} @kbd{Z >} loop and continues
31280 after the @kbd{Z >}. If the object is false, the @kbd{Z /} has no
31281 effect. Thus @kbd{@var{cond} Z /} is similar to @samp{if (@var{cond}) break;}
31286 @pindex calc-kbd-for
31287 @pindex calc-kbd-end-for
31288 The @kbd{Z (} (@code{calc-kbd-for}) and @kbd{Z )} (@code{calc-kbd-end-for})
31289 commands are similar to @kbd{Z <} and @kbd{Z >}, except that they make the
31290 value of the counter available inside the loop. The general layout is
31291 @kbd{@var{init} @var{final} Z ( @var{body} @var{step} Z )}. The @kbd{Z (}
31292 command pops initial and final values from the stack. It then creates
31293 a temporary internal counter and initializes it with the value @var{init}.
31294 The @kbd{Z (} command then repeatedly pushes the counter value onto the
31295 stack and executes @var{body} and @var{step}, adding @var{step} to the
31296 counter each time until the loop finishes.
31298 @cindex Summations (by keyboard macros)
31299 By default, the loop finishes when the counter becomes greater than (or
31300 less than) @var{final}, assuming @var{initial} is less than (greater
31301 than) @var{final}. If @var{initial} is equal to @var{final}, the body
31302 executes exactly once. The body of the loop always executes at least
31303 once. For example, @kbd{0 1 10 Z ( 2 ^ + 1 Z )} computes the sum of the
31304 squares of the integers from 1 to 10, in steps of 1.
31306 If you give a numeric prefix argument of 1 to @kbd{Z (}, the loop is
31307 forced to use upward-counting conventions. In this case, if @var{initial}
31308 is greater than @var{final} the body will not be executed at all.
31309 Note that @var{step} may still be negative in this loop; the prefix
31310 argument merely constrains the loop-finished test. Likewise, a prefix
31311 argument of @mathit{-1} forces downward-counting conventions.
31315 @pindex calc-kbd-loop
31316 @pindex calc-kbd-end-loop
31317 The @kbd{Z @{} (@code{calc-kbd-loop}) and @kbd{Z @}}
31318 (@code{calc-kbd-end-loop}) commands are similar to @kbd{Z <} and
31319 @kbd{Z >}, except that they do not pop a count from the stack---they
31320 effectively create an infinite loop. Every @kbd{Z @{} @dots{} @kbd{Z @}}
31321 loop ought to include at least one @kbd{Z /} to make sure the loop
31322 doesn't run forever. (If any error message occurs which causes Emacs
31323 to beep, the keyboard macro will also be halted; this is a standard
31324 feature of Emacs. You can also generally press @kbd{C-g} to halt a
31325 running keyboard macro, although not all versions of Unix support
31328 The conditional and looping constructs are not actually tied to
31329 keyboard macros, but they are most often used in that context.
31330 For example, the keystrokes @kbd{10 Z < 23 @key{RET} Z >} push
31331 ten copies of 23 onto the stack. This can be typed ``live'' just
31332 as easily as in a macro definition.
31334 @xref{Conditionals in Macros}, for some additional notes about
31335 conditional and looping commands.
31337 @node Local Values in Macros, Queries in Macros, Loops in Macros, Keyboard Macros
31338 @subsection Local Values in Macros
31341 @cindex Local variables
31342 @cindex Restoring saved modes
31343 Keyboard macros sometimes want to operate under known conditions
31344 without affecting surrounding conditions. For example, a keyboard
31345 macro may wish to turn on Fraction mode, or set a particular
31346 precision, independent of the user's normal setting for those
31351 @pindex calc-kbd-push
31352 @pindex calc-kbd-pop
31353 Macros also sometimes need to use local variables. Assignments to
31354 local variables inside the macro should not affect any variables
31355 outside the macro. The @kbd{Z `} (@code{calc-kbd-push}) and @kbd{Z '}
31356 (@code{calc-kbd-pop}) commands give you both of these capabilities.
31358 When you type @kbd{Z `} (with a backquote or accent grave character),
31359 the values of various mode settings are saved away. The ten ``quick''
31360 variables @code{q0} through @code{q9} are also saved. When
31361 you type @w{@kbd{Z '}} (with an apostrophe), these values are restored.
31362 Pairs of @kbd{Z `} and @kbd{Z '} commands may be nested.
31364 If a keyboard macro halts due to an error in between a @kbd{Z `} and
31365 a @kbd{Z '}, the saved values will be restored correctly even though
31366 the macro never reaches the @kbd{Z '} command. Thus you can use
31367 @kbd{Z `} and @kbd{Z '} without having to worry about what happens
31368 in exceptional conditions.
31370 If you type @kbd{Z `} ``live'' (not in a keyboard macro), Calc puts
31371 you into a ``recursive edit.'' You can tell you are in a recursive
31372 edit because there will be extra square brackets in the mode line,
31373 as in @samp{[(Calculator)]}. These brackets will go away when you
31374 type the matching @kbd{Z '} command. The modes and quick variables
31375 will be saved and restored in just the same way as if actual keyboard
31376 macros were involved.
31378 The modes saved by @kbd{Z `} and @kbd{Z '} are the current precision
31379 and binary word size, the angular mode (Deg, Rad, or HMS), the
31380 simplification mode, Algebraic mode, Symbolic mode, Infinite mode,
31381 Matrix or Scalar mode, Fraction mode, and the current complex mode
31382 (Polar or Rectangular). The ten ``quick'' variables' values (or lack
31383 thereof) are also saved.
31385 Most mode-setting commands act as toggles, but with a numeric prefix
31386 they force the mode either on (positive prefix) or off (negative
31387 or zero prefix). Since you don't know what the environment might
31388 be when you invoke your macro, it's best to use prefix arguments
31389 for all mode-setting commands inside the macro.
31391 In fact, @kbd{C-u Z `} is like @kbd{Z `} except that it sets the modes
31392 listed above to their default values. As usual, the matching @kbd{Z '}
31393 will restore the modes to their settings from before the @kbd{C-u Z `}.
31394 Also, @w{@kbd{Z `}} with a negative prefix argument resets the algebraic mode
31395 to its default (off) but leaves the other modes the same as they were
31396 outside the construct.
31398 The contents of the stack and trail, values of non-quick variables, and
31399 other settings such as the language mode and the various display modes,
31400 are @emph{not} affected by @kbd{Z `} and @kbd{Z '}.
31402 @node Queries in Macros, , Local Values in Macros, Keyboard Macros
31403 @subsection Queries in Keyboard Macros
31407 @c @pindex calc-kbd-report
31408 @c The @kbd{Z =} (@code{calc-kbd-report}) command displays an informative
31409 @c message including the value on the top of the stack. You are prompted
31410 @c to enter a string. That string, along with the top-of-stack value,
31411 @c is displayed unless @kbd{m w} (@code{calc-working}) has been used
31412 @c to turn such messages off.
31416 @pindex calc-kbd-query
31417 The @kbd{Z #} (@code{calc-kbd-query}) command prompts for an algebraic
31418 entry which takes its input from the keyboard, even during macro
31419 execution. All the normal conventions of algebraic input, including the
31420 use of @kbd{$} characters, are supported. The prompt message itself is
31421 taken from the top of the stack, and so must be entered (as a string)
31422 before the @kbd{Z #} command. (Recall, as a string it can be entered by
31423 pressing the @kbd{"} key and will appear as a vector when it is put on
31424 the stack. The prompt message is only put on the stack to provide a
31425 prompt for the @kbd{Z #} command; it will not play any role in any
31426 subsequent calculations.) This command allows your keyboard macros to
31427 accept numbers or formulas as interactive input.
31430 @kbd{2 @key{RET} "Power: " @key{RET} Z # 3 @key{RET} ^} will prompt for
31431 input with ``Power: '' in the minibuffer, then return 2 to the provided
31432 power. (The response to the prompt that's given, 3 in this example,
31433 will not be part of the macro.)
31435 @xref{Keyboard Macro Query, , , emacs, the Emacs Manual}, for a description of
31436 @kbd{C-x q} (@code{kbd-macro-query}), the standard Emacs way to accept
31437 keyboard input during a keyboard macro. In particular, you can use
31438 @kbd{C-x q} to enter a recursive edit, which allows the user to perform
31439 any Calculator operations interactively before pressing @kbd{C-M-c} to
31440 return control to the keyboard macro.
31442 @node Invocation Macros, Algebraic Definitions, Keyboard Macros, Programming
31443 @section Invocation Macros
31447 @pindex calc-user-invocation
31448 @pindex calc-user-define-invocation
31449 Calc provides one special keyboard macro, called up by @kbd{M-# z}
31450 (@code{calc-user-invocation}), that is intended to allow you to define
31451 your own special way of starting Calc. To define this ``invocation
31452 macro,'' create the macro in the usual way with @kbd{C-x (} and
31453 @kbd{C-x )}, then type @kbd{Z I} (@code{calc-user-define-invocation}).
31454 There is only one invocation macro, so you don't need to type any
31455 additional letters after @kbd{Z I}. From now on, you can type
31456 @kbd{M-# z} at any time to execute your invocation macro.
31458 For example, suppose you find yourself often grabbing rectangles of
31459 numbers into Calc and multiplying their columns. You can do this
31460 by typing @kbd{M-# r} to grab, and @kbd{V R : *} to multiply columns.
31461 To make this into an invocation macro, just type @kbd{C-x ( M-# r
31462 V R : * C-x )}, then @kbd{Z I}. Then, to multiply a rectangle of data,
31463 just mark the data in its buffer in the usual way and type @kbd{M-# z}.
31465 Invocation macros are treated like regular Emacs keyboard macros;
31466 all the special features described above for @kbd{Z K}-style macros
31467 do not apply. @kbd{M-# z} is just like @kbd{C-x e}, except that it
31468 uses the macro that was last stored by @kbd{Z I}. (In fact, the
31469 macro does not even have to have anything to do with Calc!)
31471 The @kbd{m m} command saves the last invocation macro defined by
31472 @kbd{Z I} along with all the other Calc mode settings.
31473 @xref{General Mode Commands}.
31475 @node Algebraic Definitions, Lisp Definitions, Invocation Macros, Programming
31476 @section Programming with Formulas
31480 @pindex calc-user-define-formula
31481 @cindex Programming with algebraic formulas
31482 Another way to create a new Calculator command uses algebraic formulas.
31483 The @kbd{Z F} (@code{calc-user-define-formula}) command stores the
31484 formula at the top of the stack as the definition for a key. This
31485 command prompts for five things: The key, the command name, the function
31486 name, the argument list, and the behavior of the command when given
31487 non-numeric arguments.
31489 For example, suppose we type @kbd{' a+2b @key{RET}} to push the formula
31490 @samp{a + 2*b} onto the stack. We now type @kbd{Z F m} to define this
31491 formula on the @kbd{z m} key sequence. The next prompt is for a command
31492 name, beginning with @samp{calc-}, which should be the long (@kbd{M-x}) form
31493 for the new command. If you simply press @key{RET}, a default name like
31494 @code{calc-User-m} will be constructed. In our example, suppose we enter
31495 @kbd{spam @key{RET}} to define the new command as @code{calc-spam}.
31497 If you want to give the formula a long-style name only, you can press
31498 @key{SPC} or @key{RET} when asked which single key to use. For example
31499 @kbd{Z F @key{RET} spam @key{RET}} defines the new command as
31500 @kbd{M-x calc-spam}, with no keyboard equivalent.
31502 The third prompt is for an algebraic function name. The default is to
31503 use the same name as the command name but without the @samp{calc-}
31504 prefix. (If this is of the form @samp{User-m}, the hyphen is removed so
31505 it won't be taken for a minus sign in algebraic formulas.)
31506 This is the name you will use if you want to enter your
31507 new function in an algebraic formula. Suppose we enter @kbd{yow @key{RET}}.
31508 Then the new function can be invoked by pushing two numbers on the
31509 stack and typing @kbd{z m} or @kbd{x spam}, or by entering the algebraic
31510 formula @samp{yow(x,y)}.
31512 The fourth prompt is for the function's argument list. This is used to
31513 associate values on the stack with the variables that appear in the formula.
31514 The default is a list of all variables which appear in the formula, sorted
31515 into alphabetical order. In our case, the default would be @samp{(a b)}.
31516 This means that, when the user types @kbd{z m}, the Calculator will remove
31517 two numbers from the stack, substitute these numbers for @samp{a} and
31518 @samp{b} (respectively) in the formula, then simplify the formula and
31519 push the result on the stack. In other words, @kbd{10 @key{RET} 100 z m}
31520 would replace the 10 and 100 on the stack with the number 210, which is
31521 @expr{a + 2 b} with @expr{a=10} and @expr{b=100}. Likewise, the formula
31522 @samp{yow(10, 100)} will be evaluated by substituting @expr{a=10} and
31523 @expr{b=100} in the definition.
31525 You can rearrange the order of the names before pressing @key{RET} to
31526 control which stack positions go to which variables in the formula. If
31527 you remove a variable from the argument list, that variable will be left
31528 in symbolic form by the command. Thus using an argument list of @samp{(b)}
31529 for our function would cause @kbd{10 z m} to replace the 10 on the stack
31530 with the formula @samp{a + 20}. If we had used an argument list of
31531 @samp{(b a)}, the result with inputs 10 and 100 would have been 120.
31533 You can also put a nameless function on the stack instead of just a
31534 formula, as in @samp{<a, b : a + 2 b>}. @xref{Specifying Operators}.
31535 In this example, the command will be defined by the formula @samp{a + 2 b}
31536 using the argument list @samp{(a b)}.
31538 The final prompt is a y-or-n question concerning what to do if symbolic
31539 arguments are given to your function. If you answer @kbd{y}, then
31540 executing @kbd{z m} (using the original argument list @samp{(a b)}) with
31541 arguments @expr{10} and @expr{x} will leave the function in symbolic
31542 form, i.e., @samp{yow(10,x)}. On the other hand, if you answer @kbd{n},
31543 then the formula will always be expanded, even for non-constant
31544 arguments: @samp{10 + 2 x}. If you never plan to feed algebraic
31545 formulas to your new function, it doesn't matter how you answer this
31548 If you answered @kbd{y} to this question you can still cause a function
31549 call to be expanded by typing @kbd{a "} (@code{calc-expand-formula}).
31550 Also, Calc will expand the function if necessary when you take a
31551 derivative or integral or solve an equation involving the function.
31554 @pindex calc-get-user-defn
31555 Once you have defined a formula on a key, you can retrieve this formula
31556 with the @kbd{Z G} (@code{calc-user-define-get-defn}) command. Press a
31557 key, and this command pushes the formula that was used to define that
31558 key onto the stack. Actually, it pushes a nameless function that
31559 specifies both the argument list and the defining formula. You will get
31560 an error message if the key is undefined, or if the key was not defined
31561 by a @kbd{Z F} command.
31563 The @kbd{Z E} (@code{calc-user-define-edit}) command on a key that has
31564 been defined by a formula uses a variant of the @code{calc-edit} command
31565 to edit the defining formula. Press @kbd{C-c C-c} to finish editing and
31566 store the new formula back in the definition, or kill the buffer with
31568 cancel the edit. (The argument list and other properties of the
31569 definition are unchanged; to adjust the argument list, you can use
31570 @kbd{Z G} to grab the function onto the stack, edit with @kbd{`}, and
31571 then re-execute the @kbd{Z F} command.)
31573 As usual, the @kbd{Z P} command records your definition permanently.
31574 In this case it will permanently record all three of the relevant
31575 definitions: the key, the command, and the function.
31577 You may find it useful to turn off the default simplifications with
31578 @kbd{m O} (@code{calc-no-simplify-mode}) when entering a formula to be
31579 used as a function definition. For example, the formula @samp{deriv(a^2,v)}
31580 which might be used to define a new function @samp{dsqr(a,v)} will be
31581 ``simplified'' to 0 immediately upon entry since @code{deriv} considers
31582 @expr{a} to be constant with respect to @expr{v}. Turning off
31583 default simplifications cures this problem: The definition will be stored
31584 in symbolic form without ever activating the @code{deriv} function. Press
31585 @kbd{m D} to turn the default simplifications back on afterwards.
31587 @node Lisp Definitions, , Algebraic Definitions, Programming
31588 @section Programming with Lisp
31591 The Calculator can be programmed quite extensively in Lisp. All you
31592 do is write a normal Lisp function definition, but with @code{defmath}
31593 in place of @code{defun}. This has the same form as @code{defun}, but it
31594 automagically replaces calls to standard Lisp functions like @code{+} and
31595 @code{zerop} with calls to the corresponding functions in Calc's own library.
31596 Thus you can write natural-looking Lisp code which operates on all of the
31597 standard Calculator data types. You can then use @kbd{Z D} if you wish to
31598 bind your new command to a @kbd{z}-prefix key sequence. The @kbd{Z E} command
31599 will not edit a Lisp-based definition.
31601 Emacs Lisp is described in the GNU Emacs Lisp Reference Manual. This section
31602 assumes a familiarity with Lisp programming concepts; if you do not know
31603 Lisp, you may find keyboard macros or rewrite rules to be an easier way
31604 to program the Calculator.
31606 This section first discusses ways to write commands, functions, or
31607 small programs to be executed inside of Calc. Then it discusses how
31608 your own separate programs are able to call Calc from the outside.
31609 Finally, there is a list of internal Calc functions and data structures
31610 for the true Lisp enthusiast.
31613 * Defining Functions::
31614 * Defining Simple Commands::
31615 * Defining Stack Commands::
31616 * Argument Qualifiers::
31617 * Example Definitions::
31619 * Calling Calc from Your Programs::
31623 @node Defining Functions, Defining Simple Commands, Lisp Definitions, Lisp Definitions
31624 @subsection Defining New Functions
31628 The @code{defmath} function (actually a Lisp macro) is like @code{defun}
31629 except that code in the body of the definition can make use of the full
31630 range of Calculator data types. The prefix @samp{calcFunc-} is added
31631 to the specified name to get the actual Lisp function name. As a simple
31635 (defmath myfact (n)
31637 (* n (myfact (1- n)))
31642 This actually expands to the code,
31645 (defun calcFunc-myfact (n)
31647 (math-mul n (calcFunc-myfact (math-add n -1)))
31652 This function can be used in algebraic expressions, e.g., @samp{myfact(5)}.
31654 The @samp{myfact} function as it is defined above has the bug that an
31655 expression @samp{myfact(a+b)} will be simplified to 1 because the
31656 formula @samp{a+b} is not considered to be @code{posp}. A robust
31657 factorial function would be written along the following lines:
31660 (defmath myfact (n)
31662 (* n (myfact (1- n)))
31665 nil))) ; this could be simplified as: (and (= n 0) 1)
31668 If a function returns @code{nil}, it is left unsimplified by the Calculator
31669 (except that its arguments will be simplified). Thus, @samp{myfact(a+1+2)}
31670 will be simplified to @samp{myfact(a+3)} but no further. Beware that every
31671 time the Calculator reexamines this formula it will attempt to resimplify
31672 it, so your function ought to detect the returning-@code{nil} case as
31673 efficiently as possible.
31675 The following standard Lisp functions are treated by @code{defmath}:
31676 @code{+}, @code{-}, @code{*}, @code{/}, @code{%}, @code{^} or
31677 @code{expt}, @code{=}, @code{<}, @code{>}, @code{<=}, @code{>=},
31678 @code{/=}, @code{1+}, @code{1-}, @code{logand}, @code{logior}, @code{logxor},
31679 @code{logandc2}, @code{lognot}. Also, @code{~=} is an abbreviation for
31680 @code{math-nearly-equal}, which is useful in implementing Taylor series.
31682 For other functions @var{func}, if a function by the name
31683 @samp{calcFunc-@var{func}} exists it is used, otherwise if a function by the
31684 name @samp{math-@var{func}} exists it is used, otherwise if @var{func} itself
31685 is defined as a function it is used, otherwise @samp{calcFunc-@var{func}} is
31686 used on the assumption that this is a to-be-defined math function. Also, if
31687 the function name is quoted as in @samp{('integerp a)} the function name is
31688 always used exactly as written (but not quoted).
31690 Variable names have @samp{var-} prepended to them unless they appear in
31691 the function's argument list or in an enclosing @code{let}, @code{let*},
31692 @code{for}, or @code{foreach} form,
31693 or their names already contain a @samp{-} character. Thus a reference to
31694 @samp{foo} is the same as a reference to @samp{var-foo}.
31696 A few other Lisp extensions are available in @code{defmath} definitions:
31700 The @code{elt} function accepts any number of index variables.
31701 Note that Calc vectors are stored as Lisp lists whose first
31702 element is the symbol @code{vec}; thus, @samp{(elt v 2)} yields
31703 the second element of vector @code{v}, and @samp{(elt m i j)}
31704 yields one element of a Calc matrix.
31707 The @code{setq} function has been extended to act like the Common
31708 Lisp @code{setf} function. (The name @code{setf} is recognized as
31709 a synonym of @code{setq}.) Specifically, the first argument of
31710 @code{setq} can be an @code{nth}, @code{elt}, @code{car}, or @code{cdr} form,
31711 in which case the effect is to store into the specified
31712 element of a list. Thus, @samp{(setq (elt m i j) x)} stores @expr{x}
31713 into one element of a matrix.
31716 A @code{for} looping construct is available. For example,
31717 @samp{(for ((i 0 10)) body)} executes @code{body} once for each
31718 binding of @expr{i} from zero to 10. This is like a @code{let}
31719 form in that @expr{i} is temporarily bound to the loop count
31720 without disturbing its value outside the @code{for} construct.
31721 Nested loops, as in @samp{(for ((i 0 10) (j 0 (1- i) 2)) body)},
31722 are also available. For each value of @expr{i} from zero to 10,
31723 @expr{j} counts from 0 to @expr{i-1} in steps of two. Note that
31724 @code{for} has the same general outline as @code{let*}, except
31725 that each element of the header is a list of three or four
31726 things, not just two.
31729 The @code{foreach} construct loops over elements of a list.
31730 For example, @samp{(foreach ((x (cdr v))) body)} executes
31731 @code{body} with @expr{x} bound to each element of Calc vector
31732 @expr{v} in turn. The purpose of @code{cdr} here is to skip over
31733 the initial @code{vec} symbol in the vector.
31736 The @code{break} function breaks out of the innermost enclosing
31737 @code{while}, @code{for}, or @code{foreach} loop. If given a
31738 value, as in @samp{(break x)}, this value is returned by the
31739 loop. (Lisp loops otherwise always return @code{nil}.)
31742 The @code{return} function prematurely returns from the enclosing
31743 function. For example, @samp{(return (+ x y))} returns @expr{x+y}
31744 as the value of a function. You can use @code{return} anywhere
31745 inside the body of the function.
31748 Non-integer numbers (and extremely large integers) cannot be included
31749 directly into a @code{defmath} definition. This is because the Lisp
31750 reader will fail to parse them long before @code{defmath} ever gets control.
31751 Instead, use the notation, @samp{:"3.1415"}. In fact, any algebraic
31752 formula can go between the quotes. For example,
31755 (defmath sqexp (x) ; sqexp(x) == sqrt(exp(x)) == exp(x*0.5)
31763 (defun calcFunc-sqexp (x)
31764 (and (math-numberp x)
31765 (calcFunc-exp (math-mul x '(float 5 -1)))))
31768 Note the use of @code{numberp} as a guard to ensure that the argument is
31769 a number first, returning @code{nil} if not. The exponential function
31770 could itself have been included in the expression, if we had preferred:
31771 @samp{:"exp(x * 0.5)"}. As another example, the multiplication-and-recursion
31772 step of @code{myfact} could have been written
31778 A good place to put your @code{defmath} commands is your Calc init file
31779 (the file given by @code{calc-settings-file}, typically
31780 @file{~/.calc.el}), which will not be loaded until Calc starts.
31781 If a file named @file{.emacs} exists in your home directory, Emacs reads
31782 and executes the Lisp forms in this file as it starts up. While it may
31783 seem reasonable to put your favorite @code{defmath} commands there,
31784 this has the unfortunate side-effect that parts of the Calculator must be
31785 loaded in to process the @code{defmath} commands whether or not you will
31786 actually use the Calculator! If you want to put the @code{defmath}
31787 commands there (for example, if you redefine @code{calc-settings-file}
31788 to be @file{.emacs}), a better effect can be had by writing
31791 (put 'calc-define 'thing '(progn
31798 @vindex calc-define
31799 The @code{put} function adds a @dfn{property} to a symbol. Each Lisp
31800 symbol has a list of properties associated with it. Here we add a
31801 property with a name of @code{thing} and a @samp{(progn ...)} form as
31802 its value. When Calc starts up, and at the start of every Calc command,
31803 the property list for the symbol @code{calc-define} is checked and the
31804 values of any properties found are evaluated as Lisp forms. The
31805 properties are removed as they are evaluated. The property names
31806 (like @code{thing}) are not used; you should choose something like the
31807 name of your project so as not to conflict with other properties.
31809 The net effect is that you can put the above code in your @file{.emacs}
31810 file and it will not be executed until Calc is loaded. Or, you can put
31811 that same code in another file which you load by hand either before or
31812 after Calc itself is loaded.
31814 The properties of @code{calc-define} are evaluated in the same order
31815 that they were added. They can assume that the Calc modules @file{calc.el},
31816 @file{calc-ext.el}, and @file{calc-macs.el} have been fully loaded, and
31817 that the @samp{*Calculator*} buffer will be the current buffer.
31819 If your @code{calc-define} property only defines algebraic functions,
31820 you can be sure that it will have been evaluated before Calc tries to
31821 call your function, even if the file defining the property is loaded
31822 after Calc is loaded. But if the property defines commands or key
31823 sequences, it may not be evaluated soon enough. (Suppose it defines the
31824 new command @code{tweak-calc}; the user can load your file, then type
31825 @kbd{M-x tweak-calc} before Calc has had chance to do anything.) To
31826 protect against this situation, you can put
31829 (run-hooks 'calc-check-defines)
31832 @findex calc-check-defines
31834 at the end of your file. The @code{calc-check-defines} function is what
31835 looks for and evaluates properties on @code{calc-define}; @code{run-hooks}
31836 has the advantage that it is quietly ignored if @code{calc-check-defines}
31837 is not yet defined because Calc has not yet been loaded.
31839 Examples of things that ought to be enclosed in a @code{calc-define}
31840 property are @code{defmath} calls, @code{define-key} calls that modify
31841 the Calc key map, and any calls that redefine things defined inside Calc.
31842 Ordinary @code{defun}s need not be enclosed with @code{calc-define}.
31844 @node Defining Simple Commands, Defining Stack Commands, Defining Functions, Lisp Definitions
31845 @subsection Defining New Simple Commands
31848 @findex interactive
31849 If a @code{defmath} form contains an @code{interactive} clause, it defines
31850 a Calculator command. Actually such a @code{defmath} results in @emph{two}
31851 function definitions: One, a @samp{calcFunc-} function as was just described,
31852 with the @code{interactive} clause removed. Two, a @samp{calc-} function
31853 with a suitable @code{interactive} clause and some sort of wrapper to make
31854 the command work in the Calc environment.
31856 In the simple case, the @code{interactive} clause has the same form as
31857 for normal Emacs Lisp commands:
31860 (defmath increase-precision (delta)
31861 "Increase precision by DELTA." ; This is the "documentation string"
31862 (interactive "p") ; Register this as a M-x-able command
31863 (setq calc-internal-prec (+ calc-internal-prec delta)))
31866 This expands to the pair of definitions,
31869 (defun calc-increase-precision (delta)
31870 "Increase precision by DELTA."
31873 (setq calc-internal-prec (math-add calc-internal-prec delta))))
31875 (defun calcFunc-increase-precision (delta)
31876 "Increase precision by DELTA."
31877 (setq calc-internal-prec (math-add calc-internal-prec delta)))
31881 where in this case the latter function would never really be used! Note
31882 that since the Calculator stores small integers as plain Lisp integers,
31883 the @code{math-add} function will work just as well as the native
31884 @code{+} even when the intent is to operate on native Lisp integers.
31886 @findex calc-wrapper
31887 The @samp{calc-wrapper} call invokes a macro which surrounds the body of
31888 the function with code that looks roughly like this:
31891 (let ((calc-command-flags nil))
31894 (calc-select-buffer)
31895 @emph{body of function}
31896 @emph{renumber stack}
31897 @emph{clear} Working @emph{message})
31898 @emph{realign cursor and window}
31899 @emph{clear Inverse, Hyperbolic, and Keep Args flags}
31900 @emph{update Emacs mode line}))
31903 @findex calc-select-buffer
31904 The @code{calc-select-buffer} function selects the @samp{*Calculator*}
31905 buffer if necessary, say, because the command was invoked from inside
31906 the @samp{*Calc Trail*} window.
31908 @findex calc-set-command-flag
31909 You can call, for example, @code{(calc-set-command-flag 'no-align)} to
31910 set the above-mentioned command flags. Calc routines recognize the
31911 following command flags:
31915 Stack line numbers @samp{1:}, @samp{2:}, and so on must be renumbered
31916 after this command completes. This is set by routines like
31919 @item clear-message
31920 Calc should call @samp{(message "")} if this command completes normally
31921 (to clear a ``Working@dots{}'' message out of the echo area).
31924 Do not move the cursor back to the @samp{.} top-of-stack marker.
31926 @item position-point
31927 Use the variables @code{calc-position-point-line} and
31928 @code{calc-position-point-column} to position the cursor after
31929 this command finishes.
31932 Do not clear @code{calc-inverse-flag}, @code{calc-hyperbolic-flag},
31933 and @code{calc-keep-args-flag} at the end of this command.
31936 Switch to buffer @samp{*Calc Edit*} after this command.
31939 Do not move trail pointer to end of trail when something is recorded
31945 @vindex calc-Y-help-msgs
31946 Calc reserves a special prefix key, shift-@kbd{Y}, for user-written
31947 extensions to Calc. There are no built-in commands that work with
31948 this prefix key; you must call @code{define-key} from Lisp (probably
31949 from inside a @code{calc-define} property) to add to it. Initially only
31950 @kbd{Y ?} is defined; it takes help messages from a list of strings
31951 (initially @code{nil}) in the variable @code{calc-Y-help-msgs}. All
31952 other undefined keys except for @kbd{Y} are reserved for use by
31953 future versions of Calc.
31955 If you are writing a Calc enhancement which you expect to give to
31956 others, it is best to minimize the number of @kbd{Y}-key sequences
31957 you use. In fact, if you have more than one key sequence you should
31958 consider defining three-key sequences with a @kbd{Y}, then a key that
31959 stands for your package, then a third key for the particular command
31960 within your package.
31962 Users may wish to install several Calc enhancements, and it is possible
31963 that several enhancements will choose to use the same key. In the
31964 example below, a variable @code{inc-prec-base-key} has been defined
31965 to contain the key that identifies the @code{inc-prec} package. Its
31966 value is initially @code{"P"}, but a user can change this variable
31967 if necessary without having to modify the file.
31969 Here is a complete file, @file{inc-prec.el}, which makes a @kbd{Y P I}
31970 command that increases the precision, and a @kbd{Y P D} command that
31971 decreases the precision.
31974 ;;; Increase and decrease Calc precision. Dave Gillespie, 5/31/91.
31975 ;;; (Include copyright or copyleft stuff here.)
31977 (defvar inc-prec-base-key "P"
31978 "Base key for inc-prec.el commands.")
31980 (put 'calc-define 'inc-prec '(progn
31982 (define-key calc-mode-map (format "Y%sI" inc-prec-base-key)
31983 'increase-precision)
31984 (define-key calc-mode-map (format "Y%sD" inc-prec-base-key)
31985 'decrease-precision)
31987 (setq calc-Y-help-msgs
31988 (cons (format "%s + Inc-prec, Dec-prec" inc-prec-base-key)
31991 (defmath increase-precision (delta)
31992 "Increase precision by DELTA."
31994 (setq calc-internal-prec (+ calc-internal-prec delta)))
31996 (defmath decrease-precision (delta)
31997 "Decrease precision by DELTA."
31999 (setq calc-internal-prec (- calc-internal-prec delta)))
32001 )) ; end of calc-define property
32003 (run-hooks 'calc-check-defines)
32006 @node Defining Stack Commands, Argument Qualifiers, Defining Simple Commands, Lisp Definitions
32007 @subsection Defining New Stack-Based Commands
32010 To define a new computational command which takes and/or leaves arguments
32011 on the stack, a special form of @code{interactive} clause is used.
32014 (interactive @var{num} @var{tag})
32018 where @var{num} is an integer, and @var{tag} is a string. The effect is
32019 to pop @var{num} values off the stack, resimplify them by calling
32020 @code{calc-normalize}, and hand them to your function according to the
32021 function's argument list. Your function may include @code{&optional} and
32022 @code{&rest} parameters, so long as calling the function with @var{num}
32023 parameters is valid.
32025 Your function must return either a number or a formula in a form
32026 acceptable to Calc, or a list of such numbers or formulas. These value(s)
32027 are pushed onto the stack when the function completes. They are also
32028 recorded in the Calc Trail buffer on a line beginning with @var{tag},
32029 a string of (normally) four characters or less. If you omit @var{tag}
32030 or use @code{nil} as a tag, the result is not recorded in the trail.
32032 As an example, the definition
32035 (defmath myfact (n)
32036 "Compute the factorial of the integer at the top of the stack."
32037 (interactive 1 "fact")
32039 (* n (myfact (1- n)))
32044 is a version of the factorial function shown previously which can be used
32045 as a command as well as an algebraic function. It expands to
32048 (defun calc-myfact ()
32049 "Compute the factorial of the integer at the top of the stack."
32052 (calc-enter-result 1 "fact"
32053 (cons 'calcFunc-myfact (calc-top-list-n 1)))))
32055 (defun calcFunc-myfact (n)
32056 "Compute the factorial of the integer at the top of the stack."
32058 (math-mul n (calcFunc-myfact (math-add n -1)))
32059 (and (math-zerop n) 1)))
32062 @findex calc-slow-wrapper
32063 The @code{calc-slow-wrapper} function is a version of @code{calc-wrapper}
32064 that automatically puts up a @samp{Working...} message before the
32065 computation begins. (This message can be turned off by the user
32066 with an @kbd{m w} (@code{calc-working}) command.)
32068 @findex calc-top-list-n
32069 The @code{calc-top-list-n} function returns a list of the specified number
32070 of values from the top of the stack. It resimplifies each value by
32071 calling @code{calc-normalize}. If its argument is zero it returns an
32072 empty list. It does not actually remove these values from the stack.
32074 @findex calc-enter-result
32075 The @code{calc-enter-result} function takes an integer @var{num} and string
32076 @var{tag} as described above, plus a third argument which is either a
32077 Calculator data object or a list of such objects. These objects are
32078 resimplified and pushed onto the stack after popping the specified number
32079 of values from the stack. If @var{tag} is non-@code{nil}, the values
32080 being pushed are also recorded in the trail.
32082 Note that if @code{calcFunc-myfact} returns @code{nil} this represents
32083 ``leave the function in symbolic form.'' To return an actual empty list,
32084 in the sense that @code{calc-enter-result} will push zero elements back
32085 onto the stack, you should return the special value @samp{'(nil)}, a list
32086 containing the single symbol @code{nil}.
32088 The @code{interactive} declaration can actually contain a limited
32089 Emacs-style code string as well which comes just before @var{num} and
32090 @var{tag}. Currently the only Emacs code supported is @samp{"p"}, as in
32093 (defmath foo (a b &optional c)
32094 (interactive "p" 2 "foo")
32098 In this example, the command @code{calc-foo} will evaluate the expression
32099 @samp{foo(a,b)} if executed with no argument, or @samp{foo(a,b,n)} if
32100 executed with a numeric prefix argument of @expr{n}.
32102 The other code string allowed is @samp{"m"} (unrelated to the usual @samp{"m"}
32103 code as used with @code{defun}). It uses the numeric prefix argument as the
32104 number of objects to remove from the stack and pass to the function.
32105 In this case, the integer @var{num} serves as a default number of
32106 arguments to be used when no prefix is supplied.
32108 @node Argument Qualifiers, Example Definitions, Defining Stack Commands, Lisp Definitions
32109 @subsection Argument Qualifiers
32112 Anywhere a parameter name can appear in the parameter list you can also use
32113 an @dfn{argument qualifier}. Thus the general form of a definition is:
32116 (defmath @var{name} (@var{param} @var{param...}
32117 &optional @var{param} @var{param...}
32123 where each @var{param} is either a symbol or a list of the form
32126 (@var{qual} @var{param})
32129 The following qualifiers are recognized:
32134 The argument must not be an incomplete vector, interval, or complex number.
32135 (This is rarely needed since the Calculator itself will never call your
32136 function with an incomplete argument. But there is nothing stopping your
32137 own Lisp code from calling your function with an incomplete argument.)
32141 The argument must be an integer. If it is an integer-valued float
32142 it will be accepted but converted to integer form. Non-integers and
32143 formulas are rejected.
32147 Like @samp{integer}, but the argument must be non-negative.
32151 Like @samp{integer}, but the argument must fit into a native Lisp integer,
32152 which on most systems means less than 2^23 in absolute value. The
32153 argument is converted into Lisp-integer form if necessary.
32157 The argument is converted to floating-point format if it is a number or
32158 vector. If it is a formula it is left alone. (The argument is never
32159 actually rejected by this qualifier.)
32162 The argument must satisfy predicate @var{pred}, which is one of the
32163 standard Calculator predicates. @xref{Predicates}.
32165 @item not-@var{pred}
32166 The argument must @emph{not} satisfy predicate @var{pred}.
32172 (defmath foo (a (constp (not-matrixp b)) &optional (float c)
32181 (defun calcFunc-foo (a b &optional c &rest d)
32182 (and (math-matrixp b)
32183 (math-reject-arg b 'not-matrixp))
32184 (or (math-constp b)
32185 (math-reject-arg b 'constp))
32186 (and c (setq c (math-check-float c)))
32187 (setq d (mapcar 'math-check-integer d))
32192 which performs the necessary checks and conversions before executing the
32193 body of the function.
32195 @node Example Definitions, Calling Calc from Your Programs, Argument Qualifiers, Lisp Definitions
32196 @subsection Example Definitions
32199 This section includes some Lisp programming examples on a larger scale.
32200 These programs make use of some of the Calculator's internal functions;
32204 * Bit Counting Example::
32208 @node Bit Counting Example, Sine Example, Example Definitions, Example Definitions
32209 @subsubsection Bit-Counting
32216 Calc does not include a built-in function for counting the number of
32217 ``one'' bits in a binary integer. It's easy to invent one using @kbd{b u}
32218 to convert the integer to a set, and @kbd{V #} to count the elements of
32219 that set; let's write a function that counts the bits without having to
32220 create an intermediate set.
32223 (defmath bcount ((natnum n))
32224 (interactive 1 "bcnt")
32228 (setq count (1+ count)))
32229 (setq n (lsh n -1)))
32234 When this is expanded by @code{defmath}, it will become the following
32235 Emacs Lisp function:
32238 (defun calcFunc-bcount (n)
32239 (setq n (math-check-natnum n))
32241 (while (math-posp n)
32243 (setq count (math-add count 1)))
32244 (setq n (calcFunc-lsh n -1)))
32248 If the input numbers are large, this function involves a fair amount
32249 of arithmetic. A binary right shift is essentially a division by two;
32250 recall that Calc stores integers in decimal form so bit shifts must
32251 involve actual division.
32253 To gain a bit more efficiency, we could divide the integer into
32254 @var{n}-bit chunks, each of which can be handled quickly because
32255 they fit into Lisp integers. It turns out that Calc's arithmetic
32256 routines are especially fast when dividing by an integer less than
32257 1000, so we can set @var{n = 9} bits and use repeated division by 512:
32260 (defmath bcount ((natnum n))
32261 (interactive 1 "bcnt")
32263 (while (not (fixnump n))
32264 (let ((qr (idivmod n 512)))
32265 (setq count (+ count (bcount-fixnum (cdr qr)))
32267 (+ count (bcount-fixnum n))))
32269 (defun bcount-fixnum (n)
32272 (setq count (+ count (logand n 1))
32278 Note that the second function uses @code{defun}, not @code{defmath}.
32279 Because this function deals only with native Lisp integers (``fixnums''),
32280 it can use the actual Emacs @code{+} and related functions rather
32281 than the slower but more general Calc equivalents which @code{defmath}
32284 The @code{idivmod} function does an integer division, returning both
32285 the quotient and the remainder at once. Again, note that while it
32286 might seem that @samp{(logand n 511)} and @samp{(lsh n -9)} are
32287 more efficient ways to split off the bottom nine bits of @code{n},
32288 actually they are less efficient because each operation is really
32289 a division by 512 in disguise; @code{idivmod} allows us to do the
32290 same thing with a single division by 512.
32292 @node Sine Example, , Bit Counting Example, Example Definitions
32293 @subsubsection The Sine Function
32300 A somewhat limited sine function could be defined as follows, using the
32301 well-known Taylor series expansion for
32302 @texline @math{\sin x}:
32303 @infoline @samp{sin(x)}:
32306 (defmath mysin ((float (anglep x)))
32307 (interactive 1 "mysn")
32308 (setq x (to-radians x)) ; Convert from current angular mode.
32309 (let ((sum x) ; Initial term of Taylor expansion of sin.
32311 (nfact 1) ; "nfact" equals "n" factorial at all times.
32312 (xnegsqr :"-(x^2)")) ; "xnegsqr" equals -x^2.
32313 (for ((n 3 100 2)) ; Upper limit of 100 is a good precaution.
32314 (working "mysin" sum) ; Display "Working" message, if enabled.
32315 (setq nfact (* nfact (1- n) n)
32317 newsum (+ sum (/ x nfact)))
32318 (if (~= newsum sum) ; If newsum is "nearly equal to" sum,
32319 (break)) ; then we are done.
32324 The actual @code{sin} function in Calc works by first reducing the problem
32325 to a sine or cosine of a nonnegative number less than @cpiover{4}. This
32326 ensures that the Taylor series will converge quickly. Also, the calculation
32327 is carried out with two extra digits of precision to guard against cumulative
32328 round-off in @samp{sum}. Finally, complex arguments are allowed and handled
32329 by a separate algorithm.
32332 (defmath mysin ((float (scalarp x)))
32333 (interactive 1 "mysn")
32334 (setq x (to-radians x)) ; Convert from current angular mode.
32335 (with-extra-prec 2 ; Evaluate with extra precision.
32336 (cond ((complexp x)
32339 (- (mysin-raw (- x))) ; Always call mysin-raw with x >= 0.
32340 (t (mysin-raw x))))))
32342 (defmath mysin-raw (x)
32344 (mysin-raw (% x (two-pi)))) ; Now x < 7.
32346 (- (mysin-raw (- x (pi))))) ; Now -pi/2 <= x <= pi/2.
32348 (mycos-raw (- x (pi-over-2)))) ; Now -pi/2 <= x <= pi/4.
32349 ((< x (- (pi-over-4)))
32350 (- (mycos-raw (+ x (pi-over-2))))) ; Now -pi/4 <= x <= pi/4,
32351 (t (mysin-series x)))) ; so the series will be efficient.
32355 where @code{mysin-complex} is an appropriate function to handle complex
32356 numbers, @code{mysin-series} is the routine to compute the sine Taylor
32357 series as before, and @code{mycos-raw} is a function analogous to
32358 @code{mysin-raw} for cosines.
32360 The strategy is to ensure that @expr{x} is nonnegative before calling
32361 @code{mysin-raw}. This function then recursively reduces its argument
32362 to a suitable range, namely, plus-or-minus @cpiover{4}. Note that each
32363 test, and particularly the first comparison against 7, is designed so
32364 that small roundoff errors cannot produce an infinite loop. (Suppose
32365 we compared with @samp{(two-pi)} instead; if due to roundoff problems
32366 the modulo operator ever returned @samp{(two-pi)} exactly, an infinite
32367 recursion could result!) We use modulo only for arguments that will
32368 clearly get reduced, knowing that the next rule will catch any reductions
32369 that this rule misses.
32371 If a program is being written for general use, it is important to code
32372 it carefully as shown in this second example. For quick-and-dirty programs,
32373 when you know that your own use of the sine function will never encounter
32374 a large argument, a simpler program like the first one shown is fine.
32376 @node Calling Calc from Your Programs, Internals, Example Definitions, Lisp Definitions
32377 @subsection Calling Calc from Your Lisp Programs
32380 A later section (@pxref{Internals}) gives a full description of
32381 Calc's internal Lisp functions. It's not hard to call Calc from
32382 inside your programs, but the number of these functions can be daunting.
32383 So Calc provides one special ``programmer-friendly'' function called
32384 @code{calc-eval} that can be made to do just about everything you
32385 need. It's not as fast as the low-level Calc functions, but it's
32386 much simpler to use!
32388 It may seem that @code{calc-eval} itself has a daunting number of
32389 options, but they all stem from one simple operation.
32391 In its simplest manifestation, @samp{(calc-eval "1+2")} parses the
32392 string @code{"1+2"} as if it were a Calc algebraic entry and returns
32393 the result formatted as a string: @code{"3"}.
32395 Since @code{calc-eval} is on the list of recommended @code{autoload}
32396 functions, you don't need to make any special preparations to load
32397 Calc before calling @code{calc-eval} the first time. Calc will be
32398 loaded and initialized for you.
32400 All the Calc modes that are currently in effect will be used when
32401 evaluating the expression and formatting the result.
32408 @subsubsection Additional Arguments to @code{calc-eval}
32411 If the input string parses to a list of expressions, Calc returns
32412 the results separated by @code{", "}. You can specify a different
32413 separator by giving a second string argument to @code{calc-eval}:
32414 @samp{(calc-eval "1+2,3+4" ";")} returns @code{"3;7"}.
32416 The ``separator'' can also be any of several Lisp symbols which
32417 request other behaviors from @code{calc-eval}. These are discussed
32420 You can give additional arguments to be substituted for
32421 @samp{$}, @samp{$$}, and so on in the main expression. For
32422 example, @samp{(calc-eval "$/$$" nil "7" "1+1")} evaluates the
32423 expression @code{"7/(1+1)"} to yield the result @code{"3.5"}
32424 (assuming Fraction mode is not in effect). Note the @code{nil}
32425 used as a placeholder for the item-separator argument.
32432 @subsubsection Error Handling
32435 If @code{calc-eval} encounters an error, it returns a list containing
32436 the character position of the error, plus a suitable message as a
32437 string. Note that @samp{1 / 0} is @emph{not} an error by Calc's
32438 standards; it simply returns the string @code{"1 / 0"} which is the
32439 division left in symbolic form. But @samp{(calc-eval "1/")} will
32440 return the list @samp{(2 "Expected a number")}.
32442 If you bind the variable @code{calc-eval-error} to @code{t}
32443 using a @code{let} form surrounding the call to @code{calc-eval},
32444 errors instead call the Emacs @code{error} function which aborts
32445 to the Emacs command loop with a beep and an error message.
32447 If you bind this variable to the symbol @code{string}, error messages
32448 are returned as strings instead of lists. The character position is
32451 As a courtesy to other Lisp code which may be using Calc, be sure
32452 to bind @code{calc-eval-error} using @code{let} rather than changing
32453 it permanently with @code{setq}.
32460 @subsubsection Numbers Only
32463 Sometimes it is preferable to treat @samp{1 / 0} as an error
32464 rather than returning a symbolic result. If you pass the symbol
32465 @code{num} as the second argument to @code{calc-eval}, results
32466 that are not constants are treated as errors. The error message
32467 reported is the first @code{calc-why} message if there is one,
32468 or otherwise ``Number expected.''
32470 A result is ``constant'' if it is a number, vector, or other
32471 object that does not include variables or function calls. If it
32472 is a vector, the components must themselves be constants.
32479 @subsubsection Default Modes
32482 If the first argument to @code{calc-eval} is a list whose first
32483 element is a formula string, then @code{calc-eval} sets all the
32484 various Calc modes to their default values while the formula is
32485 evaluated and formatted. For example, the precision is set to 12
32486 digits, digit grouping is turned off, and the Normal language
32489 This same principle applies to the other options discussed below.
32490 If the first argument would normally be @var{x}, then it can also
32491 be the list @samp{(@var{x})} to use the default mode settings.
32493 If there are other elements in the list, they are taken as
32494 variable-name/value pairs which override the default mode
32495 settings. Look at the documentation at the front of the
32496 @file{calc.el} file to find the names of the Lisp variables for
32497 the various modes. The mode settings are restored to their
32498 original values when @code{calc-eval} is done.
32500 For example, @samp{(calc-eval '("$+$$" calc-internal-prec 8) 'num a b)}
32501 computes the sum of two numbers, requiring a numeric result, and
32502 using default mode settings except that the precision is 8 instead
32503 of the default of 12.
32505 It's usually best to use this form of @code{calc-eval} unless your
32506 program actually considers the interaction with Calc's mode settings
32507 to be a feature. This will avoid all sorts of potential ``gotchas'';
32508 consider what happens with @samp{(calc-eval "sqrt(2)" 'num)}
32509 when the user has left Calc in Symbolic mode or No-Simplify mode.
32511 As another example, @samp{(equal (calc-eval '("$<$$") nil a b) "1")}
32512 checks if the number in string @expr{a} is less than the one in
32513 string @expr{b}. Without using a list, the integer 1 might
32514 come out in a variety of formats which would be hard to test for
32515 conveniently: @code{"1"}, @code{"8#1"}, @code{"00001"}. (But
32516 see ``Predicates'' mode, below.)
32523 @subsubsection Raw Numbers
32526 Normally all input and output for @code{calc-eval} is done with strings.
32527 You can do arithmetic with, say, @samp{(calc-eval "$+$$" nil a b)}
32528 in place of @samp{(+ a b)}, but this is very inefficient since the
32529 numbers must be converted to and from string format as they are passed
32530 from one @code{calc-eval} to the next.
32532 If the separator is the symbol @code{raw}, the result will be returned
32533 as a raw Calc data structure rather than a string. You can read about
32534 how these objects look in the following sections, but usually you can
32535 treat them as ``black box'' objects with no important internal
32538 There is also a @code{rawnum} symbol, which is a combination of
32539 @code{raw} (returning a raw Calc object) and @code{num} (signaling
32540 an error if that object is not a constant).
32542 You can pass a raw Calc object to @code{calc-eval} in place of a
32543 string, either as the formula itself or as one of the @samp{$}
32544 arguments. Thus @samp{(calc-eval "$+$$" 'raw a b)} is an
32545 addition function that operates on raw Calc objects. Of course
32546 in this case it would be easier to call the low-level @code{math-add}
32547 function in Calc, if you can remember its name.
32549 In particular, note that a plain Lisp integer is acceptable to Calc
32550 as a raw object. (All Lisp integers are accepted on input, but
32551 integers of more than six decimal digits are converted to ``big-integer''
32552 form for output. @xref{Data Type Formats}.)
32554 When it comes time to display the object, just use @samp{(calc-eval a)}
32555 to format it as a string.
32557 It is an error if the input expression evaluates to a list of
32558 values. The separator symbol @code{list} is like @code{raw}
32559 except that it returns a list of one or more raw Calc objects.
32561 Note that a Lisp string is not a valid Calc object, nor is a list
32562 containing a string. Thus you can still safely distinguish all the
32563 various kinds of error returns discussed above.
32570 @subsubsection Predicates
32573 If the separator symbol is @code{pred}, the result of the formula is
32574 treated as a true/false value; @code{calc-eval} returns @code{t} or
32575 @code{nil}, respectively. A value is considered ``true'' if it is a
32576 non-zero number, or false if it is zero or if it is not a number.
32578 For example, @samp{(calc-eval "$<$$" 'pred a b)} tests whether
32579 one value is less than another.
32581 As usual, it is also possible for @code{calc-eval} to return one of
32582 the error indicators described above. Lisp will interpret such an
32583 indicator as ``true'' if you don't check for it explicitly. If you
32584 wish to have an error register as ``false'', use something like
32585 @samp{(eq (calc-eval ...) t)}.
32592 @subsubsection Variable Values
32595 Variables in the formula passed to @code{calc-eval} are not normally
32596 replaced by their values. If you wish this, you can use the
32597 @code{evalv} function (@pxref{Algebraic Manipulation}). For example,
32598 if 4 is stored in Calc variable @code{a} (i.e., in Lisp variable
32599 @code{var-a}), then @samp{(calc-eval "a+pi")} will return the
32600 formula @code{"a + pi"}, but @samp{(calc-eval "evalv(a+pi)")}
32601 will return @code{"7.14159265359"}.
32603 To store in a Calc variable, just use @code{setq} to store in the
32604 corresponding Lisp variable. (This is obtained by prepending
32605 @samp{var-} to the Calc variable name.) Calc routines will
32606 understand either string or raw form values stored in variables,
32607 although raw data objects are much more efficient. For example,
32608 to increment the Calc variable @code{a}:
32611 (setq var-a (calc-eval "evalv(a+1)" 'raw))
32619 @subsubsection Stack Access
32622 If the separator symbol is @code{push}, the formula argument is
32623 evaluated (with possible @samp{$} expansions, as usual). The
32624 result is pushed onto the Calc stack. The return value is @code{nil}
32625 (unless there is an error from evaluating the formula, in which
32626 case the return value depends on @code{calc-eval-error} in the
32629 If the separator symbol is @code{pop}, the first argument to
32630 @code{calc-eval} must be an integer instead of a string. That
32631 many values are popped from the stack and thrown away. A negative
32632 argument deletes the entry at that stack level. The return value
32633 is the number of elements remaining in the stack after popping;
32634 @samp{(calc-eval 0 'pop)} is a good way to measure the size of
32637 If the separator symbol is @code{top}, the first argument to
32638 @code{calc-eval} must again be an integer. The value at that
32639 stack level is formatted as a string and returned. Thus
32640 @samp{(calc-eval 1 'top)} returns the top-of-stack value. If the
32641 integer is out of range, @code{nil} is returned.
32643 The separator symbol @code{rawtop} is just like @code{top} except
32644 that the stack entry is returned as a raw Calc object instead of
32647 In all of these cases the first argument can be made a list in
32648 order to force the default mode settings, as described above.
32649 Thus @samp{(calc-eval '(2 calc-number-radix 16) 'top)} returns the
32650 second-to-top stack entry, formatted as a string using the default
32651 instead of current display modes, except that the radix is
32652 hexadecimal instead of decimal.
32654 It is, of course, polite to put the Calc stack back the way you
32655 found it when you are done, unless the user of your program is
32656 actually expecting it to affect the stack.
32658 Note that you do not actually have to switch into the @samp{*Calculator*}
32659 buffer in order to use @code{calc-eval}; it temporarily switches into
32660 the stack buffer if necessary.
32667 @subsubsection Keyboard Macros
32670 If the separator symbol is @code{macro}, the first argument must be a
32671 string of characters which Calc can execute as a sequence of keystrokes.
32672 This switches into the Calc buffer for the duration of the macro.
32673 For example, @samp{(calc-eval "vx5\rVR+" 'macro)} pushes the
32674 vector @samp{[1,2,3,4,5]} on the stack and then replaces it
32675 with the sum of those numbers. Note that @samp{\r} is the Lisp
32676 notation for the carriage-return, @key{RET}, character.
32678 If your keyboard macro wishes to pop the stack, @samp{\C-d} is
32679 safer than @samp{\177} (the @key{DEL} character) because some
32680 installations may have switched the meanings of @key{DEL} and
32681 @kbd{C-h}. Calc always interprets @kbd{C-d} as a synonym for
32682 ``pop-stack'' regardless of key mapping.
32684 If you provide a third argument to @code{calc-eval}, evaluation
32685 of the keyboard macro will leave a record in the Trail using
32686 that argument as a tag string. Normally the Trail is unaffected.
32688 The return value in this case is always @code{nil}.
32695 @subsubsection Lisp Evaluation
32698 Finally, if the separator symbol is @code{eval}, then the Lisp
32699 @code{eval} function is called on the first argument, which must
32700 be a Lisp expression rather than a Calc formula. Remember to
32701 quote the expression so that it is not evaluated until inside
32704 The difference from plain @code{eval} is that @code{calc-eval}
32705 switches to the Calc buffer before evaluating the expression.
32706 For example, @samp{(calc-eval '(setq calc-internal-prec 17) 'eval)}
32707 will correctly affect the buffer-local Calc precision variable.
32709 An alternative would be @samp{(calc-eval '(calc-precision 17) 'eval)}.
32710 This is evaluating a call to the function that is normally invoked
32711 by the @kbd{p} key, giving it 17 as its ``numeric prefix argument.''
32712 Note that this function will leave a message in the echo area as
32713 a side effect. Also, all Calc functions switch to the Calc buffer
32714 automatically if not invoked from there, so the above call is
32715 also equivalent to @samp{(calc-precision 17)} by itself.
32716 In all cases, Calc uses @code{save-excursion} to switch back to
32717 your original buffer when it is done.
32719 As usual the first argument can be a list that begins with a Lisp
32720 expression to use default instead of current mode settings.
32722 The result of @code{calc-eval} in this usage is just the result
32723 returned by the evaluated Lisp expression.
32730 @subsubsection Example
32733 @findex convert-temp
32734 Here is a sample Emacs command that uses @code{calc-eval}. Suppose
32735 you have a document with lots of references to temperatures on the
32736 Fahrenheit scale, say ``98.6 F'', and you wish to convert these
32737 references to Centigrade. The following command does this conversion.
32738 Place the Emacs cursor right after the letter ``F'' and invoke the
32739 command to change ``98.6 F'' to ``37 C''. Or, if the temperature is
32740 already in Centigrade form, the command changes it back to Fahrenheit.
32743 (defun convert-temp ()
32746 (re-search-backward "[^-.0-9]\\([-.0-9]+\\) *\\([FC]\\)")
32747 (let* ((top1 (match-beginning 1))
32748 (bot1 (match-end 1))
32749 (number (buffer-substring top1 bot1))
32750 (top2 (match-beginning 2))
32751 (bot2 (match-end 2))
32752 (type (buffer-substring top2 bot2)))
32753 (if (equal type "F")
32755 number (calc-eval "($ - 32)*5/9" nil number))
32757 number (calc-eval "$*9/5 + 32" nil number)))
32759 (delete-region top2 bot2)
32760 (insert-before-markers type)
32762 (delete-region top1 bot1)
32763 (if (string-match "\\.$" number) ; change "37." to "37"
32764 (setq number (substring number 0 -1)))
32768 Note the use of @code{insert-before-markers} when changing between
32769 ``F'' and ``C'', so that the character winds up before the cursor
32770 instead of after it.
32772 @node Internals, , Calling Calc from Your Programs, Lisp Definitions
32773 @subsection Calculator Internals
32776 This section describes the Lisp functions defined by the Calculator that
32777 may be of use to user-written Calculator programs (as described in the
32778 rest of this chapter). These functions are shown by their names as they
32779 conventionally appear in @code{defmath}. Their full Lisp names are
32780 generally gotten by prepending @samp{calcFunc-} or @samp{math-} to their
32781 apparent names. (Names that begin with @samp{calc-} are already in
32782 their full Lisp form.) You can use the actual full names instead if you
32783 prefer them, or if you are calling these functions from regular Lisp.
32785 The functions described here are scattered throughout the various
32786 Calc component files. Note that @file{calc.el} includes @code{autoload}s
32787 for only a few component files; when Calc wants to call an advanced
32788 function it calls @samp{(calc-extensions)} first; this function
32789 autoloads @file{calc-ext.el}, which in turn autoloads all the functions
32790 in the remaining component files.
32792 Because @code{defmath} itself uses the extensions, user-written code
32793 generally always executes with the extensions already loaded, so
32794 normally you can use any Calc function and be confident that it will
32795 be autoloaded for you when necessary. If you are doing something
32796 special, check carefully to make sure each function you are using is
32797 from @file{calc.el} or its components, and call @samp{(calc-extensions)}
32798 before using any function based in @file{calc-ext.el} if you can't
32799 prove this file will already be loaded.
32802 * Data Type Formats::
32803 * Interactive Lisp Functions::
32804 * Stack Lisp Functions::
32806 * Computational Lisp Functions::
32807 * Vector Lisp Functions::
32808 * Symbolic Lisp Functions::
32809 * Formatting Lisp Functions::
32813 @node Data Type Formats, Interactive Lisp Functions, Internals, Internals
32814 @subsubsection Data Type Formats
32817 Integers are stored in either of two ways, depending on their magnitude.
32818 Integers less than one million in absolute value are stored as standard
32819 Lisp integers. This is the only storage format for Calc data objects
32820 which is not a Lisp list.
32822 Large integers are stored as lists of the form @samp{(bigpos @var{d0}
32823 @var{d1} @var{d2} @dots{})} for positive integers 1000000 or more, or
32824 @samp{(bigneg @var{d0} @var{d1} @var{d2} @dots{})} for negative integers
32825 @mathit{-1000000} or less. Each @var{d} is a base-1000 ``digit,'' a Lisp integer
32826 from 0 to 999. The least significant digit is @var{d0}; the last digit,
32827 @var{dn}, which is always nonzero, is the most significant digit. For
32828 example, the integer @mathit{-12345678} is stored as @samp{(bigneg 678 345 12)}.
32830 The distinction between small and large integers is entirely hidden from
32831 the user. In @code{defmath} definitions, the Lisp predicate @code{integerp}
32832 returns true for either kind of integer, and in general both big and small
32833 integers are accepted anywhere the word ``integer'' is used in this manual.
32834 If the distinction must be made, native Lisp integers are called @dfn{fixnums}
32835 and large integers are called @dfn{bignums}.
32837 Fractions are stored as a list of the form, @samp{(frac @var{n} @var{d})}
32838 where @var{n} is an integer (big or small) numerator, @var{d} is an
32839 integer denominator greater than one, and @var{n} and @var{d} are relatively
32840 prime. Note that fractions where @var{d} is one are automatically converted
32841 to plain integers by all math routines; fractions where @var{d} is negative
32842 are normalized by negating the numerator and denominator.
32844 Floating-point numbers are stored in the form, @samp{(float @var{mant}
32845 @var{exp})}, where @var{mant} (the ``mantissa'') is an integer less than
32846 @samp{10^@var{p}} in absolute value (@var{p} represents the current
32847 precision), and @var{exp} (the ``exponent'') is a fixnum. The value of
32848 the float is @samp{@var{mant} * 10^@var{exp}}. For example, the number
32849 @mathit{-3.14} is stored as @samp{(float -314 -2) = -314*10^-2}. Other constraints
32850 are that the number 0.0 is always stored as @samp{(float 0 0)}, and,
32851 except for the 0.0 case, the rightmost base-10 digit of @var{mant} is
32852 always nonzero. (If the rightmost digit is zero, the number is
32853 rearranged by dividing @var{mant} by ten and incrementing @var{exp}.)
32855 Rectangular complex numbers are stored in the form @samp{(cplx @var{re}
32856 @var{im})}, where @var{re} and @var{im} are each real numbers, either
32857 integers, fractions, or floats. The value is @samp{@var{re} + @var{im}i}.
32858 The @var{im} part is nonzero; complex numbers with zero imaginary
32859 components are converted to real numbers automatically.
32861 Polar complex numbers are stored in the form @samp{(polar @var{r}
32862 @var{theta})}, where @var{r} is a positive real value and @var{theta}
32863 is a real value or HMS form representing an angle. This angle is
32864 usually normalized to lie in the interval @samp{(-180 ..@: 180)} degrees,
32865 or @samp{(-pi ..@: pi)} radians, according to the current angular mode.
32866 If the angle is 0 the value is converted to a real number automatically.
32867 (If the angle is 180 degrees, the value is usually also converted to a
32868 negative real number.)
32870 Hours-minutes-seconds forms are stored as @samp{(hms @var{h} @var{m}
32871 @var{s})}, where @var{h} is an integer or an integer-valued float (i.e.,
32872 a float with @samp{@var{exp} >= 0}), @var{m} is an integer or integer-valued
32873 float in the range @w{@samp{[0 ..@: 60)}}, and @var{s} is any real number
32874 in the range @samp{[0 ..@: 60)}.
32876 Date forms are stored as @samp{(date @var{n})}, where @var{n} is
32877 a real number that counts days since midnight on the morning of
32878 January 1, 1 AD. If @var{n} is an integer, this is a pure date
32879 form. If @var{n} is a fraction or float, this is a date/time form.
32881 Modulo forms are stored as @samp{(mod @var{n} @var{m})}, where @var{m} is a
32882 positive real number or HMS form, and @var{n} is a real number or HMS
32883 form in the range @samp{[0 ..@: @var{m})}.
32885 Error forms are stored as @samp{(sdev @var{x} @var{sigma})}, where @var{x}
32886 is the mean value and @var{sigma} is the standard deviation. Each
32887 component is either a number, an HMS form, or a symbolic object
32888 (a variable or function call). If @var{sigma} is zero, the value is
32889 converted to a plain real number. If @var{sigma} is negative or
32890 complex, it is automatically normalized to be a positive real.
32892 Interval forms are stored as @samp{(intv @var{mask} @var{lo} @var{hi})},
32893 where @var{mask} is one of the integers 0, 1, 2, or 3, and @var{lo} and
32894 @var{hi} are real numbers, HMS forms, or symbolic objects. The @var{mask}
32895 is a binary integer where 1 represents the fact that the interval is
32896 closed on the high end, and 2 represents the fact that it is closed on
32897 the low end. (Thus 3 represents a fully closed interval.) The interval
32898 @w{@samp{(intv 3 @var{x} @var{x})}} is converted to the plain number @var{x};
32899 intervals @samp{(intv @var{mask} @var{x} @var{x})} for any other @var{mask}
32900 represent empty intervals. If @var{hi} is less than @var{lo}, the interval
32901 is converted to a standard empty interval by replacing @var{hi} with @var{lo}.
32903 Vectors are stored as @samp{(vec @var{v1} @var{v2} @dots{})}, where @var{v1}
32904 is the first element of the vector, @var{v2} is the second, and so on.
32905 An empty vector is stored as @samp{(vec)}. A matrix is simply a vector
32906 where all @var{v}'s are themselves vectors of equal lengths. Note that
32907 Calc vectors are unrelated to the Emacs Lisp ``vector'' type, which is
32908 generally unused by Calc data structures.
32910 Variables are stored as @samp{(var @var{name} @var{sym})}, where
32911 @var{name} is a Lisp symbol whose print name is used as the visible name
32912 of the variable, and @var{sym} is a Lisp symbol in which the variable's
32913 value is actually stored. Thus, @samp{(var pi var-pi)} represents the
32914 special constant @samp{pi}. Almost always, the form is @samp{(var
32915 @var{v} var-@var{v})}. If the variable name was entered with @code{#}
32916 signs (which are converted to hyphens internally), the form is
32917 @samp{(var @var{u} @var{v})}, where @var{u} is a symbol whose name
32918 contains @code{#} characters, and @var{v} is a symbol that contains
32919 @code{-} characters instead. The value of a variable is the Calc
32920 object stored in its @var{sym} symbol's value cell. If the symbol's
32921 value cell is void or if it contains @code{nil}, the variable has no
32922 value. Special constants have the form @samp{(special-const
32923 @var{value})} stored in their value cell, where @var{value} is a formula
32924 which is evaluated when the constant's value is requested. Variables
32925 which represent units are not stored in any special way; they are units
32926 only because their names appear in the units table. If the value
32927 cell contains a string, it is parsed to get the variable's value when
32928 the variable is used.
32930 A Lisp list with any other symbol as the first element is a function call.
32931 The symbols @code{+}, @code{-}, @code{*}, @code{/}, @code{%}, @code{^},
32932 and @code{|} represent special binary operators; these lists are always
32933 of the form @samp{(@var{op} @var{lhs} @var{rhs})} where @var{lhs} is the
32934 sub-formula on the lefthand side and @var{rhs} is the sub-formula on the
32935 right. The symbol @code{neg} represents unary negation; this list is always
32936 of the form @samp{(neg @var{arg})}. Any other symbol @var{func} represents a
32937 function that would be displayed in function-call notation; the symbol
32938 @var{func} is in general always of the form @samp{calcFunc-@var{name}}.
32939 The function cell of the symbol @var{func} should contain a Lisp function
32940 for evaluating a call to @var{func}. This function is passed the remaining
32941 elements of the list (themselves already evaluated) as arguments; such
32942 functions should return @code{nil} or call @code{reject-arg} to signify
32943 that they should be left in symbolic form, or they should return a Calc
32944 object which represents their value, or a list of such objects if they
32945 wish to return multiple values. (The latter case is allowed only for
32946 functions which are the outer-level call in an expression whose value is
32947 about to be pushed on the stack; this feature is considered obsolete
32948 and is not used by any built-in Calc functions.)
32950 @node Interactive Lisp Functions, Stack Lisp Functions, Data Type Formats, Internals
32951 @subsubsection Interactive Functions
32954 The functions described here are used in implementing interactive Calc
32955 commands. Note that this list is not exhaustive! If there is an
32956 existing command that behaves similarly to the one you want to define,
32957 you may find helpful tricks by checking the source code for that command.
32959 @defun calc-set-command-flag flag
32960 Set the command flag @var{flag}. This is generally a Lisp symbol, but
32961 may in fact be anything. The effect is to add @var{flag} to the list
32962 stored in the variable @code{calc-command-flags}, unless it is already
32963 there. @xref{Defining Simple Commands}.
32966 @defun calc-clear-command-flag flag
32967 If @var{flag} appears among the list of currently-set command flags,
32968 remove it from that list.
32971 @defun calc-record-undo rec
32972 Add the ``undo record'' @var{rec} to the list of steps to take if the
32973 current operation should need to be undone. Stack push and pop functions
32974 automatically call @code{calc-record-undo}, so the kinds of undo records
32975 you might need to create take the form @samp{(set @var{sym} @var{value})},
32976 which says that the Lisp variable @var{sym} was changed and had previously
32977 contained @var{value}; @samp{(store @var{var} @var{value})} which says that
32978 the Calc variable @var{var} (a string which is the name of the symbol that
32979 contains the variable's value) was stored and its previous value was
32980 @var{value} (either a Calc data object, or @code{nil} if the variable was
32981 previously void); or @samp{(eval @var{undo} @var{redo} @var{args} @dots{})},
32982 which means that to undo requires calling the function @samp{(@var{undo}
32983 @var{args} @dots{})} and, if the undo is later redone, calling
32984 @samp{(@var{redo} @var{args} @dots{})}.
32987 @defun calc-record-why msg args
32988 Record the error or warning message @var{msg}, which is normally a string.
32989 This message will be replayed if the user types @kbd{w} (@code{calc-why});
32990 if the message string begins with a @samp{*}, it is considered important
32991 enough to display even if the user doesn't type @kbd{w}. If one or more
32992 @var{args} are present, the displayed message will be of the form,
32993 @samp{@var{msg}: @var{arg1}, @var{arg2}, @dots{}}, where the arguments are
32994 formatted on the assumption that they are either strings or Calc objects of
32995 some sort. If @var{msg} is a symbol, it is the name of a Calc predicate
32996 (such as @code{integerp} or @code{numvecp}) which the arguments did not
32997 satisfy; it is expanded to a suitable string such as ``Expected an
32998 integer.'' The @code{reject-arg} function calls @code{calc-record-why}
32999 automatically; @pxref{Predicates}.
33002 @defun calc-is-inverse
33003 This predicate returns true if the current command is inverse,
33004 i.e., if the Inverse (@kbd{I} key) flag was set.
33007 @defun calc-is-hyperbolic
33008 This predicate is the analogous function for the @kbd{H} key.
33011 @node Stack Lisp Functions, Predicates, Interactive Lisp Functions, Internals
33012 @subsubsection Stack-Oriented Functions
33015 The functions described here perform various operations on the Calc
33016 stack and trail. They are to be used in interactive Calc commands.
33018 @defun calc-push-list vals n
33019 Push the Calc objects in list @var{vals} onto the stack at stack level
33020 @var{n}. If @var{n} is omitted it defaults to 1, so that the elements
33021 are pushed at the top of the stack. If @var{n} is greater than 1, the
33022 elements will be inserted into the stack so that the last element will
33023 end up at level @var{n}, the next-to-last at level @var{n}+1, etc.
33024 The elements of @var{vals} are assumed to be valid Calc objects, and
33025 are not evaluated, rounded, or renormalized in any way. If @var{vals}
33026 is an empty list, nothing happens.
33028 The stack elements are pushed without any sub-formula selections.
33029 You can give an optional third argument to this function, which must
33030 be a list the same size as @var{vals} of selections. Each selection
33031 must be @code{eq} to some sub-formula of the corresponding formula
33032 in @var{vals}, or @code{nil} if that formula should have no selection.
33035 @defun calc-top-list n m
33036 Return a list of the @var{n} objects starting at level @var{m} of the
33037 stack. If @var{m} is omitted it defaults to 1, so that the elements are
33038 taken from the top of the stack. If @var{n} is omitted, it also
33039 defaults to 1, so that the top stack element (in the form of a
33040 one-element list) is returned. If @var{m} is greater than 1, the
33041 @var{m}th stack element will be at the end of the list, the @var{m}+1st
33042 element will be next-to-last, etc. If @var{n} or @var{m} are out of
33043 range, the command is aborted with a suitable error message. If @var{n}
33044 is zero, the function returns an empty list. The stack elements are not
33045 evaluated, rounded, or renormalized.
33047 If any stack elements contain selections, and selections have not
33048 been disabled by the @kbd{j e} (@code{calc-enable-selections}) command,
33049 this function returns the selected portions rather than the entire
33050 stack elements. It can be given a third ``selection-mode'' argument
33051 which selects other behaviors. If it is the symbol @code{t}, then
33052 a selection in any of the requested stack elements produces an
33053 ``invalid operation on selections'' error. If it is the symbol @code{full},
33054 the whole stack entry is always returned regardless of selections.
33055 If it is the symbol @code{sel}, the selected portion is always returned,
33056 or @code{nil} if there is no selection. (This mode ignores the @kbd{j e}
33057 command.) If the symbol is @code{entry}, the complete stack entry in
33058 list form is returned; the first element of this list will be the whole
33059 formula, and the third element will be the selection (or @code{nil}).
33062 @defun calc-pop-stack n m
33063 Remove the specified elements from the stack. The parameters @var{n}
33064 and @var{m} are defined the same as for @code{calc-top-list}. The return
33065 value of @code{calc-pop-stack} is uninteresting.
33067 If there are any selected sub-formulas among the popped elements, and
33068 @kbd{j e} has not been used to disable selections, this produces an
33069 error without changing the stack. If you supply an optional third
33070 argument of @code{t}, the stack elements are popped even if they
33071 contain selections.
33074 @defun calc-record-list vals tag
33075 This function records one or more results in the trail. The @var{vals}
33076 are a list of strings or Calc objects. The @var{tag} is the four-character
33077 tag string to identify the values. If @var{tag} is omitted, a blank tag
33081 @defun calc-normalize n
33082 This function takes a Calc object and ``normalizes'' it. At the very
33083 least this involves re-rounding floating-point values according to the
33084 current precision and other similar jobs. Also, unless the user has
33085 selected No-Simplify mode (@pxref{Simplification Modes}), this involves
33086 actually evaluating a formula object by executing the function calls
33087 it contains, and possibly also doing algebraic simplification, etc.
33090 @defun calc-top-list-n n m
33091 This function is identical to @code{calc-top-list}, except that it calls
33092 @code{calc-normalize} on the values that it takes from the stack. They
33093 are also passed through @code{check-complete}, so that incomplete
33094 objects will be rejected with an error message. All computational
33095 commands should use this in preference to @code{calc-top-list}; the only
33096 standard Calc commands that operate on the stack without normalizing
33097 are stack management commands like @code{calc-enter} and @code{calc-roll-up}.
33098 This function accepts the same optional selection-mode argument as
33099 @code{calc-top-list}.
33102 @defun calc-top-n m
33103 This function is a convenient form of @code{calc-top-list-n} in which only
33104 a single element of the stack is taken and returned, rather than a list
33105 of elements. This also accepts an optional selection-mode argument.
33108 @defun calc-enter-result n tag vals
33109 This function is a convenient interface to most of the above functions.
33110 The @var{vals} argument should be either a single Calc object, or a list
33111 of Calc objects; the object or objects are normalized, and the top @var{n}
33112 stack entries are replaced by the normalized objects. If @var{tag} is
33113 non-@code{nil}, the normalized objects are also recorded in the trail.
33114 A typical stack-based computational command would take the form,
33117 (calc-enter-result @var{n} @var{tag} (cons 'calcFunc-@var{func}
33118 (calc-top-list-n @var{n})))
33121 If any of the @var{n} stack elements replaced contain sub-formula
33122 selections, and selections have not been disabled by @kbd{j e},
33123 this function takes one of two courses of action. If @var{n} is
33124 equal to the number of elements in @var{vals}, then each element of
33125 @var{vals} is spliced into the corresponding selection; this is what
33126 happens when you use the @key{TAB} key, or when you use a unary
33127 arithmetic operation like @code{sqrt}. If @var{vals} has only one
33128 element but @var{n} is greater than one, there must be only one
33129 selection among the top @var{n} stack elements; the element from
33130 @var{vals} is spliced into that selection. This is what happens when
33131 you use a binary arithmetic operation like @kbd{+}. Any other
33132 combination of @var{n} and @var{vals} is an error when selections
33136 @defun calc-unary-op tag func arg
33137 This function implements a unary operator that allows a numeric prefix
33138 argument to apply the operator over many stack entries. If the prefix
33139 argument @var{arg} is @code{nil}, this uses @code{calc-enter-result}
33140 as outlined above. Otherwise, it maps the function over several stack
33141 elements; @pxref{Prefix Arguments}. For example,
33144 (defun calc-zeta (arg)
33146 (calc-unary-op "zeta" 'calcFunc-zeta arg))
33150 @defun calc-binary-op tag func arg ident unary
33151 This function implements a binary operator, analogously to
33152 @code{calc-unary-op}. The optional @var{ident} and @var{unary}
33153 arguments specify the behavior when the prefix argument is zero or
33154 one, respectively. If the prefix is zero, the value @var{ident}
33155 is pushed onto the stack, if specified, otherwise an error message
33156 is displayed. If the prefix is one, the unary function @var{unary}
33157 is applied to the top stack element, or, if @var{unary} is not
33158 specified, nothing happens. When the argument is two or more,
33159 the binary function @var{func} is reduced across the top @var{arg}
33160 stack elements; when the argument is negative, the function is
33161 mapped between the next-to-top @mathit{-@var{arg}} stack elements and the
33165 @defun calc-stack-size
33166 Return the number of elements on the stack as an integer. This count
33167 does not include elements that have been temporarily hidden by stack
33168 truncation; @pxref{Truncating the Stack}.
33171 @defun calc-cursor-stack-index n
33172 Move the point to the @var{n}th stack entry. If @var{n} is zero, this
33173 will be the @samp{.} line. If @var{n} is from 1 to the current stack size,
33174 this will be the beginning of the first line of that stack entry's display.
33175 If line numbers are enabled, this will move to the first character of the
33176 line number, not the stack entry itself.
33179 @defun calc-substack-height n
33180 Return the number of lines between the beginning of the @var{n}th stack
33181 entry and the bottom of the buffer. If @var{n} is zero, this
33182 will be one (assuming no stack truncation). If all stack entries are
33183 one line long (i.e., no matrices are displayed), the return value will
33184 be equal @var{n}+1 as long as @var{n} is in range. (Note that in Big
33185 mode, the return value includes the blank lines that separate stack
33189 @defun calc-refresh
33190 Erase the @code{*Calculator*} buffer and reformat its contents from memory.
33191 This must be called after changing any parameter, such as the current
33192 display radix, which might change the appearance of existing stack
33193 entries. (During a keyboard macro invoked by the @kbd{X} key, refreshing
33194 is suppressed, but a flag is set so that the entire stack will be refreshed
33195 rather than just the top few elements when the macro finishes.)
33198 @node Predicates, Computational Lisp Functions, Stack Lisp Functions, Internals
33199 @subsubsection Predicates
33202 The functions described here are predicates, that is, they return a
33203 true/false value where @code{nil} means false and anything else means
33204 true. These predicates are expanded by @code{defmath}, for example,
33205 from @code{zerop} to @code{math-zerop}. In many cases they correspond
33206 to native Lisp functions by the same name, but are extended to cover
33207 the full range of Calc data types.
33210 Returns true if @var{x} is numerically zero, in any of the Calc data
33211 types. (Note that for some types, such as error forms and intervals,
33212 it never makes sense to return true.) In @code{defmath}, the expression
33213 @samp{(= x 0)} will automatically be converted to @samp{(math-zerop x)},
33214 and @samp{(/= x 0)} will be converted to @samp{(not (math-zerop x))}.
33218 Returns true if @var{x} is negative. This accepts negative real numbers
33219 of various types, negative HMS and date forms, and intervals in which
33220 all included values are negative. In @code{defmath}, the expression
33221 @samp{(< x 0)} will automatically be converted to @samp{(math-negp x)},
33222 and @samp{(>= x 0)} will be converted to @samp{(not (math-negp x))}.
33226 Returns true if @var{x} is positive (and non-zero). For complex
33227 numbers, none of these three predicates will return true.
33230 @defun looks-negp x
33231 Returns true if @var{x} is ``negative-looking.'' This returns true if
33232 @var{x} is a negative number, or a formula with a leading minus sign
33233 such as @samp{-a/b}. In other words, this is an object which can be
33234 made simpler by calling @code{(- @var{x})}.
33238 Returns true if @var{x} is an integer of any size.
33242 Returns true if @var{x} is a native Lisp integer.
33246 Returns true if @var{x} is a nonnegative integer of any size.
33249 @defun fixnatnump x
33250 Returns true if @var{x} is a nonnegative Lisp integer.
33253 @defun num-integerp x
33254 Returns true if @var{x} is numerically an integer, i.e., either a
33255 true integer or a float with no significant digits to the right of
33259 @defun messy-integerp x
33260 Returns true if @var{x} is numerically, but not literally, an integer.
33261 A value is @code{num-integerp} if it is @code{integerp} or
33262 @code{messy-integerp} (but it is never both at once).
33265 @defun num-natnump x
33266 Returns true if @var{x} is numerically a nonnegative integer.
33270 Returns true if @var{x} is an even integer.
33273 @defun looks-evenp x
33274 Returns true if @var{x} is an even integer, or a formula with a leading
33275 multiplicative coefficient which is an even integer.
33279 Returns true if @var{x} is an odd integer.
33283 Returns true if @var{x} is a rational number, i.e., an integer or a
33288 Returns true if @var{x} is a real number, i.e., an integer, fraction,
33289 or floating-point number.
33293 Returns true if @var{x} is a real number or HMS form.
33297 Returns true if @var{x} is a float, or a complex number, error form,
33298 interval, date form, or modulo form in which at least one component
33303 Returns true if @var{x} is a rectangular or polar complex number
33304 (but not a real number).
33307 @defun rect-complexp x
33308 Returns true if @var{x} is a rectangular complex number.
33311 @defun polar-complexp x
33312 Returns true if @var{x} is a polar complex number.
33316 Returns true if @var{x} is a real number or a complex number.
33320 Returns true if @var{x} is a real or complex number or an HMS form.
33324 Returns true if @var{x} is a vector (this simply checks if its argument
33325 is a list whose first element is the symbol @code{vec}).
33329 Returns true if @var{x} is a number or vector.
33333 Returns true if @var{x} is a matrix, i.e., a vector of one or more vectors,
33334 all of the same size.
33337 @defun square-matrixp x
33338 Returns true if @var{x} is a square matrix.
33342 Returns true if @var{x} is any numeric Calc object, including real and
33343 complex numbers, HMS forms, date forms, error forms, intervals, and
33344 modulo forms. (Note that error forms and intervals may include formulas
33345 as their components; see @code{constp} below.)
33349 Returns true if @var{x} is an object or a vector. This also accepts
33350 incomplete objects, but it rejects variables and formulas (except as
33351 mentioned above for @code{objectp}).
33355 Returns true if @var{x} is a ``primitive'' or ``atomic'' Calc object,
33356 i.e., one whose components cannot be regarded as sub-formulas. This
33357 includes variables, and all @code{objectp} types except error forms
33362 Returns true if @var{x} is constant, i.e., a real or complex number,
33363 HMS form, date form, or error form, interval, or vector all of whose
33364 components are @code{constp}.
33368 Returns true if @var{x} is numerically less than @var{y}. Returns false
33369 if @var{x} is greater than or equal to @var{y}, or if the order is
33370 undefined or cannot be determined. Generally speaking, this works
33371 by checking whether @samp{@var{x} - @var{y}} is @code{negp}. In
33372 @code{defmath}, the expression @samp{(< x y)} will automatically be
33373 converted to @samp{(lessp x y)}; expressions involving @code{>}, @code{<=},
33374 and @code{>=} are similarly converted in terms of @code{lessp}.
33378 Returns true if @var{x} comes before @var{y} in a canonical ordering
33379 of Calc objects. If @var{x} and @var{y} are both real numbers, this
33380 will be the same as @code{lessp}. But whereas @code{lessp} considers
33381 other types of objects to be unordered, @code{beforep} puts any two
33382 objects into a definite, consistent order. The @code{beforep}
33383 function is used by the @kbd{V S} vector-sorting command, and also
33384 by @kbd{a s} to put the terms of a product into canonical order:
33385 This allows @samp{x y + y x} to be simplified easily to @samp{2 x y}.
33389 This is the standard Lisp @code{equal} predicate; it returns true if
33390 @var{x} and @var{y} are structurally identical. This is the usual way
33391 to compare numbers for equality, but note that @code{equal} will treat
33392 0 and 0.0 as different.
33395 @defun math-equal x y
33396 Returns true if @var{x} and @var{y} are numerically equal, either because
33397 they are @code{equal}, or because their difference is @code{zerop}. In
33398 @code{defmath}, the expression @samp{(= x y)} will automatically be
33399 converted to @samp{(math-equal x y)}.
33402 @defun equal-int x n
33403 Returns true if @var{x} and @var{n} are numerically equal, where @var{n}
33404 is a fixnum which is not a multiple of 10. This will automatically be
33405 used by @code{defmath} in place of the more general @code{math-equal}
33409 @defun nearly-equal x y
33410 Returns true if @var{x} and @var{y}, as floating-point numbers, are
33411 equal except possibly in the last decimal place. For example,
33412 314.159 and 314.166 are considered nearly equal if the current
33413 precision is 6 (since they differ by 7 units), but not if the current
33414 precision is 7 (since they differ by 70 units). Most functions which
33415 use series expansions use @code{with-extra-prec} to evaluate the
33416 series with 2 extra digits of precision, then use @code{nearly-equal}
33417 to decide when the series has converged; this guards against cumulative
33418 error in the series evaluation without doing extra work which would be
33419 lost when the result is rounded back down to the current precision.
33420 In @code{defmath}, this can be written @samp{(~= @var{x} @var{y})}.
33421 The @var{x} and @var{y} can be numbers of any kind, including complex.
33424 @defun nearly-zerop x y
33425 Returns true if @var{x} is nearly zero, compared to @var{y}. This
33426 checks whether @var{x} plus @var{y} would by be @code{nearly-equal}
33427 to @var{y} itself, to within the current precision, in other words,
33428 if adding @var{x} to @var{y} would have a negligible effect on @var{y}
33429 due to roundoff error. @var{X} may be a real or complex number, but
33430 @var{y} must be real.
33434 Return true if the formula @var{x} represents a true value in
33435 Calc, not Lisp, terms. It tests if @var{x} is a non-zero number
33436 or a provably non-zero formula.
33439 @defun reject-arg val pred
33440 Abort the current function evaluation due to unacceptable argument values.
33441 This calls @samp{(calc-record-why @var{pred} @var{val})}, then signals a
33442 Lisp error which @code{normalize} will trap. The net effect is that the
33443 function call which led here will be left in symbolic form.
33446 @defun inexact-value
33447 If Symbolic mode is enabled, this will signal an error that causes
33448 @code{normalize} to leave the formula in symbolic form, with the message
33449 ``Inexact result.'' (This function has no effect when not in Symbolic mode.)
33450 Note that if your function calls @samp{(sin 5)} in Symbolic mode, the
33451 @code{sin} function will call @code{inexact-value}, which will cause your
33452 function to be left unsimplified. You may instead wish to call
33453 @samp{(normalize (list 'calcFunc-sin 5))}, which in Symbolic mode will
33454 return the formula @samp{sin(5)} to your function.
33458 This signals an error that will be reported as a floating-point overflow.
33462 This signals a floating-point underflow.
33465 @node Computational Lisp Functions, Vector Lisp Functions, Predicates, Internals
33466 @subsubsection Computational Functions
33469 The functions described here do the actual computational work of the
33470 Calculator. In addition to these, note that any function described in
33471 the main body of this manual may be called from Lisp; for example, if
33472 the documentation refers to the @code{calc-sqrt} [@code{sqrt}] command,
33473 this means @code{calc-sqrt} is an interactive stack-based square-root
33474 command and @code{sqrt} (which @code{defmath} expands to @code{calcFunc-sqrt})
33475 is the actual Lisp function for taking square roots.
33477 The functions @code{math-add}, @code{math-sub}, @code{math-mul},
33478 @code{math-div}, @code{math-mod}, and @code{math-neg} are not included
33479 in this list, since @code{defmath} allows you to write native Lisp
33480 @code{+}, @code{-}, @code{*}, @code{/}, @code{%}, and unary @code{-},
33481 respectively, instead.
33483 @defun normalize val
33484 (Full form: @code{math-normalize}.)
33485 Reduce the value @var{val} to standard form. For example, if @var{val}
33486 is a fixnum, it will be converted to a bignum if it is too large, and
33487 if @var{val} is a bignum it will be normalized by clipping off trailing
33488 (i.e., most-significant) zero digits and converting to a fixnum if it is
33489 small. All the various data types are similarly converted to their standard
33490 forms. Variables are left alone, but function calls are actually evaluated
33491 in formulas. For example, normalizing @samp{(+ 2 (calcFunc-abs -4))} will
33494 If a function call fails, because the function is void or has the wrong
33495 number of parameters, or because it returns @code{nil} or calls
33496 @code{reject-arg} or @code{inexact-result}, @code{normalize} returns
33497 the formula still in symbolic form.
33499 If the current simplification mode is ``none'' or ``numeric arguments
33500 only,'' @code{normalize} will act appropriately. However, the more
33501 powerful simplification modes (like Algebraic Simplification) are
33502 not handled by @code{normalize}. They are handled by @code{calc-normalize},
33503 which calls @code{normalize} and possibly some other routines, such
33504 as @code{simplify} or @code{simplify-units}. Programs generally will
33505 never call @code{calc-normalize} except when popping or pushing values
33509 @defun evaluate-expr expr
33510 Replace all variables in @var{expr} that have values with their values,
33511 then use @code{normalize} to simplify the result. This is what happens
33512 when you press the @kbd{=} key interactively.
33515 @defmac with-extra-prec n body
33516 Evaluate the Lisp forms in @var{body} with precision increased by @var{n}
33517 digits. This is a macro which expands to
33521 (let ((calc-internal-prec (+ calc-internal-prec @var{n})))
33525 The surrounding call to @code{math-normalize} causes a floating-point
33526 result to be rounded down to the original precision afterwards. This
33527 is important because some arithmetic operations assume a number's
33528 mantissa contains no more digits than the current precision allows.
33531 @defun make-frac n d
33532 Build a fraction @samp{@var{n}:@var{d}}. This is equivalent to calling
33533 @samp{(normalize (list 'frac @var{n} @var{d}))}, but more efficient.
33536 @defun make-float mant exp
33537 Build a floating-point value out of @var{mant} and @var{exp}, both
33538 of which are arbitrary integers. This function will return a
33539 properly normalized float value, or signal an overflow or underflow
33540 if @var{exp} is out of range.
33543 @defun make-sdev x sigma
33544 Build an error form out of @var{x} and the absolute value of @var{sigma}.
33545 If @var{sigma} is zero, the result is the number @var{x} directly.
33546 If @var{sigma} is negative or complex, its absolute value is used.
33547 If @var{x} or @var{sigma} is not a valid type of object for use in
33548 error forms, this calls @code{reject-arg}.
33551 @defun make-intv mask lo hi
33552 Build an interval form out of @var{mask} (which is assumed to be an
33553 integer from 0 to 3), and the limits @var{lo} and @var{hi}. If
33554 @var{lo} is greater than @var{hi}, an empty interval form is returned.
33555 This calls @code{reject-arg} if @var{lo} or @var{hi} is unsuitable.
33558 @defun sort-intv mask lo hi
33559 Build an interval form, similar to @code{make-intv}, except that if
33560 @var{lo} is less than @var{hi} they are simply exchanged, and the
33561 bits of @var{mask} are swapped accordingly.
33564 @defun make-mod n m
33565 Build a modulo form out of @var{n} and the modulus @var{m}. Since modulo
33566 forms do not allow formulas as their components, if @var{n} or @var{m}
33567 is not a real number or HMS form the result will be a formula which
33568 is a call to @code{makemod}, the algebraic version of this function.
33572 Convert @var{x} to floating-point form. Integers and fractions are
33573 converted to numerically equivalent floats; components of complex
33574 numbers, vectors, HMS forms, date forms, error forms, intervals, and
33575 modulo forms are recursively floated. If the argument is a variable
33576 or formula, this calls @code{reject-arg}.
33580 Compare the numbers @var{x} and @var{y}, and return @mathit{-1} if
33581 @samp{(lessp @var{x} @var{y})}, 1 if @samp{(lessp @var{y} @var{x})},
33582 0 if @samp{(math-equal @var{x} @var{y})}, or 2 if the order is
33583 undefined or cannot be determined.
33587 Return the number of digits of integer @var{n}, effectively
33588 @samp{ceil(log10(@var{n}))}, but much more efficient. Zero is
33589 considered to have zero digits.
33592 @defun scale-int x n
33593 Shift integer @var{x} left @var{n} decimal digits, or right @mathit{-@var{n}}
33594 digits with truncation toward zero.
33597 @defun scale-rounding x n
33598 Like @code{scale-int}, except that a right shift rounds to the nearest
33599 integer rather than truncating.
33603 Return the integer @var{n} as a fixnum, i.e., a native Lisp integer.
33604 If @var{n} is outside the permissible range for Lisp integers (usually
33605 24 binary bits) the result is undefined.
33609 Compute the square of @var{x}; short for @samp{(* @var{x} @var{x})}.
33612 @defun quotient x y
33613 Divide integer @var{x} by integer @var{y}; return an integer quotient
33614 and discard the remainder. If @var{x} or @var{y} is negative, the
33615 direction of rounding is undefined.
33619 Perform an integer division; if @var{x} and @var{y} are both nonnegative
33620 integers, this uses the @code{quotient} function, otherwise it computes
33621 @samp{floor(@var{x}/@var{y})}. Thus the result is well-defined but
33622 slower than for @code{quotient}.
33626 Divide integer @var{x} by integer @var{y}; return the integer remainder
33627 and discard the quotient. Like @code{quotient}, this works only for
33628 integer arguments and is not well-defined for negative arguments.
33629 For a more well-defined result, use @samp{(% @var{x} @var{y})}.
33633 Divide integer @var{x} by integer @var{y}; return a cons cell whose
33634 @code{car} is @samp{(quotient @var{x} @var{y})} and whose @code{cdr}
33635 is @samp{(imod @var{x} @var{y})}.
33639 Compute @var{x} to the power @var{y}. In @code{defmath} code, this can
33640 also be written @samp{(^ @var{x} @var{y})} or
33641 @w{@samp{(expt @var{x} @var{y})}}.
33644 @defun abs-approx x
33645 Compute a fast approximation to the absolute value of @var{x}. For
33646 example, for a rectangular complex number the result is the sum of
33647 the absolute values of the components.
33651 @findex gamma-const
33657 @findex pi-over-180
33658 @findex sqrt-two-pi
33662 The function @samp{(pi)} computes @samp{pi} to the current precision.
33663 Other related constant-generating functions are @code{two-pi},
33664 @code{pi-over-2}, @code{pi-over-4}, @code{pi-over-180}, @code{sqrt-two-pi},
33665 @code{e}, @code{sqrt-e}, @code{ln-2}, @code{ln-10}, @code{phi} and
33666 @code{gamma-const}. Each function returns a floating-point value in the
33667 current precision, and each uses caching so that all calls after the
33668 first are essentially free.
33671 @defmac math-defcache @var{func} @var{initial} @var{form}
33672 This macro, usually used as a top-level call like @code{defun} or
33673 @code{defvar}, defines a new cached constant analogous to @code{pi}, etc.
33674 It defines a function @code{func} which returns the requested value;
33675 if @var{initial} is non-@code{nil} it must be a @samp{(float @dots{})}
33676 form which serves as an initial value for the cache. If @var{func}
33677 is called when the cache is empty or does not have enough digits to
33678 satisfy the current precision, the Lisp expression @var{form} is evaluated
33679 with the current precision increased by four, and the result minus its
33680 two least significant digits is stored in the cache. For example,
33681 calling @samp{(pi)} with a precision of 30 computes @samp{pi} to 34
33682 digits, rounds it down to 32 digits for future use, then rounds it
33683 again to 30 digits for use in the present request.
33686 @findex half-circle
33687 @findex quarter-circle
33688 @defun full-circle symb
33689 If the current angular mode is Degrees or HMS, this function returns the
33690 integer 360. In Radians mode, this function returns either the
33691 corresponding value in radians to the current precision, or the formula
33692 @samp{2*pi}, depending on the Symbolic mode. There are also similar
33693 function @code{half-circle} and @code{quarter-circle}.
33696 @defun power-of-2 n
33697 Compute two to the integer power @var{n}, as a (potentially very large)
33698 integer. Powers of two are cached, so only the first call for a
33699 particular @var{n} is expensive.
33702 @defun integer-log2 n
33703 Compute the base-2 logarithm of @var{n}, which must be an integer which
33704 is a power of two. If @var{n} is not a power of two, this function will
33708 @defun div-mod a b m
33709 Divide @var{a} by @var{b}, modulo @var{m}. This returns @code{nil} if
33710 there is no solution, or if any of the arguments are not integers.
33713 @defun pow-mod a b m
33714 Compute @var{a} to the power @var{b}, modulo @var{m}. If @var{a},
33715 @var{b}, and @var{m} are integers, this uses an especially efficient
33716 algorithm. Otherwise, it simply computes @samp{(% (^ a b) m)}.
33720 Compute the integer square root of @var{n}. This is the square root
33721 of @var{n} rounded down toward zero, i.e., @samp{floor(sqrt(@var{n}))}.
33722 If @var{n} is itself an integer, the computation is especially efficient.
33725 @defun to-hms a ang
33726 Convert the argument @var{a} into an HMS form. If @var{ang} is specified,
33727 it is the angular mode in which to interpret @var{a}, either @code{deg}
33728 or @code{rad}. Otherwise, the current angular mode is used. If @var{a}
33729 is already an HMS form it is returned as-is.
33732 @defun from-hms a ang
33733 Convert the HMS form @var{a} into a real number. If @var{ang} is specified,
33734 it is the angular mode in which to express the result, otherwise the
33735 current angular mode is used. If @var{a} is already a real number, it
33739 @defun to-radians a
33740 Convert the number or HMS form @var{a} to radians from the current
33744 @defun from-radians a
33745 Convert the number @var{a} from radians to the current angular mode.
33746 If @var{a} is a formula, this returns the formula @samp{deg(@var{a})}.
33749 @defun to-radians-2 a
33750 Like @code{to-radians}, except that in Symbolic mode a degrees to
33751 radians conversion yields a formula like @samp{@var{a}*pi/180}.
33754 @defun from-radians-2 a
33755 Like @code{from-radians}, except that in Symbolic mode a radians to
33756 degrees conversion yields a formula like @samp{@var{a}*180/pi}.
33759 @defun random-digit
33760 Produce a random base-1000 digit in the range 0 to 999.
33763 @defun random-digits n
33764 Produce a random @var{n}-digit integer; this will be an integer
33765 in the interval @samp{[0, 10^@var{n})}.
33768 @defun random-float
33769 Produce a random float in the interval @samp{[0, 1)}.
33772 @defun prime-test n iters
33773 Determine whether the integer @var{n} is prime. Return a list which has
33774 one of these forms: @samp{(nil @var{f})} means the number is non-prime
33775 because it was found to be divisible by @var{f}; @samp{(nil)} means it
33776 was found to be non-prime by table look-up (so no factors are known);
33777 @samp{(nil unknown)} means it is definitely non-prime but no factors
33778 are known because @var{n} was large enough that Fermat's probabilistic
33779 test had to be used; @samp{(t)} means the number is definitely prime;
33780 and @samp{(maybe @var{i} @var{p})} means that Fermat's test, after @var{i}
33781 iterations, is @var{p} percent sure that the number is prime. The
33782 @var{iters} parameter is the number of Fermat iterations to use, in the
33783 case that this is necessary. If @code{prime-test} returns ``maybe,''
33784 you can call it again with the same @var{n} to get a greater certainty;
33785 @code{prime-test} remembers where it left off.
33788 @defun to-simple-fraction f
33789 If @var{f} is a floating-point number which can be represented exactly
33790 as a small rational number. return that number, else return @var{f}.
33791 For example, 0.75 would be converted to 3:4. This function is very
33795 @defun to-fraction f tol
33796 Find a rational approximation to floating-point number @var{f} to within
33797 a specified tolerance @var{tol}; this corresponds to the algebraic
33798 function @code{frac}, and can be rather slow.
33801 @defun quarter-integer n
33802 If @var{n} is an integer or integer-valued float, this function
33803 returns zero. If @var{n} is a half-integer (i.e., an integer plus
33804 @mathit{1:2} or 0.5), it returns 2. If @var{n} is a quarter-integer,
33805 it returns 1 or 3. If @var{n} is anything else, this function
33806 returns @code{nil}.
33809 @node Vector Lisp Functions, Symbolic Lisp Functions, Computational Lisp Functions, Internals
33810 @subsubsection Vector Functions
33813 The functions described here perform various operations on vectors and
33816 @defun math-concat x y
33817 Do a vector concatenation; this operation is written @samp{@var{x} | @var{y}}
33818 in a symbolic formula. @xref{Building Vectors}.
33821 @defun vec-length v
33822 Return the length of vector @var{v}. If @var{v} is not a vector, the
33823 result is zero. If @var{v} is a matrix, this returns the number of
33824 rows in the matrix.
33827 @defun mat-dimens m
33828 Determine the dimensions of vector or matrix @var{m}. If @var{m} is not
33829 a vector, the result is an empty list. If @var{m} is a plain vector
33830 but not a matrix, the result is a one-element list containing the length
33831 of the vector. If @var{m} is a matrix with @var{r} rows and @var{c} columns,
33832 the result is the list @samp{(@var{r} @var{c})}. Higher-order tensors
33833 produce lists of more than two dimensions. Note that the object
33834 @samp{[[1, 2, 3], [4, 5]]} is a vector of vectors not all the same size,
33835 and is treated by this and other Calc routines as a plain vector of two
33839 @defun dimension-error
33840 Abort the current function with a message of ``Dimension error.''
33841 The Calculator will leave the function being evaluated in symbolic
33842 form; this is really just a special case of @code{reject-arg}.
33845 @defun build-vector args
33846 Return a Calc vector with @var{args} as elements.
33847 For example, @samp{(build-vector 1 2 3)} returns the Calc vector
33848 @samp{[1, 2, 3]}, stored internally as the list @samp{(vec 1 2 3)}.
33851 @defun make-vec obj dims
33852 Return a Calc vector or matrix all of whose elements are equal to
33853 @var{obj}. For example, @samp{(make-vec 27 3 4)} returns a 3x4 matrix
33857 @defun row-matrix v
33858 If @var{v} is a plain vector, convert it into a row matrix, i.e.,
33859 a matrix whose single row is @var{v}. If @var{v} is already a matrix,
33863 @defun col-matrix v
33864 If @var{v} is a plain vector, convert it into a column matrix, i.e., a
33865 matrix with each element of @var{v} as a separate row. If @var{v} is
33866 already a matrix, leave it alone.
33870 Map the Lisp function @var{f} over the Calc vector @var{v}. For example,
33871 @samp{(map-vec 'math-floor v)} returns a vector of the floored components
33875 @defun map-vec-2 f a b
33876 Map the Lisp function @var{f} over the two vectors @var{a} and @var{b}.
33877 If @var{a} and @var{b} are vectors of equal length, the result is a
33878 vector of the results of calling @samp{(@var{f} @var{ai} @var{bi})}
33879 for each pair of elements @var{ai} and @var{bi}. If either @var{a} or
33880 @var{b} is a scalar, it is matched with each value of the other vector.
33881 For example, @samp{(map-vec-2 'math-add v 1)} returns the vector @var{v}
33882 with each element increased by one. Note that using @samp{'+} would not
33883 work here, since @code{defmath} does not expand function names everywhere,
33884 just where they are in the function position of a Lisp expression.
33887 @defun reduce-vec f v
33888 Reduce the function @var{f} over the vector @var{v}. For example, if
33889 @var{v} is @samp{[10, 20, 30, 40]}, this calls @samp{(f (f (f 10 20) 30) 40)}.
33890 If @var{v} is a matrix, this reduces over the rows of @var{v}.
33893 @defun reduce-cols f m
33894 Reduce the function @var{f} over the columns of matrix @var{m}. For
33895 example, if @var{m} is @samp{[[1, 2], [3, 4], [5, 6]]}, the result
33896 is a vector of the two elements @samp{(f (f 1 3) 5)} and @samp{(f (f 2 4) 6)}.
33900 Return the @var{n}th row of matrix @var{m}. This is equivalent to
33901 @samp{(elt m n)}. For a slower but safer version, use @code{mrow}.
33902 (@xref{Extracting Elements}.)
33906 Return the @var{n}th column of matrix @var{m}, in the form of a vector.
33907 The arguments are not checked for correctness.
33910 @defun mat-less-row m n
33911 Return a copy of matrix @var{m} with its @var{n}th row deleted. The
33912 number @var{n} must be in range from 1 to the number of rows in @var{m}.
33915 @defun mat-less-col m n
33916 Return a copy of matrix @var{m} with its @var{n}th column deleted.
33920 Return the transpose of matrix @var{m}.
33923 @defun flatten-vector v
33924 Flatten nested vector @var{v} into a vector of scalars. For example,
33925 if @var{v} is @samp{[[1, 2, 3], [4, 5]]} the result is @samp{[1, 2, 3, 4, 5]}.
33928 @defun copy-matrix m
33929 If @var{m} is a matrix, return a copy of @var{m}. This maps
33930 @code{copy-sequence} over the rows of @var{m}; in Lisp terms, each
33931 element of the result matrix will be @code{eq} to the corresponding
33932 element of @var{m}, but none of the @code{cons} cells that make up
33933 the structure of the matrix will be @code{eq}. If @var{m} is a plain
33934 vector, this is the same as @code{copy-sequence}.
33937 @defun swap-rows m r1 r2
33938 Exchange rows @var{r1} and @var{r2} of matrix @var{m} in-place. In
33939 other words, unlike most of the other functions described here, this
33940 function changes @var{m} itself rather than building up a new result
33941 matrix. The return value is @var{m}, i.e., @samp{(eq (swap-rows m 1 2) m)}
33942 is true, with the side effect of exchanging the first two rows of
33946 @node Symbolic Lisp Functions, Formatting Lisp Functions, Vector Lisp Functions, Internals
33947 @subsubsection Symbolic Functions
33950 The functions described here operate on symbolic formulas in the
33953 @defun calc-prepare-selection num
33954 Prepare a stack entry for selection operations. If @var{num} is
33955 omitted, the stack entry containing the cursor is used; otherwise,
33956 it is the number of the stack entry to use. This function stores
33957 useful information about the current stack entry into a set of
33958 variables. @code{calc-selection-cache-num} contains the number of
33959 the stack entry involved (equal to @var{num} if you specified it);
33960 @code{calc-selection-cache-entry} contains the stack entry as a
33961 list (such as @code{calc-top-list} would return with @code{entry}
33962 as the selection mode); and @code{calc-selection-cache-comp} contains
33963 a special ``tagged'' composition (@pxref{Formatting Lisp Functions})
33964 which allows Calc to relate cursor positions in the buffer with
33965 their corresponding sub-formulas.
33967 A slight complication arises in the selection mechanism because
33968 formulas may contain small integers. For example, in the vector
33969 @samp{[1, 2, 1]} the first and last elements are @code{eq} to each
33970 other; selections are recorded as the actual Lisp object that
33971 appears somewhere in the tree of the whole formula, but storing
33972 @code{1} would falsely select both @code{1}'s in the vector. So
33973 @code{calc-prepare-selection} also checks the stack entry and
33974 replaces any plain integers with ``complex number'' lists of the form
33975 @samp{(cplx @var{n} 0)}. This list will be displayed the same as a
33976 plain @var{n} and the change will be completely invisible to the
33977 user, but it will guarantee that no two sub-formulas of the stack
33978 entry will be @code{eq} to each other. Next time the stack entry
33979 is involved in a computation, @code{calc-normalize} will replace
33980 these lists with plain numbers again, again invisibly to the user.
33983 @defun calc-encase-atoms x
33984 This modifies the formula @var{x} to ensure that each part of the
33985 formula is a unique atom, using the @samp{(cplx @var{n} 0)} trick
33986 described above. This function may use @code{setcar} to modify
33987 the formula in-place.
33990 @defun calc-find-selected-part
33991 Find the smallest sub-formula of the current formula that contains
33992 the cursor. This assumes @code{calc-prepare-selection} has been
33993 called already. If the cursor is not actually on any part of the
33994 formula, this returns @code{nil}.
33997 @defun calc-change-current-selection selection
33998 Change the currently prepared stack element's selection to
33999 @var{selection}, which should be @code{eq} to some sub-formula
34000 of the stack element, or @code{nil} to unselect the formula.
34001 The stack element's appearance in the Calc buffer is adjusted
34002 to reflect the new selection.
34005 @defun calc-find-nth-part expr n
34006 Return the @var{n}th sub-formula of @var{expr}. This function is used
34007 by the selection commands, and (unless @kbd{j b} has been used) treats
34008 sums and products as flat many-element formulas. Thus if @var{expr}
34009 is @samp{((a + b) - c) + d}, calling @code{calc-find-nth-part} with
34010 @var{n} equal to four will return @samp{d}.
34013 @defun calc-find-parent-formula expr part
34014 Return the sub-formula of @var{expr} which immediately contains
34015 @var{part}. If @var{expr} is @samp{a*b + (c+1)*d} and @var{part}
34016 is @code{eq} to the @samp{c+1} term of @var{expr}, then this function
34017 will return @samp{(c+1)*d}. If @var{part} turns out not to be a
34018 sub-formula of @var{expr}, the function returns @code{nil}. If
34019 @var{part} is @code{eq} to @var{expr}, the function returns @code{t}.
34020 This function does not take associativity into account.
34023 @defun calc-find-assoc-parent-formula expr part
34024 This is the same as @code{calc-find-parent-formula}, except that
34025 (unless @kbd{j b} has been used) it continues widening the selection
34026 to contain a complete level of the formula. Given @samp{a} from
34027 @samp{((a + b) - c) + d}, @code{calc-find-parent-formula} will
34028 return @samp{a + b} but @code{calc-find-assoc-parent-formula} will
34029 return the whole expression.
34032 @defun calc-grow-assoc-formula expr part
34033 This expands sub-formula @var{part} of @var{expr} to encompass a
34034 complete level of the formula. If @var{part} and its immediate
34035 parent are not compatible associative operators, or if @kbd{j b}
34036 has been used, this simply returns @var{part}.
34039 @defun calc-find-sub-formula expr part
34040 This finds the immediate sub-formula of @var{expr} which contains
34041 @var{part}. It returns an index @var{n} such that
34042 @samp{(calc-find-nth-part @var{expr} @var{n})} would return @var{part}.
34043 If @var{part} is not a sub-formula of @var{expr}, it returns @code{nil}.
34044 If @var{part} is @code{eq} to @var{expr}, it returns @code{t}. This
34045 function does not take associativity into account.
34048 @defun calc-replace-sub-formula expr old new
34049 This function returns a copy of formula @var{expr}, with the
34050 sub-formula that is @code{eq} to @var{old} replaced by @var{new}.
34053 @defun simplify expr
34054 Simplify the expression @var{expr} by applying various algebraic rules.
34055 This is what the @w{@kbd{a s}} (@code{calc-simplify}) command uses. This
34056 always returns a copy of the expression; the structure @var{expr} points
34057 to remains unchanged in memory.
34059 More precisely, here is what @code{simplify} does: The expression is
34060 first normalized and evaluated by calling @code{normalize}. If any
34061 @code{AlgSimpRules} have been defined, they are then applied. Then
34062 the expression is traversed in a depth-first, bottom-up fashion; at
34063 each level, any simplifications that can be made are made until no
34064 further changes are possible. Once the entire formula has been
34065 traversed in this way, it is compared with the original formula (from
34066 before the call to @code{normalize}) and, if it has changed,
34067 the entire procedure is repeated (starting with @code{normalize})
34068 until no further changes occur. Usually only two iterations are
34069 needed:@: one to simplify the formula, and another to verify that no
34070 further simplifications were possible.
34073 @defun simplify-extended expr
34074 Simplify the expression @var{expr}, with additional rules enabled that
34075 help do a more thorough job, while not being entirely ``safe'' in all
34076 circumstances. (For example, this mode will simplify @samp{sqrt(x^2)}
34077 to @samp{x}, which is only valid when @var{x} is positive.) This is
34078 implemented by temporarily binding the variable @code{math-living-dangerously}
34079 to @code{t} (using a @code{let} form) and calling @code{simplify}.
34080 Dangerous simplification rules are written to check this variable
34081 before taking any action.
34084 @defun simplify-units expr
34085 Simplify the expression @var{expr}, treating variable names as units
34086 whenever possible. This works by binding the variable
34087 @code{math-simplifying-units} to @code{t} while calling @code{simplify}.
34090 @defmac math-defsimplify funcs body
34091 Register a new simplification rule; this is normally called as a top-level
34092 form, like @code{defun} or @code{defmath}. If @var{funcs} is a symbol
34093 (like @code{+} or @code{calcFunc-sqrt}), this simplification rule is
34094 applied to the formulas which are calls to the specified function. Or,
34095 @var{funcs} can be a list of such symbols; the rule applies to all
34096 functions on the list. The @var{body} is written like the body of a
34097 function with a single argument called @code{expr}. The body will be
34098 executed with @code{expr} bound to a formula which is a call to one of
34099 the functions @var{funcs}. If the function body returns @code{nil}, or
34100 if it returns a result @code{equal} to the original @code{expr}, it is
34101 ignored and Calc goes on to try the next simplification rule that applies.
34102 If the function body returns something different, that new formula is
34103 substituted for @var{expr} in the original formula.
34105 At each point in the formula, rules are tried in the order of the
34106 original calls to @code{math-defsimplify}; the search stops after the
34107 first rule that makes a change. Thus later rules for that same
34108 function will not have a chance to trigger until the next iteration
34109 of the main @code{simplify} loop.
34111 Note that, since @code{defmath} is not being used here, @var{body} must
34112 be written in true Lisp code without the conveniences that @code{defmath}
34113 provides. If you prefer, you can have @var{body} simply call another
34114 function (defined with @code{defmath}) which does the real work.
34116 The arguments of a function call will already have been simplified
34117 before any rules for the call itself are invoked. Since a new argument
34118 list is consed up when this happens, this means that the rule's body is
34119 allowed to rearrange the function's arguments destructively if that is
34120 convenient. Here is a typical example of a simplification rule:
34123 (math-defsimplify calcFunc-arcsinh
34124 (or (and (math-looks-negp (nth 1 expr))
34125 (math-neg (list 'calcFunc-arcsinh
34126 (math-neg (nth 1 expr)))))
34127 (and (eq (car-safe (nth 1 expr)) 'calcFunc-sinh)
34128 (or math-living-dangerously
34129 (math-known-realp (nth 1 (nth 1 expr))))
34130 (nth 1 (nth 1 expr)))))
34133 This is really a pair of rules written with one @code{math-defsimplify}
34134 for convenience; the first replaces @samp{arcsinh(-x)} with
34135 @samp{-arcsinh(x)}, and the second, which is safe only for real @samp{x},
34136 replaces @samp{arcsinh(sinh(x))} with @samp{x}.
34139 @defun common-constant-factor expr
34140 Check @var{expr} to see if it is a sum of terms all multiplied by the
34141 same rational value. If so, return this value. If not, return @code{nil}.
34142 For example, if called on @samp{6x + 9y + 12z}, it would return 3, since
34143 3 is a common factor of all the terms.
34146 @defun cancel-common-factor expr factor
34147 Assuming @var{expr} is a sum with @var{factor} as a common factor,
34148 divide each term of the sum by @var{factor}. This is done by
34149 destructively modifying parts of @var{expr}, on the assumption that
34150 it is being used by a simplification rule (where such things are
34151 allowed; see above). For example, consider this built-in rule for
34155 (math-defsimplify calcFunc-sqrt
34156 (let ((fac (math-common-constant-factor (nth 1 expr))))
34157 (and fac (not (eq fac 1))
34158 (math-mul (math-normalize (list 'calcFunc-sqrt fac))
34160 (list 'calcFunc-sqrt
34161 (math-cancel-common-factor
34162 (nth 1 expr) fac)))))))
34166 @defun frac-gcd a b
34167 Compute a ``rational GCD'' of @var{a} and @var{b}, which must both be
34168 rational numbers. This is the fraction composed of the GCD of the
34169 numerators of @var{a} and @var{b}, over the GCD of the denominators.
34170 It is used by @code{common-constant-factor}. Note that the standard
34171 @code{gcd} function uses the LCM to combine the denominators.
34174 @defun map-tree func expr many
34175 Try applying Lisp function @var{func} to various sub-expressions of
34176 @var{expr}. Initially, call @var{func} with @var{expr} itself as an
34177 argument. If this returns an expression which is not @code{equal} to
34178 @var{expr}, apply @var{func} again until eventually it does return
34179 @var{expr} with no changes. Then, if @var{expr} is a function call,
34180 recursively apply @var{func} to each of the arguments. This keeps going
34181 until no changes occur anywhere in the expression; this final expression
34182 is returned by @code{map-tree}. Note that, unlike simplification rules,
34183 @var{func} functions may @emph{not} make destructive changes to
34184 @var{expr}. If a third argument @var{many} is provided, it is an
34185 integer which says how many times @var{func} may be applied; the
34186 default, as described above, is infinitely many times.
34189 @defun compile-rewrites rules
34190 Compile the rewrite rule set specified by @var{rules}, which should
34191 be a formula that is either a vector or a variable name. If the latter,
34192 the compiled rules are saved so that later @code{compile-rules} calls
34193 for that same variable can return immediately. If there are problems
34194 with the rules, this function calls @code{error} with a suitable
34198 @defun apply-rewrites expr crules heads
34199 Apply the compiled rewrite rule set @var{crules} to the expression
34200 @var{expr}. This will make only one rewrite and only checks at the
34201 top level of the expression. The result @code{nil} if no rules
34202 matched, or if the only rules that matched did not actually change
34203 the expression. The @var{heads} argument is optional; if is given,
34204 it should be a list of all function names that (may) appear in
34205 @var{expr}. The rewrite compiler tags each rule with the
34206 rarest-looking function name in the rule; if you specify @var{heads},
34207 @code{apply-rewrites} can use this information to narrow its search
34208 down to just a few rules in the rule set.
34211 @defun rewrite-heads expr
34212 Compute a @var{heads} list for @var{expr} suitable for use with
34213 @code{apply-rewrites}, as discussed above.
34216 @defun rewrite expr rules many
34217 This is an all-in-one rewrite function. It compiles the rule set
34218 specified by @var{rules}, then uses @code{map-tree} to apply the
34219 rules throughout @var{expr} up to @var{many} (default infinity)
34223 @defun match-patterns pat vec not-flag
34224 Given a Calc vector @var{vec} and an uncompiled pattern set or
34225 pattern set variable @var{pat}, this function returns a new vector
34226 of all elements of @var{vec} which do (or don't, if @var{not-flag} is
34227 non-@code{nil}) match any of the patterns in @var{pat}.
34230 @defun deriv expr var value symb
34231 Compute the derivative of @var{expr} with respect to variable @var{var}
34232 (which may actually be any sub-expression). If @var{value} is specified,
34233 the derivative is evaluated at the value of @var{var}; otherwise, the
34234 derivative is left in terms of @var{var}. If the expression contains
34235 functions for which no derivative formula is known, new derivative
34236 functions are invented by adding primes to the names; @pxref{Calculus}.
34237 However, if @var{symb} is non-@code{nil}, the presence of undifferentiable
34238 functions in @var{expr} instead cancels the whole differentiation, and
34239 @code{deriv} returns @code{nil} instead.
34241 Derivatives of an @var{n}-argument function can be defined by
34242 adding a @code{math-derivative-@var{n}} property to the property list
34243 of the symbol for the function's derivative, which will be the
34244 function name followed by an apostrophe. The value of the property
34245 should be a Lisp function; it is called with the same arguments as the
34246 original function call that is being differentiated. It should return
34247 a formula for the derivative. For example, the derivative of @code{ln}
34251 (put 'calcFunc-ln\' 'math-derivative-1
34252 (function (lambda (u) (math-div 1 u))))
34255 The two-argument @code{log} function has two derivatives,
34257 (put 'calcFunc-log\' 'math-derivative-2 ; d(log(x,b)) / dx
34258 (function (lambda (x b) ... )))
34259 (put 'calcFunc-log\'2 'math-derivative-2 ; d(log(x,b)) / db
34260 (function (lambda (x b) ... )))
34264 @defun tderiv expr var value symb
34265 Compute the total derivative of @var{expr}. This is the same as
34266 @code{deriv}, except that variables other than @var{var} are not
34267 assumed to be constant with respect to @var{var}.
34270 @defun integ expr var low high
34271 Compute the integral of @var{expr} with respect to @var{var}.
34272 @xref{Calculus}, for further details.
34275 @defmac math-defintegral funcs body
34276 Define a rule for integrating a function or functions of one argument;
34277 this macro is very similar in format to @code{math-defsimplify}.
34278 The main difference is that here @var{body} is the body of a function
34279 with a single argument @code{u} which is bound to the argument to the
34280 function being integrated, not the function call itself. Also, the
34281 variable of integration is available as @code{math-integ-var}. If
34282 evaluation of the integral requires doing further integrals, the body
34283 should call @samp{(math-integral @var{x})} to find the integral of
34284 @var{x} with respect to @code{math-integ-var}; this function returns
34285 @code{nil} if the integral could not be done. Some examples:
34288 (math-defintegral calcFunc-conj
34289 (let ((int (math-integral u)))
34291 (list 'calcFunc-conj int))))
34293 (math-defintegral calcFunc-cos
34294 (and (equal u math-integ-var)
34295 (math-from-radians-2 (list 'calcFunc-sin u))))
34298 In the @code{cos} example, we define only the integral of @samp{cos(x) dx},
34299 relying on the general integration-by-substitution facility to handle
34300 cosines of more complicated arguments. An integration rule should return
34301 @code{nil} if it can't do the integral; if several rules are defined for
34302 the same function, they are tried in order until one returns a non-@code{nil}
34306 @defmac math-defintegral-2 funcs body
34307 Define a rule for integrating a function or functions of two arguments.
34308 This is exactly analogous to @code{math-defintegral}, except that @var{body}
34309 is written as the body of a function with two arguments, @var{u} and
34313 @defun solve-for lhs rhs var full
34314 Attempt to solve the equation @samp{@var{lhs} = @var{rhs}} by isolating
34315 the variable @var{var} on the lefthand side; return the resulting righthand
34316 side, or @code{nil} if the equation cannot be solved. The variable
34317 @var{var} must appear at least once in @var{lhs} or @var{rhs}. Note that
34318 the return value is a formula which does not contain @var{var}; this is
34319 different from the user-level @code{solve} and @code{finv} functions,
34320 which return a rearranged equation or a functional inverse, respectively.
34321 If @var{full} is non-@code{nil}, a full solution including dummy signs
34322 and dummy integers will be produced. User-defined inverses are provided
34323 as properties in a manner similar to derivatives:
34326 (put 'calcFunc-ln 'math-inverse
34327 (function (lambda (x) (list 'calcFunc-exp x))))
34330 This function can call @samp{(math-solve-get-sign @var{x})} to create
34331 a new arbitrary sign variable, returning @var{x} times that sign, and
34332 @samp{(math-solve-get-int @var{x})} to create a new arbitrary integer
34333 variable multiplied by @var{x}. These functions simply return @var{x}
34334 if the caller requested a non-``full'' solution.
34337 @defun solve-eqn expr var full
34338 This version of @code{solve-for} takes an expression which will
34339 typically be an equation or inequality. (If it is not, it will be
34340 interpreted as the equation @samp{@var{expr} = 0}.) It returns an
34341 equation or inequality, or @code{nil} if no solution could be found.
34344 @defun solve-system exprs vars full
34345 This function solves a system of equations. Generally, @var{exprs}
34346 and @var{vars} will be vectors of equal length.
34347 @xref{Solving Systems of Equations}, for other options.
34350 @defun expr-contains expr var
34351 Returns a non-@code{nil} value if @var{var} occurs as a subexpression
34354 This function might seem at first to be identical to
34355 @code{calc-find-sub-formula}. The key difference is that
34356 @code{expr-contains} uses @code{equal} to test for matches, whereas
34357 @code{calc-find-sub-formula} uses @code{eq}. In the formula
34358 @samp{f(a, a)}, the two @samp{a}s will be @code{equal} but not
34359 @code{eq} to each other.
34362 @defun expr-contains-count expr var
34363 Returns the number of occurrences of @var{var} as a subexpression
34364 of @var{expr}, or @code{nil} if there are no occurrences.
34367 @defun expr-depends expr var
34368 Returns true if @var{expr} refers to any variable the occurs in @var{var}.
34369 In other words, it checks if @var{expr} and @var{var} have any variables
34373 @defun expr-contains-vars expr
34374 Return true if @var{expr} contains any variables, or @code{nil} if @var{expr}
34375 contains only constants and functions with constant arguments.
34378 @defun expr-subst expr old new
34379 Returns a copy of @var{expr}, with all occurrences of @var{old} replaced
34380 by @var{new}. This treats @code{lambda} forms specially with respect
34381 to the dummy argument variables, so that the effect is always to return
34382 @var{expr} evaluated at @var{old} = @var{new}.
34385 @defun multi-subst expr old new
34386 This is like @code{expr-subst}, except that @var{old} and @var{new}
34387 are lists of expressions to be substituted simultaneously. If one
34388 list is shorter than the other, trailing elements of the longer list
34392 @defun expr-weight expr
34393 Returns the ``weight'' of @var{expr}, basically a count of the total
34394 number of objects and function calls that appear in @var{expr}. For
34395 ``primitive'' objects, this will be one.
34398 @defun expr-height expr
34399 Returns the ``height'' of @var{expr}, which is the deepest level to
34400 which function calls are nested. (Note that @samp{@var{a} + @var{b}}
34401 counts as a function call.) For primitive objects, this returns zero.
34404 @defun polynomial-p expr var
34405 Check if @var{expr} is a polynomial in variable (or sub-expression)
34406 @var{var}. If so, return the degree of the polynomial, that is, the
34407 highest power of @var{var} that appears in @var{expr}. For example,
34408 for @samp{(x^2 + 3)^3 + 4} this would return 6. This function returns
34409 @code{nil} unless @var{expr}, when expanded out by @kbd{a x}
34410 (@code{calc-expand}), would consist of a sum of terms in which @var{var}
34411 appears only raised to nonnegative integer powers. Note that if
34412 @var{var} does not occur in @var{expr}, then @var{expr} is considered
34413 a polynomial of degree 0.
34416 @defun is-polynomial expr var degree loose
34417 Check if @var{expr} is a polynomial in variable or sub-expression
34418 @var{var}, and, if so, return a list representation of the polynomial
34419 where the elements of the list are coefficients of successive powers of
34420 @var{var}: @samp{@var{a} + @var{b} x + @var{c} x^3} would produce the
34421 list @samp{(@var{a} @var{b} 0 @var{c})}, and @samp{(x + 1)^2} would
34422 produce the list @samp{(1 2 1)}. The highest element of the list will
34423 be non-zero, with the special exception that if @var{expr} is the
34424 constant zero, the returned value will be @samp{(0)}. Return @code{nil}
34425 if @var{expr} is not a polynomial in @var{var}. If @var{degree} is
34426 specified, this will not consider polynomials of degree higher than that
34427 value. This is a good precaution because otherwise an input of
34428 @samp{(x+1)^1000} will cause a huge coefficient list to be built. If
34429 @var{loose} is non-@code{nil}, then a looser definition of a polynomial
34430 is used in which coefficients are no longer required not to depend on
34431 @var{var}, but are only required not to take the form of polynomials
34432 themselves. For example, @samp{sin(x) x^2 + cos(x)} is a loose
34433 polynomial with coefficients @samp{((calcFunc-cos x) 0 (calcFunc-sin
34434 x))}. The result will never be @code{nil} in loose mode, since any
34435 expression can be interpreted as a ``constant'' loose polynomial.
34438 @defun polynomial-base expr pred
34439 Check if @var{expr} is a polynomial in any variable that occurs in it;
34440 if so, return that variable. (If @var{expr} is a multivariate polynomial,
34441 this chooses one variable arbitrarily.) If @var{pred} is specified, it should
34442 be a Lisp function which is called as @samp{(@var{pred} @var{subexpr})},
34443 and which should return true if @code{mpb-top-expr} (a global name for
34444 the original @var{expr}) is a suitable polynomial in @var{subexpr}.
34445 The default predicate uses @samp{(polynomial-p mpb-top-expr @var{subexpr})};
34446 you can use @var{pred} to specify additional conditions. Or, you could
34447 have @var{pred} build up a list of every suitable @var{subexpr} that
34451 @defun poly-simplify poly
34452 Simplify polynomial coefficient list @var{poly} by (destructively)
34453 clipping off trailing zeros.
34456 @defun poly-mix a ac b bc
34457 Mix two polynomial lists @var{a} and @var{b} (in the form returned by
34458 @code{is-polynomial}) in a linear combination with coefficient expressions
34459 @var{ac} and @var{bc}. The result is a (not necessarily simplified)
34460 polynomial list representing @samp{@var{ac} @var{a} + @var{bc} @var{b}}.
34463 @defun poly-mul a b
34464 Multiply two polynomial coefficient lists @var{a} and @var{b}. The
34465 result will be in simplified form if the inputs were simplified.
34468 @defun build-polynomial-expr poly var
34469 Construct a Calc formula which represents the polynomial coefficient
34470 list @var{poly} applied to variable @var{var}. The @kbd{a c}
34471 (@code{calc-collect}) command uses @code{is-polynomial} to turn an
34472 expression into a coefficient list, then @code{build-polynomial-expr}
34473 to turn the list back into an expression in regular form.
34476 @defun check-unit-name var
34477 Check if @var{var} is a variable which can be interpreted as a unit
34478 name. If so, return the units table entry for that unit. This
34479 will be a list whose first element is the unit name (not counting
34480 prefix characters) as a symbol and whose second element is the
34481 Calc expression which defines the unit. (Refer to the Calc sources
34482 for details on the remaining elements of this list.) If @var{var}
34483 is not a variable or is not a unit name, return @code{nil}.
34486 @defun units-in-expr-p expr sub-exprs
34487 Return true if @var{expr} contains any variables which can be
34488 interpreted as units. If @var{sub-exprs} is @code{t}, the entire
34489 expression is searched. If @var{sub-exprs} is @code{nil}, this
34490 checks whether @var{expr} is directly a units expression.
34493 @defun single-units-in-expr-p expr
34494 Check whether @var{expr} contains exactly one units variable. If so,
34495 return the units table entry for the variable. If @var{expr} does
34496 not contain any units, return @code{nil}. If @var{expr} contains
34497 two or more units, return the symbol @code{wrong}.
34500 @defun to-standard-units expr which
34501 Convert units expression @var{expr} to base units. If @var{which}
34502 is @code{nil}, use Calc's native base units. Otherwise, @var{which}
34503 can specify a units system, which is a list of two-element lists,
34504 where the first element is a Calc base symbol name and the second
34505 is an expression to substitute for it.
34508 @defun remove-units expr
34509 Return a copy of @var{expr} with all units variables replaced by ones.
34510 This expression is generally normalized before use.
34513 @defun extract-units expr
34514 Return a copy of @var{expr} with everything but units variables replaced
34518 @node Formatting Lisp Functions, Hooks, Symbolic Lisp Functions, Internals
34519 @subsubsection I/O and Formatting Functions
34522 The functions described here are responsible for parsing and formatting
34523 Calc numbers and formulas.
34525 @defun calc-eval str sep arg1 arg2 @dots{}
34526 This is the simplest interface to the Calculator from another Lisp program.
34527 @xref{Calling Calc from Your Programs}.
34530 @defun read-number str
34531 If string @var{str} contains a valid Calc number, either integer,
34532 fraction, float, or HMS form, this function parses and returns that
34533 number. Otherwise, it returns @code{nil}.
34536 @defun read-expr str
34537 Read an algebraic expression from string @var{str}. If @var{str} does
34538 not have the form of a valid expression, return a list of the form
34539 @samp{(error @var{pos} @var{msg})} where @var{pos} is an integer index
34540 into @var{str} of the general location of the error, and @var{msg} is
34541 a string describing the problem.
34544 @defun read-exprs str
34545 Read a list of expressions separated by commas, and return it as a
34546 Lisp list. If an error occurs in any expressions, an error list as
34547 shown above is returned instead.
34550 @defun calc-do-alg-entry initial prompt no-norm
34551 Read an algebraic formula or formulas using the minibuffer. All
34552 conventions of regular algebraic entry are observed. The return value
34553 is a list of Calc formulas; there will be more than one if the user
34554 entered a list of values separated by commas. The result is @code{nil}
34555 if the user presses Return with a blank line. If @var{initial} is
34556 given, it is a string which the minibuffer will initially contain.
34557 If @var{prompt} is given, it is the prompt string to use; the default
34558 is ``Algebraic:''. If @var{no-norm} is @code{t}, the formulas will
34559 be returned exactly as parsed; otherwise, they will be passed through
34560 @code{calc-normalize} first.
34562 To support the use of @kbd{$} characters in the algebraic entry, use
34563 @code{let} to bind @code{calc-dollar-values} to a list of the values
34564 to be substituted for @kbd{$}, @kbd{$$}, and so on, and bind
34565 @code{calc-dollar-used} to 0. Upon return, @code{calc-dollar-used}
34566 will have been changed to the highest number of consecutive @kbd{$}s
34567 that actually appeared in the input.
34570 @defun format-number a
34571 Convert the real or complex number or HMS form @var{a} to string form.
34574 @defun format-flat-expr a prec
34575 Convert the arbitrary Calc number or formula @var{a} to string form,
34576 in the style used by the trail buffer and the @code{calc-edit} command.
34577 This is a simple format designed
34578 mostly to guarantee the string is of a form that can be re-parsed by
34579 @code{read-expr}. Most formatting modes, such as digit grouping,
34580 complex number format, and point character, are ignored to ensure the
34581 result will be re-readable. The @var{prec} parameter is normally 0; if
34582 you pass a large integer like 1000 instead, the expression will be
34583 surrounded by parentheses unless it is a plain number or variable name.
34586 @defun format-nice-expr a width
34587 This is like @code{format-flat-expr} (with @var{prec} equal to 0),
34588 except that newlines will be inserted to keep lines down to the
34589 specified @var{width}, and vectors that look like matrices or rewrite
34590 rules are written in a pseudo-matrix format. The @code{calc-edit}
34591 command uses this when only one stack entry is being edited.
34594 @defun format-value a width
34595 Convert the Calc number or formula @var{a} to string form, using the
34596 format seen in the stack buffer. Beware the string returned may
34597 not be re-readable by @code{read-expr}, for example, because of digit
34598 grouping. Multi-line objects like matrices produce strings that
34599 contain newline characters to separate the lines. The @var{w}
34600 parameter, if given, is the target window size for which to format
34601 the expressions. If @var{w} is omitted, the width of the Calculator
34605 @defun compose-expr a prec
34606 Format the Calc number or formula @var{a} according to the current
34607 language mode, returning a ``composition.'' To learn about the
34608 structure of compositions, see the comments in the Calc source code.
34609 You can specify the format of a given type of function call by putting
34610 a @code{math-compose-@var{lang}} property on the function's symbol,
34611 whose value is a Lisp function that takes @var{a} and @var{prec} as
34612 arguments and returns a composition. Here @var{lang} is a language
34613 mode name, one of @code{normal}, @code{big}, @code{c}, @code{pascal},
34614 @code{fortran}, @code{tex}, @code{eqn}, @code{math}, or @code{maple}.
34615 In Big mode, Calc actually tries @code{math-compose-big} first, then
34616 tries @code{math-compose-normal}. If this property does not exist,
34617 or if the function returns @code{nil}, the function is written in the
34618 normal function-call notation for that language.
34621 @defun composition-to-string c w
34622 Convert a composition structure returned by @code{compose-expr} into
34623 a string. Multi-line compositions convert to strings containing
34624 newline characters. The target window size is given by @var{w}.
34625 The @code{format-value} function basically calls @code{compose-expr}
34626 followed by @code{composition-to-string}.
34629 @defun comp-width c
34630 Compute the width in characters of composition @var{c}.
34633 @defun comp-height c
34634 Compute the height in lines of composition @var{c}.
34637 @defun comp-ascent c
34638 Compute the portion of the height of composition @var{c} which is on or
34639 above the baseline. For a one-line composition, this will be one.
34642 @defun comp-descent c
34643 Compute the portion of the height of composition @var{c} which is below
34644 the baseline. For a one-line composition, this will be zero.
34647 @defun comp-first-char c
34648 If composition @var{c} is a ``flat'' composition, return the first
34649 (leftmost) character of the composition as an integer. Otherwise,
34653 @defun comp-last-char c
34654 If composition @var{c} is a ``flat'' composition, return the last
34655 (rightmost) character, otherwise return @code{nil}.
34658 @comment @node Lisp Variables, Hooks, Formatting Lisp Functions, Internals
34659 @comment @subsubsection Lisp Variables
34662 @comment (This section is currently unfinished.)
34664 @node Hooks, , Formatting Lisp Functions, Internals
34665 @subsubsection Hooks
34668 Hooks are variables which contain Lisp functions (or lists of functions)
34669 which are called at various times. Calc defines a number of hooks
34670 that help you to customize it in various ways. Calc uses the Lisp
34671 function @code{run-hooks} to invoke the hooks shown below. Several
34672 other customization-related variables are also described here.
34674 @defvar calc-load-hook
34675 This hook is called at the end of @file{calc.el}, after the file has
34676 been loaded, before any functions in it have been called, but after
34677 @code{calc-mode-map} and similar variables have been set up.
34680 @defvar calc-ext-load-hook
34681 This hook is called at the end of @file{calc-ext.el}.
34684 @defvar calc-start-hook
34685 This hook is called as the last step in a @kbd{M-x calc} command.
34686 At this point, the Calc buffer has been created and initialized if
34687 necessary, the Calc window and trail window have been created,
34688 and the ``Welcome to Calc'' message has been displayed.
34691 @defvar calc-mode-hook
34692 This hook is called when the Calc buffer is being created. Usually
34693 this will only happen once per Emacs session. The hook is called
34694 after Emacs has switched to the new buffer, the mode-settings file
34695 has been read if necessary, and all other buffer-local variables
34696 have been set up. After this hook returns, Calc will perform a
34697 @code{calc-refresh} operation, set up the mode line display, then
34698 evaluate any deferred @code{calc-define} properties that have not
34699 been evaluated yet.
34702 @defvar calc-trail-mode-hook
34703 This hook is called when the Calc Trail buffer is being created.
34704 It is called as the very last step of setting up the Trail buffer.
34705 Like @code{calc-mode-hook}, this will normally happen only once
34709 @defvar calc-end-hook
34710 This hook is called by @code{calc-quit}, generally because the user
34711 presses @kbd{q} or @kbd{M-# c} while in Calc. The Calc buffer will
34712 be the current buffer. The hook is called as the very first
34713 step, before the Calc window is destroyed.
34716 @defvar calc-window-hook
34717 If this hook is non-@code{nil}, it is called to create the Calc window.
34718 Upon return, this new Calc window should be the current window.
34719 (The Calc buffer will already be the current buffer when the
34720 hook is called.) If the hook is not defined, Calc will
34721 generally use @code{split-window}, @code{set-window-buffer},
34722 and @code{select-window} to create the Calc window.
34725 @defvar calc-trail-window-hook
34726 If this hook is non-@code{nil}, it is called to create the Calc Trail
34727 window. The variable @code{calc-trail-buffer} will contain the buffer
34728 which the window should use. Unlike @code{calc-window-hook}, this hook
34729 must @emph{not} switch into the new window.
34732 @defvar calc-embedded-mode-hook
34733 This hook is called the first time that Embedded mode is entered.
34736 @defvar calc-embedded-new-buffer-hook
34737 This hook is called each time that Embedded mode is entered in a
34741 @defvar calc-embedded-new-formula-hook
34742 This hook is called each time that Embedded mode is enabled for a
34746 @defvar calc-edit-mode-hook
34747 This hook is called by @code{calc-edit} (and the other ``edit''
34748 commands) when the temporary editing buffer is being created.
34749 The buffer will have been selected and set up to be in
34750 @code{calc-edit-mode}, but will not yet have been filled with
34751 text. (In fact it may still have leftover text from a previous
34752 @code{calc-edit} command.)
34755 @defvar calc-mode-save-hook
34756 This hook is called by the @code{calc-save-modes} command,
34757 after Calc's own mode features have been inserted into the
34758 Calc init file and just before the ``End of mode settings''
34759 message is inserted.
34762 @defvar calc-reset-hook
34763 This hook is called after @kbd{M-# 0} (@code{calc-reset}) has
34764 reset all modes. The Calc buffer will be the current buffer.
34767 @defvar calc-other-modes
34768 This variable contains a list of strings. The strings are
34769 concatenated at the end of the modes portion of the Calc
34770 mode line (after standard modes such as ``Deg'', ``Inv'' and
34771 ``Hyp''). Each string should be a short, single word followed
34772 by a space. The variable is @code{nil} by default.
34775 @defvar calc-mode-map
34776 This is the keymap that is used by Calc mode. The best time
34777 to adjust it is probably in a @code{calc-mode-hook}. If the
34778 Calc extensions package (@file{calc-ext.el}) has not yet been
34779 loaded, many of these keys will be bound to @code{calc-missing-key},
34780 which is a command that loads the extensions package and
34781 ``retypes'' the key. If your @code{calc-mode-hook} rebinds
34782 one of these keys, it will probably be overridden when the
34783 extensions are loaded.
34786 @defvar calc-digit-map
34787 This is the keymap that is used during numeric entry. Numeric
34788 entry uses the minibuffer, but this map binds every non-numeric
34789 key to @code{calcDigit-nondigit} which generally calls
34790 @code{exit-minibuffer} and ``retypes'' the key.
34793 @defvar calc-alg-ent-map
34794 This is the keymap that is used during algebraic entry. This is
34795 mostly a copy of @code{minibuffer-local-map}.
34798 @defvar calc-store-var-map
34799 This is the keymap that is used during entry of variable names for
34800 commands like @code{calc-store} and @code{calc-recall}. This is
34801 mostly a copy of @code{minibuffer-local-completion-map}.
34804 @defvar calc-edit-mode-map
34805 This is the (sparse) keymap used by @code{calc-edit} and other
34806 temporary editing commands. It binds @key{RET}, @key{LFD},
34807 and @kbd{C-c C-c} to @code{calc-edit-finish}.
34810 @defvar calc-mode-var-list
34811 This is a list of variables which are saved by @code{calc-save-modes}.
34812 Each entry is a list of two items, the variable (as a Lisp symbol)
34813 and its default value. When modes are being saved, each variable
34814 is compared with its default value (using @code{equal}) and any
34815 non-default variables are written out.
34818 @defvar calc-local-var-list
34819 This is a list of variables which should be buffer-local to the
34820 Calc buffer. Each entry is a variable name (as a Lisp symbol).
34821 These variables also have their default values manipulated by
34822 the @code{calc} and @code{calc-quit} commands; @pxref{Multiple Calculators}.
34823 Since @code{calc-mode-hook} is called after this list has been
34824 used the first time, your hook should add a variable to the
34825 list and also call @code{make-local-variable} itself.
34828 @node Customizable Variables, Reporting Bugs, Programming, Top
34829 @appendix Customizable Variables
34831 GNU Calc is controlled by many variables, most of which can be reset
34832 from within Calc. Some variables are less involved with actual
34833 calculation, and can be set outside of Calc using Emacs's
34834 customization facilities. These variables are listed below.
34835 Typing @kbd{M-x customize-variable RET @var{variable-name} RET}
34836 will bring up a buffer in which the variable's value can be redefined.
34837 Typing @kbd{M-x customize-group RET calc RET} will bring up a buffer which
34838 contains all of Calc's customizable variables. (These variables can
34839 also be reset by putting the appropriate lines in your .emacs file;
34840 @xref{Init File, ,Init File, emacs, The GNU Emacs Manual}.)
34842 Some of the customizable variables are regular expressions. A regular
34843 expression is basically a pattern that Calc can search for.
34844 See @ref{Regexp Search,, Regular Expression Search, emacs, The GNU Emacs Manual}
34845 to see how regular expressions work.
34847 @defvar calc-settings-file
34848 The variable @code{calc-settings-file} holds the file name in
34849 which commands like @kbd{m m} and @kbd{Z P} store ``permanent''
34851 If @code{calc-settings-file} is not your user init file (typically
34852 @file{~/.emacs}) and if the variable @code{calc-loaded-settings-file} is
34853 @code{nil}, then Calc will automatically load your settings file (if it
34854 exists) the first time Calc is invoked.
34856 The default value for this variable is @code{"~/.calc.el"}.
34859 @defvar calc-gnuplot-name
34860 See @ref{Graphics}.@*
34861 The variable @code{calc-gnuplot-name} should be the name of the
34862 GNUPLOT program (a string). If you have GNUPLOT installed on your
34863 system but Calc is unable to find it, you may need to set this
34864 variable. (@pxref{Customizable Variables})
34865 You may also need to set some Lisp variables to show Calc how to run
34866 GNUPLOT on your system, see @ref{Devices, ,Graphical Devices} . The default value
34867 of @code{calc-gnuplot-name} is @code{"gnuplot"}.
34870 @defvar calc-gnuplot-plot-command
34871 @defvarx calc-gnuplot-print-command
34872 See @ref{Devices, ,Graphical Devices}.@*
34873 The variables @code{calc-gnuplot-plot-command} and
34874 @code{calc-gnuplot-print-command} represent system commands to
34875 display and print the output of GNUPLOT, respectively. These may be
34876 @code{nil} if no command is necessary, or strings which can include
34877 @samp{%s} to signify the name of the file to be displayed or printed.
34878 Or, these variables may contain Lisp expressions which are evaluated
34879 to display or print the output.
34881 The default value of @code{calc-gnuplot-plot-command} is @code{nil},
34882 and the default value of @code{calc-gnuplot-print-command} is
34886 @defvar calc-language-alist
34887 See @ref{Basic Embedded Mode}.@*
34888 The variable @code{calc-language-alist} controls the languages that
34889 Calc will associate with major modes. When Calc embedded mode is
34890 enabled, it will try to use the current major mode to
34891 determine what language should be used. (This can be overridden using
34892 Calc's mode changing commands, @xref{Mode Settings in Embedded Mode}.)
34893 The variable @code{calc-language-alist} consists of a list of pairs of
34894 the form @code{(@var{MAJOR-MODE} . @var{LANGUAGE})}; for example,
34895 @code{(latex-mode . latex)} is one such pair. If Calc embedded is
34896 activated in a buffer whose major mode is @var{MAJOR-MODE}, it will set itself
34897 to use the language @var{LANGUAGE}.
34899 The default value of @code{calc-language-alist} is
34901 ((latex-mode . latex)
34903 (plain-tex-mode . tex)
34904 (context-mode . tex)
34906 (pascal-mode . pascal)
34909 (fortran-mode . fortran)
34910 (f90-mode . fortran))
34914 @defvar calc-embedded-announce-formula
34915 @defvarx calc-embedded-announce-formula-alist
34916 See @ref{Customizing Embedded Mode}.@*
34917 The variable @code{calc-embedded-announce-formula} helps determine
34918 what formulas @kbd{M-# a} will activate in a buffer. It is a
34919 regular expression, and when activating embedded formulas with
34920 @kbd{M-# a}, it will tell Calc that what follows is a formula to be
34921 activated. (Calc also uses other patterns to find formulas, such as
34922 @samp{=>} and @samp{:=}.)
34924 The default pattern is @code{"%Embed\n\\(% .*\n\\)*"}, which checks
34925 for @samp{%Embed} followed by any number of lines beginning with
34926 @samp{%} and a space.
34928 The variable @code{calc-embedded-announce-formula-alist} is used to
34929 set @code{calc-embedded-announce-formula} to different regular
34930 expressions depending on the major mode of the editing buffer.
34931 It consists of a list of pairs of the form @code{(@var{MAJOR-MODE} .
34932 @var{REGEXP})}, and its default value is
34934 ((c++-mode . "//Embed\n\\(// .*\n\\)*")
34935 (c-mode . "/\\*Embed\\*/\n\\(/\\* .*\\*/\n\\)*")
34936 (f90-mode . "!Embed\n\\(! .*\n\\)*")
34937 (fortran-mode . "C Embed\n\\(C .*\n\\)*")
34938 (html-helper-mode . "<!-- Embed -->\n\\(<!-- .* -->\n\\)*")
34939 (html-mode . "<!-- Embed -->\n\\(<!-- .* -->\n\\)*")
34940 (nroff-mode . "\\\\\"Embed\n\\(\\\\\" .*\n\\)*")
34941 (pascal-mode . "@{Embed@}\n\\(@{.*@}\n\\)*")
34942 (sgml-mode . "<!-- Embed -->\n\\(<!-- .* -->\n\\)*")
34943 (xml-mode . "<!-- Embed -->\n\\(<!-- .* -->\n\\)*")
34944 (texinfo-mode . "@@c Embed\n\\(@@c .*\n\\)*"))
34946 Any major modes added to @code{calc-embedded-announce-formula-alist}
34947 should also be added to @code{calc-embedded-open-close-plain-alist}
34948 and @code{calc-embedded-open-close-mode-alist}.
34951 @defvar calc-embedded-open-formula
34952 @defvarx calc-embedded-close-formula
34953 @defvarx calc-embedded-open-close-formula-alist
34954 See @ref{Customizing Embedded Mode}.@*
34955 The variables @code{calc-embedded-open-formula} and
34956 @code{calc-embedded-open-formula} control the region that Calc will
34957 activate as a formula when Embedded mode is entered with @kbd{M-# e}.
34958 They are regular expressions;
34959 Calc normally scans backward and forward in the buffer for the
34960 nearest text matching these regular expressions to be the ``formula
34963 The simplest delimiters are blank lines. Other delimiters that
34964 Embedded mode understands by default are:
34967 The @TeX{} and La@TeX{} math delimiters @samp{$ $}, @samp{$$ $$},
34968 @samp{\[ \]}, and @samp{\( \)};
34970 Lines beginning with @samp{\begin} and @samp{\end} (except matrix delimiters);
34972 Lines beginning with @samp{@@} (Texinfo delimiters).
34974 Lines beginning with @samp{.EQ} and @samp{.EN} (@dfn{eqn} delimiters);
34976 Lines containing a single @samp{%} or @samp{.\"} symbol and nothing else.
34979 The variable @code{calc-embedded-open-close-formula-alist} is used to
34980 set @code{calc-embedded-open-formula} and
34981 @code{calc-embedded-close-formula} to different regular
34982 expressions depending on the major mode of the editing buffer.
34983 It consists of a list of lists of the form
34984 @code{(@var{MAJOR-MODE} @var{OPEN-FORMULA-REGEXP}
34985 @var{CLOSE-FORMULA-REGEXP})}, and its default value is
34989 @defvar calc-embedded-open-word
34990 @defvarx calc-embedded-close-word
34991 @defvarx calc-embedded-open-close-word-alist
34992 See @ref{Customizing Embedded Mode}.@*
34993 The variables @code{calc-embedded-open-word} and
34994 @code{calc-embedded-close-word} control the region that Calc will
34995 activate when Embedded mode is entered with @kbd{M-# w}. They are
34996 regular expressions.
34998 The default values of @code{calc-embedded-open-word} and
34999 @code{calc-embedded-close-word} are @code{"^\\|[^-+0-9.eE]"} and
35000 @code{"$\\|[^-+0-9.eE]"} respectively.
35002 The variable @code{calc-embedded-open-close-word-alist} is used to
35003 set @code{calc-embedded-open-word} and
35004 @code{calc-embedded-close-word} to different regular
35005 expressions depending on the major mode of the editing buffer.
35006 It consists of a list of lists of the form
35007 @code{(@var{MAJOR-MODE} @var{OPEN-WORD-REGEXP}
35008 @var{CLOSE-WORD-REGEXP})}, and its default value is
35012 @defvar calc-embedded-open-plain
35013 @defvarx calc-embedded-close-plain
35014 @defvarx calc-embedded-open-close-plain-alist
35015 See @ref{Customizing Embedded Mode}.@*
35016 The variables @code{calc-embedded-open-plain} and
35017 @code{calc-embedded-open-plain} are used to delimit ``plain''
35018 formulas. Note that these are actual strings, not regular
35019 expressions, because Calc must be able to write these string into a
35020 buffer as well as to recognize them.
35022 The default string for @code{calc-embedded-open-plain} is
35023 @code{"%%% "}, note the trailing space. The default string for
35024 @code{calc-embedded-close-plain} is @code{" %%%\n"}, without
35025 the trailing newline here, the first line of a Big mode formula
35026 that followed might be shifted over with respect to the other lines.
35028 The variable @code{calc-embedded-open-close-plain-alist} is used to
35029 set @code{calc-embedded-open-plain} and
35030 @code{calc-embedded-close-plain} to different strings
35031 depending on the major mode of the editing buffer.
35032 It consists of a list of lists of the form
35033 @code{(@var{MAJOR-MODE} @var{OPEN-PLAIN-STRING}
35034 @var{CLOSE-PLAIN-STRING})}, and its default value is
35036 ((c++-mode "// %% " " %%\n")
35037 (c-mode "/* %% " " %% */\n")
35038 (f90-mode "! %% " " %%\n")
35039 (fortran-mode "C %% " " %%\n")
35040 (html-helper-mode "<!-- %% " " %% -->\n")
35041 (html-mode "<!-- %% " " %% -->\n")
35042 (nroff-mode "\\\" %% " " %%\n")
35043 (pascal-mode "@{%% " " %%@}\n")
35044 (sgml-mode "<!-- %% " " %% -->\n")
35045 (xml-mode "<!-- %% " " %% -->\n")
35046 (texinfo-mode "@@c %% " " %%\n"))
35048 Any major modes added to @code{calc-embedded-open-close-plain-alist}
35049 should also be added to @code{calc-embedded-announce-formula-alist}
35050 and @code{calc-embedded-open-close-mode-alist}.
35053 @defvar calc-embedded-open-new-formula
35054 @defvarx calc-embedded-close-new-formula
35055 @defvarx calc-embedded-open-close-new-formula-alist
35056 See @ref{Customizing Embedded Mode}.@*
35057 The variables @code{calc-embedded-open-new-formula} and
35058 @code{calc-embedded-close-new-formula} are strings which are
35059 inserted before and after a new formula when you type @kbd{M-# f}.
35061 The default value of @code{calc-embedded-open-new-formula} is
35062 @code{"\n\n"}. If this string begins with a newline character and the
35063 @kbd{M-# f} is typed at the beginning of a line, @kbd{M-# f} will skip
35064 this first newline to avoid introducing unnecessary blank lines in the
35065 file. The default value of @code{calc-embedded-close-new-formula} is
35066 also @code{"\n\n"}. The final newline is omitted by @w{@kbd{M-# f}}
35067 if typed at the end of a line. (It follows that if @kbd{M-# f} is
35068 typed on a blank line, both a leading opening newline and a trailing
35069 closing newline are omitted.)
35071 The variable @code{calc-embedded-open-close-new-formula-alist} is used to
35072 set @code{calc-embedded-open-new-formula} and
35073 @code{calc-embedded-close-new-formula} to different strings
35074 depending on the major mode of the editing buffer.
35075 It consists of a list of lists of the form
35076 @code{(@var{MAJOR-MODE} @var{OPEN-NEW-FORMULA-STRING}
35077 @var{CLOSE-NEW-FORMULA-STRING})}, and its default value is
35081 @defvar calc-embedded-open-mode
35082 @defvarx calc-embedded-close-mode
35083 @defvarx calc-embedded-open-close-mode-alist
35084 See @ref{Customizing Embedded Mode}.@*
35085 The variables @code{calc-embedded-open-mode} and
35086 @code{calc-embedded-close-mode} are strings which Calc will place before
35087 and after any mode annotations that it inserts. Calc never scans for
35088 these strings; Calc always looks for the annotation itself, so it is not
35089 necessary to add them to user-written annotations.
35091 The default value of @code{calc-embedded-open-mode} is @code{"% "}
35092 and the default value of @code{calc-embedded-close-mode} is
35094 If you change the value of @code{calc-embedded-close-mode}, it is a good
35095 idea still to end with a newline so that mode annotations will appear on
35096 lines by themselves.
35098 The variable @code{calc-embedded-open-close-mode-alist} is used to
35099 set @code{calc-embedded-open-mode} and
35100 @code{calc-embedded-close-mode} to different strings
35101 expressions depending on the major mode of the editing buffer.
35102 It consists of a list of lists of the form
35103 @code{(@var{MAJOR-MODE} @var{OPEN-MODE-STRING}
35104 @var{CLOSE-MODE-STRING})}, and its default value is
35106 ((c++-mode "// " "\n")
35107 (c-mode "/* " " */\n")
35108 (f90-mode "! " "\n")
35109 (fortran-mode "C " "\n")
35110 (html-helper-mode "<!-- " " -->\n")
35111 (html-mode "<!-- " " -->\n")
35112 (nroff-mode "\\\" " "\n")
35113 (pascal-mode "@{ " " @}\n")
35114 (sgml-mode "<!-- " " -->\n")
35115 (xml-mode "<!-- " " -->\n")
35116 (texinfo-mode "@@c " "\n"))
35118 Any major modes added to @code{calc-embedded-open-close-mode-alist}
35119 should also be added to @code{calc-embedded-announce-formula-alist}
35120 and @code{calc-embedded-open-close-plain-alist}.
35123 @node Reporting Bugs, Summary, Customizable Variables, Top
35124 @appendix Reporting Bugs
35127 If you find a bug in Calc, send e-mail to Jay Belanger,
35130 belanger@@truman.edu
35134 There is an automatic command @kbd{M-x report-calc-bug} which helps
35135 you to report bugs. This command prompts you for a brief subject
35136 line, then leaves you in a mail editing buffer. Type @kbd{C-c C-c} to
35137 send your mail. Make sure your subject line indicates that you are
35138 reporting a Calc bug; this command sends mail to the maintainer's
35141 If you have suggestions for additional features for Calc, please send
35142 them. Some have dared to suggest that Calc is already top-heavy with
35143 features; this obviously cannot be the case, so if you have ideas, send
35146 At the front of the source file, @file{calc.el}, is a list of ideas for
35147 future work. If any enthusiastic souls wish to take it upon themselves
35148 to work on these, please send a message (using @kbd{M-x report-calc-bug})
35149 so any efforts can be coordinated.
35151 The latest version of Calc is available from Savannah, in the Emacs
35152 CVS tree. See @uref{http://savannah.gnu.org/projects/emacs}.
35155 @node Summary, Key Index, Reporting Bugs, Top
35156 @appendix Calc Summary
35159 This section includes a complete list of Calc 2.1 keystroke commands.
35160 Each line lists the stack entries used by the command (top-of-stack
35161 last), the keystrokes themselves, the prompts asked by the command,
35162 and the result of the command (also with top-of-stack last).
35163 The result is expressed using the equivalent algebraic function.
35164 Commands which put no results on the stack show the full @kbd{M-x}
35165 command name in that position. Numbers preceding the result or
35166 command name refer to notes at the end.
35168 Algebraic functions and @kbd{M-x} commands that don't have corresponding
35169 keystrokes are not listed in this summary.
35170 @xref{Command Index}. @xref{Function Index}.
35175 \vskip-2\baselineskip \null
35176 \gdef\sumrow#1{\sumrowx#1\relax}%
35177 \gdef\sumrowx#1\:#2\:#3\:#4\:#5\:#6\relax{%
35180 \hbox to5em{\sl\hss#1}%
35181 \hbox to5em{\tt#2\hss}%
35182 \hbox to4em{\sl#3\hss}%
35183 \hbox to5em{\rm\hss#4}%
35188 \gdef\sumlpar{{\rm(}}%
35189 \gdef\sumrpar{{\rm)}}%
35190 \gdef\sumcomma{{\rm,\thinspace}}%
35191 \gdef\sumexcl{{\rm!}}%
35192 \gdef\sumbreak{\vskip-2.5\baselineskip\goodbreak}%
35193 \gdef\minus#1{{\tt-}}%
35197 @catcode`@(=@active @let(=@sumlpar
35198 @catcode`@)=@active @let)=@sumrpar
35199 @catcode`@,=@active @let,=@sumcomma
35200 @catcode`@!=@active @let!=@sumexcl
35204 @advance@baselineskip-2.5pt
35207 @r{ @: M-# a @: @: 33 @:calc-embedded-activate@:}
35208 @r{ @: M-# b @: @: @:calc-big-or-small@:}
35209 @r{ @: M-# c @: @: @:calc@:}
35210 @r{ @: M-# d @: @: @:calc-embedded-duplicate@:}
35211 @r{ @: M-# e @: @: 34 @:calc-embedded@:}
35212 @r{ @: M-# f @:formula @: @:calc-embedded-new-formula@:}
35213 @r{ @: M-# g @: @: 35 @:calc-grab-region@:}
35214 @r{ @: M-# i @: @: @:calc-info@:}
35215 @r{ @: M-# j @: @: @:calc-embedded-select@:}
35216 @r{ @: M-# k @: @: @:calc-keypad@:}
35217 @r{ @: M-# l @: @: @:calc-load-everything@:}
35218 @r{ @: M-# m @: @: @:read-kbd-macro@:}
35219 @r{ @: M-# n @: @: 4 @:calc-embedded-next@:}
35220 @r{ @: M-# o @: @: @:calc-other-window@:}
35221 @r{ @: M-# p @: @: 4 @:calc-embedded-previous@:}
35222 @r{ @: M-# q @:formula @: @:quick-calc@:}
35223 @r{ @: M-# r @: @: 36 @:calc-grab-rectangle@:}
35224 @r{ @: M-# s @: @: @:calc-info-summary@:}
35225 @r{ @: M-# t @: @: @:calc-tutorial@:}
35226 @r{ @: M-# u @: @: @:calc-embedded-update-formula@:}
35227 @r{ @: M-# w @: @: @:calc-embedded-word@:}
35228 @r{ @: M-# x @: @: @:calc-quit@:}
35229 @r{ @: M-# y @: @:1,28,49 @:calc-copy-to-buffer@:}
35230 @r{ @: M-# z @: @: @:calc-user-invocation@:}
35231 @r{ @: M-# = @: @: @:calc-embedded-update-formula@:}
35232 @r{ @: M-# : @: @: 36 @:calc-grab-sum-down@:}
35233 @r{ @: M-# _ @: @: 36 @:calc-grab-sum-across@:}
35234 @r{ @: M-# ` @:editing @: 30 @:calc-embedded-edit@:}
35235 @r{ @: M-# 0 @:(zero) @: @:calc-reset@:}
35238 @r{ @: 0-9 @:number @: @:@:number}
35239 @r{ @: . @:number @: @:@:0.number}
35240 @r{ @: _ @:number @: @:-@:number}
35241 @r{ @: e @:number @: @:@:1e number}
35242 @r{ @: # @:number @: @:@:current-radix@tfn{#}number}
35243 @r{ @: P @:(in number) @: @:+/-@:}
35244 @r{ @: M @:(in number) @: @:mod@:}
35245 @r{ @: @@ ' " @: (in number)@: @:@:HMS form}
35246 @r{ @: h m s @: (in number)@: @:@:HMS form}
35249 @r{ @: ' @:formula @: 37,46 @:@:formula}
35250 @r{ @: $ @:formula @: 37,46 @:$@:formula}
35251 @r{ @: " @:string @: 37,46 @:@:string}
35254 @r{ a b@: + @: @: 2 @:add@:(a,b) a+b}
35255 @r{ a b@: - @: @: 2 @:sub@:(a,b) a@minus{}b}
35256 @r{ a b@: * @: @: 2 @:mul@:(a,b) a b, a*b}
35257 @r{ a b@: / @: @: 2 @:div@:(a,b) a/b}
35258 @r{ a b@: ^ @: @: 2 @:pow@:(a,b) a^b}
35259 @r{ a b@: I ^ @: @: 2 @:nroot@:(a,b) a^(1/b)}
35260 @r{ a b@: % @: @: 2 @:mod@:(a,b) a%b}
35261 @r{ a b@: \ @: @: 2 @:idiv@:(a,b) a\b}
35262 @r{ a b@: : @: @: 2 @:fdiv@:(a,b)}
35263 @r{ a b@: | @: @: 2 @:vconcat@:(a,b) a|b}
35264 @r{ a b@: I | @: @: @:vconcat@:(b,a) b|a}
35265 @r{ a b@: H | @: @: 2 @:append@:(a,b)}
35266 @r{ a b@: I H | @: @: @:append@:(b,a)}
35267 @r{ a@: & @: @: 1 @:inv@:(a) 1/a}
35268 @r{ a@: ! @: @: 1 @:fact@:(a) a!}
35269 @r{ a@: = @: @: 1 @:evalv@:(a)}
35270 @r{ a@: M-% @: @: @:percent@:(a) a%}
35273 @r{ ... a@: @key{RET} @: @: 1 @:@:... a a}
35274 @r{ ... a@: @key{SPC} @: @: 1 @:@:... a a}
35275 @r{... a b@: @key{TAB} @: @: 3 @:@:... b a}
35276 @r{. a b c@: M-@key{TAB} @: @: 3 @:@:... b c a}
35277 @r{... a b@: @key{LFD} @: @: 1 @:@:... a b a}
35278 @r{ ... a@: @key{DEL} @: @: 1 @:@:...}
35279 @r{... a b@: M-@key{DEL} @: @: 1 @:@:... b}
35280 @r{ @: M-@key{RET} @: @: 4 @:calc-last-args@:}
35281 @r{ a@: ` @:editing @: 1,30 @:calc-edit@:}
35284 @r{ ... a@: C-d @: @: 1 @:@:...}
35285 @r{ @: C-k @: @: 27 @:calc-kill@:}
35286 @r{ @: C-w @: @: 27 @:calc-kill-region@:}
35287 @r{ @: C-y @: @: @:calc-yank@:}
35288 @r{ @: C-_ @: @: 4 @:calc-undo@:}
35289 @r{ @: M-k @: @: 27 @:calc-copy-as-kill@:}
35290 @r{ @: M-w @: @: 27 @:calc-copy-region-as-kill@:}
35293 @r{ @: [ @: @: @:@:[...}
35294 @r{[.. a b@: ] @: @: @:@:[a,b]}
35295 @r{ @: ( @: @: @:@:(...}
35296 @r{(.. a b@: ) @: @: @:@:(a,b)}
35297 @r{ @: , @: @: @:@:vector or rect complex}
35298 @r{ @: ; @: @: @:@:matrix or polar complex}
35299 @r{ @: .. @: @: @:@:interval}
35302 @r{ @: ~ @: @: @:calc-num-prefix@:}
35303 @r{ @: < @: @: 4 @:calc-scroll-left@:}
35304 @r{ @: > @: @: 4 @:calc-scroll-right@:}
35305 @r{ @: @{ @: @: 4 @:calc-scroll-down@:}
35306 @r{ @: @} @: @: 4 @:calc-scroll-up@:}
35307 @r{ @: ? @: @: @:calc-help@:}
35310 @r{ a@: n @: @: 1 @:neg@:(a) @minus{}a}
35311 @r{ @: o @: @: 4 @:calc-realign@:}
35312 @r{ @: p @:precision @: 31 @:calc-precision@:}
35313 @r{ @: q @: @: @:calc-quit@:}
35314 @r{ @: w @: @: @:calc-why@:}
35315 @r{ @: x @:command @: @:M-x calc-@:command}
35316 @r{ a@: y @: @:1,28,49 @:calc-copy-to-buffer@:}
35319 @r{ a@: A @: @: 1 @:abs@:(a)}
35320 @r{ a b@: B @: @: 2 @:log@:(a,b)}
35321 @r{ a b@: I B @: @: 2 @:alog@:(a,b) b^a}
35322 @r{ a@: C @: @: 1 @:cos@:(a)}
35323 @r{ a@: I C @: @: 1 @:arccos@:(a)}
35324 @r{ a@: H C @: @: 1 @:cosh@:(a)}
35325 @r{ a@: I H C @: @: 1 @:arccosh@:(a)}
35326 @r{ @: D @: @: 4 @:calc-redo@:}
35327 @r{ a@: E @: @: 1 @:exp@:(a)}
35328 @r{ a@: H E @: @: 1 @:exp10@:(a) 10.^a}
35329 @r{ a@: F @: @: 1,11 @:floor@:(a,d)}
35330 @r{ a@: I F @: @: 1,11 @:ceil@:(a,d)}
35331 @r{ a@: H F @: @: 1,11 @:ffloor@:(a,d)}
35332 @r{ a@: I H F @: @: 1,11 @:fceil@:(a,d)}
35333 @r{ a@: G @: @: 1 @:arg@:(a)}
35334 @r{ @: H @:command @: 32 @:@:Hyperbolic}
35335 @r{ @: I @:command @: 32 @:@:Inverse}
35336 @r{ a@: J @: @: 1 @:conj@:(a)}
35337 @r{ @: K @:command @: 32 @:@:Keep-args}
35338 @r{ a@: L @: @: 1 @:ln@:(a)}
35339 @r{ a@: H L @: @: 1 @:log10@:(a)}
35340 @r{ @: M @: @: @:calc-more-recursion-depth@:}
35341 @r{ @: I M @: @: @:calc-less-recursion-depth@:}
35342 @r{ a@: N @: @: 5 @:evalvn@:(a)}
35343 @r{ @: P @: @: @:@:pi}
35344 @r{ @: I P @: @: @:@:gamma}
35345 @r{ @: H P @: @: @:@:e}
35346 @r{ @: I H P @: @: @:@:phi}
35347 @r{ a@: Q @: @: 1 @:sqrt@:(a)}
35348 @r{ a@: I Q @: @: 1 @:sqr@:(a) a^2}
35349 @r{ a@: R @: @: 1,11 @:round@:(a,d)}
35350 @r{ a@: I R @: @: 1,11 @:trunc@:(a,d)}
35351 @r{ a@: H R @: @: 1,11 @:fround@:(a,d)}
35352 @r{ a@: I H R @: @: 1,11 @:ftrunc@:(a,d)}
35353 @r{ a@: S @: @: 1 @:sin@:(a)}
35354 @r{ a@: I S @: @: 1 @:arcsin@:(a)}
35355 @r{ a@: H S @: @: 1 @:sinh@:(a)}
35356 @r{ a@: I H S @: @: 1 @:arcsinh@:(a)}
35357 @r{ a@: T @: @: 1 @:tan@:(a)}
35358 @r{ a@: I T @: @: 1 @:arctan@:(a)}
35359 @r{ a@: H T @: @: 1 @:tanh@:(a)}
35360 @r{ a@: I H T @: @: 1 @:arctanh@:(a)}
35361 @r{ @: U @: @: 4 @:calc-undo@:}
35362 @r{ @: X @: @: 4 @:calc-call-last-kbd-macro@:}
35365 @r{ a b@: a = @: @: 2 @:eq@:(a,b) a=b}
35366 @r{ a b@: a # @: @: 2 @:neq@:(a,b) a!=b}
35367 @r{ a b@: a < @: @: 2 @:lt@:(a,b) a<b}
35368 @r{ a b@: a > @: @: 2 @:gt@:(a,b) a>b}
35369 @r{ a b@: a [ @: @: 2 @:leq@:(a,b) a<=b}
35370 @r{ a b@: a ] @: @: 2 @:geq@:(a,b) a>=b}
35371 @r{ a b@: a @{ @: @: 2 @:in@:(a,b)}
35372 @r{ a b@: a & @: @: 2,45 @:land@:(a,b) a&&b}
35373 @r{ a b@: a | @: @: 2,45 @:lor@:(a,b) a||b}
35374 @r{ a@: a ! @: @: 1,45 @:lnot@:(a) !a}
35375 @r{ a b c@: a : @: @: 45 @:if@:(a,b,c) a?b:c}
35376 @r{ a@: a . @: @: 1 @:rmeq@:(a)}
35377 @r{ a@: a " @: @: 7,8 @:calc-expand-formula@:}
35380 @r{ a@: a + @:i, l, h @: 6,38 @:sum@:(a,i,l,h)}
35381 @r{ a@: a - @:i, l, h @: 6,38 @:asum@:(a,i,l,h)}
35382 @r{ a@: a * @:i, l, h @: 6,38 @:prod@:(a,i,l,h)}
35383 @r{ a b@: a _ @: @: 2 @:subscr@:(a,b) a_b}
35386 @r{ a b@: a \ @: @: 2 @:pdiv@:(a,b)}
35387 @r{ a b@: a % @: @: 2 @:prem@:(a,b)}
35388 @r{ a b@: a / @: @: 2 @:pdivrem@:(a,b) [q,r]}
35389 @r{ a b@: H a / @: @: 2 @:pdivide@:(a,b) q+r/b}
35392 @r{ a@: a a @: @: 1 @:apart@:(a)}
35393 @r{ a@: a b @:old, new @: 38 @:subst@:(a,old,new)}
35394 @r{ a@: a c @:v @: 38 @:collect@:(a,v)}
35395 @r{ a@: a d @:v @: 4,38 @:deriv@:(a,v)}
35396 @r{ a@: H a d @:v @: 4,38 @:tderiv@:(a,v)}
35397 @r{ a@: a e @: @: @:esimplify@:(a)}
35398 @r{ a@: a f @: @: 1 @:factor@:(a)}
35399 @r{ a@: H a f @: @: 1 @:factors@:(a)}
35400 @r{ a b@: a g @: @: 2 @:pgcd@:(a,b)}
35401 @r{ a@: a i @:v @: 38 @:integ@:(a,v)}
35402 @r{ a@: a m @:pats @: 38 @:match@:(a,pats)}
35403 @r{ a@: I a m @:pats @: 38 @:matchnot@:(a,pats)}
35404 @r{ data x@: a p @: @: 28 @:polint@:(data,x)}
35405 @r{ data x@: H a p @: @: 28 @:ratint@:(data,x)}
35406 @r{ a@: a n @: @: 1 @:nrat@:(a)}
35407 @r{ a@: a r @:rules @:4,8,38 @:rewrite@:(a,rules,n)}
35408 @r{ a@: a s @: @: @:simplify@:(a)}
35409 @r{ a@: a t @:v, n @: 31,39 @:taylor@:(a,v,n)}
35410 @r{ a@: a v @: @: 7,8 @:calc-alg-evaluate@:}
35411 @r{ a@: a x @: @: 4,8 @:expand@:(a)}
35414 @r{ data@: a F @:model, vars @: 48 @:fit@:(m,iv,pv,data)}
35415 @r{ data@: I a F @:model, vars @: 48 @:xfit@:(m,iv,pv,data)}
35416 @r{ data@: H a F @:model, vars @: 48 @:efit@:(m,iv,pv,data)}
35417 @r{ a@: a I @:v, l, h @: 38 @:ninteg@:(a,v,l,h)}
35418 @r{ a b@: a M @:op @: 22 @:mapeq@:(op,a,b)}
35419 @r{ a b@: I a M @:op @: 22 @:mapeqr@:(op,a,b)}
35420 @r{ a b@: H a M @:op @: 22 @:mapeqp@:(op,a,b)}
35421 @r{ a g@: a N @:v @: 38 @:minimize@:(a,v,g)}
35422 @r{ a g@: H a N @:v @: 38 @:wminimize@:(a,v,g)}
35423 @r{ a@: a P @:v @: 38 @:roots@:(a,v)}
35424 @r{ a g@: a R @:v @: 38 @:root@:(a,v,g)}
35425 @r{ a g@: H a R @:v @: 38 @:wroot@:(a,v,g)}
35426 @r{ a@: a S @:v @: 38 @:solve@:(a,v)}
35427 @r{ a@: I a S @:v @: 38 @:finv@:(a,v)}
35428 @r{ a@: H a S @:v @: 38 @:fsolve@:(a,v)}
35429 @r{ a@: I H a S @:v @: 38 @:ffinv@:(a,v)}
35430 @r{ a@: a T @:i, l, h @: 6,38 @:table@:(a,i,l,h)}
35431 @r{ a g@: a X @:v @: 38 @:maximize@:(a,v,g)}
35432 @r{ a g@: H a X @:v @: 38 @:wmaximize@:(a,v,g)}
35435 @r{ a b@: b a @: @: 9 @:and@:(a,b,w)}
35436 @r{ a@: b c @: @: 9 @:clip@:(a,w)}
35437 @r{ a b@: b d @: @: 9 @:diff@:(a,b,w)}
35438 @r{ a@: b l @: @: 10 @:lsh@:(a,n,w)}
35439 @r{ a n@: H b l @: @: 9 @:lsh@:(a,n,w)}
35440 @r{ a@: b n @: @: 9 @:not@:(a,w)}
35441 @r{ a b@: b o @: @: 9 @:or@:(a,b,w)}
35442 @r{ v@: b p @: @: 1 @:vpack@:(v)}
35443 @r{ a@: b r @: @: 10 @:rsh@:(a,n,w)}
35444 @r{ a n@: H b r @: @: 9 @:rsh@:(a,n,w)}
35445 @r{ a@: b t @: @: 10 @:rot@:(a,n,w)}
35446 @r{ a n@: H b t @: @: 9 @:rot@:(a,n,w)}
35447 @r{ a@: b u @: @: 1 @:vunpack@:(a)}
35448 @r{ @: b w @:w @: 9,50 @:calc-word-size@:}
35449 @r{ a b@: b x @: @: 9 @:xor@:(a,b,w)}
35452 @r{c s l p@: b D @: @: @:ddb@:(c,s,l,p)}
35453 @r{ r n p@: b F @: @: @:fv@:(r,n,p)}
35454 @r{ r n p@: I b F @: @: @:fvb@:(r,n,p)}
35455 @r{ r n p@: H b F @: @: @:fvl@:(r,n,p)}
35456 @r{ v@: b I @: @: 19 @:irr@:(v)}
35457 @r{ v@: I b I @: @: 19 @:irrb@:(v)}
35458 @r{ a@: b L @: @: 10 @:ash@:(a,n,w)}
35459 @r{ a n@: H b L @: @: 9 @:ash@:(a,n,w)}
35460 @r{ r n a@: b M @: @: @:pmt@:(r,n,a)}
35461 @r{ r n a@: I b M @: @: @:pmtb@:(r,n,a)}
35462 @r{ r n a@: H b M @: @: @:pmtl@:(r,n,a)}
35463 @r{ r v@: b N @: @: 19 @:npv@:(r,v)}
35464 @r{ r v@: I b N @: @: 19 @:npvb@:(r,v)}
35465 @r{ r n p@: b P @: @: @:pv@:(r,n,p)}
35466 @r{ r n p@: I b P @: @: @:pvb@:(r,n,p)}
35467 @r{ r n p@: H b P @: @: @:pvl@:(r,n,p)}
35468 @r{ a@: b R @: @: 10 @:rash@:(a,n,w)}
35469 @r{ a n@: H b R @: @: 9 @:rash@:(a,n,w)}
35470 @r{ c s l@: b S @: @: @:sln@:(c,s,l)}
35471 @r{ n p a@: b T @: @: @:rate@:(n,p,a)}
35472 @r{ n p a@: I b T @: @: @:rateb@:(n,p,a)}
35473 @r{ n p a@: H b T @: @: @:ratel@:(n,p,a)}
35474 @r{c s l p@: b Y @: @: @:syd@:(c,s,l,p)}
35476 @r{ r p a@: b # @: @: @:nper@:(r,p,a)}
35477 @r{ r p a@: I b # @: @: @:nperb@:(r,p,a)}
35478 @r{ r p a@: H b # @: @: @:nperl@:(r,p,a)}
35479 @r{ a b@: b % @: @: @:relch@:(a,b)}
35482 @r{ a@: c c @: @: 5 @:pclean@:(a,p)}
35483 @r{ a@: c 0-9 @: @: @:pclean@:(a,p)}
35484 @r{ a@: H c c @: @: 5 @:clean@:(a,p)}
35485 @r{ a@: H c 0-9 @: @: @:clean@:(a,p)}
35486 @r{ a@: c d @: @: 1 @:deg@:(a)}
35487 @r{ a@: c f @: @: 1 @:pfloat@:(a)}
35488 @r{ a@: H c f @: @: 1 @:float@:(a)}
35489 @r{ a@: c h @: @: 1 @:hms@:(a)}
35490 @r{ a@: c p @: @: @:polar@:(a)}
35491 @r{ a@: I c p @: @: @:rect@:(a)}
35492 @r{ a@: c r @: @: 1 @:rad@:(a)}
35495 @r{ a@: c F @: @: 5 @:pfrac@:(a,p)}
35496 @r{ a@: H c F @: @: 5 @:frac@:(a,p)}
35499 @r{ a@: c % @: @: @:percent@:(a*100)}
35502 @r{ @: d . @:char @: 50 @:calc-point-char@:}
35503 @r{ @: d , @:char @: 50 @:calc-group-char@:}
35504 @r{ @: d < @: @: 13,50 @:calc-left-justify@:}
35505 @r{ @: d = @: @: 13,50 @:calc-center-justify@:}
35506 @r{ @: d > @: @: 13,50 @:calc-right-justify@:}
35507 @r{ @: d @{ @:label @: 50 @:calc-left-label@:}
35508 @r{ @: d @} @:label @: 50 @:calc-right-label@:}
35509 @r{ @: d [ @: @: 4 @:calc-truncate-up@:}
35510 @r{ @: d ] @: @: 4 @:calc-truncate-down@:}
35511 @r{ @: d " @: @: 12,50 @:calc-display-strings@:}
35512 @r{ @: d @key{SPC} @: @: @:calc-refresh@:}
35513 @r{ @: d @key{RET} @: @: 1 @:calc-refresh-top@:}
35516 @r{ @: d 0 @: @: 50 @:calc-decimal-radix@:}
35517 @r{ @: d 2 @: @: 50 @:calc-binary-radix@:}
35518 @r{ @: d 6 @: @: 50 @:calc-hex-radix@:}
35519 @r{ @: d 8 @: @: 50 @:calc-octal-radix@:}
35522 @r{ @: d b @: @:12,13,50 @:calc-line-breaking@:}
35523 @r{ @: d c @: @: 50 @:calc-complex-notation@:}
35524 @r{ @: d d @:format @: 50 @:calc-date-notation@:}
35525 @r{ @: d e @: @: 5,50 @:calc-eng-notation@:}
35526 @r{ @: d f @:num @: 31,50 @:calc-fix-notation@:}
35527 @r{ @: d g @: @:12,13,50 @:calc-group-digits@:}
35528 @r{ @: d h @:format @: 50 @:calc-hms-notation@:}
35529 @r{ @: d i @: @: 50 @:calc-i-notation@:}
35530 @r{ @: d j @: @: 50 @:calc-j-notation@:}
35531 @r{ @: d l @: @: 12,50 @:calc-line-numbering@:}
35532 @r{ @: d n @: @: 5,50 @:calc-normal-notation@:}
35533 @r{ @: d o @:format @: 50 @:calc-over-notation@:}
35534 @r{ @: d p @: @: 12,50 @:calc-show-plain@:}
35535 @r{ @: d r @:radix @: 31,50 @:calc-radix@:}
35536 @r{ @: d s @: @: 5,50 @:calc-sci-notation@:}
35537 @r{ @: d t @: @: 27 @:calc-truncate-stack@:}
35538 @r{ @: d w @: @: 12,13 @:calc-auto-why@:}
35539 @r{ @: d z @: @: 12,50 @:calc-leading-zeros@:}
35542 @r{ @: d B @: @: 50 @:calc-big-language@:}
35543 @r{ @: d C @: @: 50 @:calc-c-language@:}
35544 @r{ @: d E @: @: 50 @:calc-eqn-language@:}
35545 @r{ @: d F @: @: 50 @:calc-fortran-language@:}
35546 @r{ @: d M @: @: 50 @:calc-mathematica-language@:}
35547 @r{ @: d N @: @: 50 @:calc-normal-language@:}
35548 @r{ @: d O @: @: 50 @:calc-flat-language@:}
35549 @r{ @: d P @: @: 50 @:calc-pascal-language@:}
35550 @r{ @: d T @: @: 50 @:calc-tex-language@:}
35551 @r{ @: d L @: @: 50 @:calc-latex-language@:}
35552 @r{ @: d U @: @: 50 @:calc-unformatted-language@:}
35553 @r{ @: d W @: @: 50 @:calc-maple-language@:}
35556 @r{ a@: f [ @: @: 4 @:decr@:(a,n)}
35557 @r{ a@: f ] @: @: 4 @:incr@:(a,n)}
35560 @r{ a b@: f b @: @: 2 @:beta@:(a,b)}
35561 @r{ a@: f e @: @: 1 @:erf@:(a)}
35562 @r{ a@: I f e @: @: 1 @:erfc@:(a)}
35563 @r{ a@: f g @: @: 1 @:gamma@:(a)}
35564 @r{ a b@: f h @: @: 2 @:hypot@:(a,b)}
35565 @r{ a@: f i @: @: 1 @:im@:(a)}
35566 @r{ n a@: f j @: @: 2 @:besJ@:(n,a)}
35567 @r{ a b@: f n @: @: 2 @:min@:(a,b)}
35568 @r{ a@: f r @: @: 1 @:re@:(a)}
35569 @r{ a@: f s @: @: 1 @:sign@:(a)}
35570 @r{ a b@: f x @: @: 2 @:max@:(a,b)}
35571 @r{ n a@: f y @: @: 2 @:besY@:(n,a)}
35574 @r{ a@: f A @: @: 1 @:abssqr@:(a)}
35575 @r{ x a b@: f B @: @: @:betaI@:(x,a,b)}
35576 @r{ x a b@: H f B @: @: @:betaB@:(x,a,b)}
35577 @r{ a@: f E @: @: 1 @:expm1@:(a)}
35578 @r{ a x@: f G @: @: 2 @:gammaP@:(a,x)}
35579 @r{ a x@: I f G @: @: 2 @:gammaQ@:(a,x)}
35580 @r{ a x@: H f G @: @: 2 @:gammag@:(a,x)}
35581 @r{ a x@: I H f G @: @: 2 @:gammaG@:(a,x)}
35582 @r{ a b@: f I @: @: 2 @:ilog@:(a,b)}
35583 @r{ a b@: I f I @: @: 2 @:alog@:(a,b) b^a}
35584 @r{ a@: f L @: @: 1 @:lnp1@:(a)}
35585 @r{ a@: f M @: @: 1 @:mant@:(a)}
35586 @r{ a@: f Q @: @: 1 @:isqrt@:(a)}
35587 @r{ a@: I f Q @: @: 1 @:sqr@:(a) a^2}
35588 @r{ a n@: f S @: @: 2 @:scf@:(a,n)}
35589 @r{ y x@: f T @: @: @:arctan2@:(y,x)}
35590 @r{ a@: f X @: @: 1 @:xpon@:(a)}
35593 @r{ x y@: g a @: @: 28,40 @:calc-graph-add@:}
35594 @r{ @: g b @: @: 12 @:calc-graph-border@:}
35595 @r{ @: g c @: @: @:calc-graph-clear@:}
35596 @r{ @: g d @: @: 41 @:calc-graph-delete@:}
35597 @r{ x y@: g f @: @: 28,40 @:calc-graph-fast@:}
35598 @r{ @: g g @: @: 12 @:calc-graph-grid@:}
35599 @r{ @: g h @:title @: @:calc-graph-header@:}
35600 @r{ @: g j @: @: 4 @:calc-graph-juggle@:}
35601 @r{ @: g k @: @: 12 @:calc-graph-key@:}
35602 @r{ @: g l @: @: 12 @:calc-graph-log-x@:}
35603 @r{ @: g n @:name @: @:calc-graph-name@:}
35604 @r{ @: g p @: @: 42 @:calc-graph-plot@:}
35605 @r{ @: g q @: @: @:calc-graph-quit@:}
35606 @r{ @: g r @:range @: @:calc-graph-range-x@:}
35607 @r{ @: g s @: @: 12,13 @:calc-graph-line-style@:}
35608 @r{ @: g t @:title @: @:calc-graph-title-x@:}
35609 @r{ @: g v @: @: @:calc-graph-view-commands@:}
35610 @r{ @: g x @:display @: @:calc-graph-display@:}
35611 @r{ @: g z @: @: 12 @:calc-graph-zero-x@:}
35614 @r{ x y z@: g A @: @: 28,40 @:calc-graph-add-3d@:}
35615 @r{ @: g C @:command @: @:calc-graph-command@:}
35616 @r{ @: g D @:device @: 43,44 @:calc-graph-device@:}
35617 @r{ x y z@: g F @: @: 28,40 @:calc-graph-fast-3d@:}
35618 @r{ @: g H @: @: 12 @:calc-graph-hide@:}
35619 @r{ @: g K @: @: @:calc-graph-kill@:}
35620 @r{ @: g L @: @: 12 @:calc-graph-log-y@:}
35621 @r{ @: g N @:number @: 43,51 @:calc-graph-num-points@:}
35622 @r{ @: g O @:filename @: 43,44 @:calc-graph-output@:}
35623 @r{ @: g P @: @: 42 @:calc-graph-print@:}
35624 @r{ @: g R @:range @: @:calc-graph-range-y@:}
35625 @r{ @: g S @: @: 12,13 @:calc-graph-point-style@:}
35626 @r{ @: g T @:title @: @:calc-graph-title-y@:}
35627 @r{ @: g V @: @: @:calc-graph-view-trail@:}
35628 @r{ @: g X @:format @: @:calc-graph-geometry@:}
35629 @r{ @: g Z @: @: 12 @:calc-graph-zero-y@:}
35632 @r{ @: g C-l @: @: 12 @:calc-graph-log-z@:}
35633 @r{ @: g C-r @:range @: @:calc-graph-range-z@:}
35634 @r{ @: g C-t @:title @: @:calc-graph-title-z@:}
35637 @r{ @: h b @: @: @:calc-describe-bindings@:}
35638 @r{ @: h c @:key @: @:calc-describe-key-briefly@:}
35639 @r{ @: h f @:function @: @:calc-describe-function@:}
35640 @r{ @: h h @: @: @:calc-full-help@:}
35641 @r{ @: h i @: @: @:calc-info@:}
35642 @r{ @: h k @:key @: @:calc-describe-key@:}
35643 @r{ @: h n @: @: @:calc-view-news@:}
35644 @r{ @: h s @: @: @:calc-info-summary@:}
35645 @r{ @: h t @: @: @:calc-tutorial@:}
35646 @r{ @: h v @:var @: @:calc-describe-variable@:}
35649 @r{ @: j 1-9 @: @: @:calc-select-part@:}
35650 @r{ @: j @key{RET} @: @: 27 @:calc-copy-selection@:}
35651 @r{ @: j @key{DEL} @: @: 27 @:calc-del-selection@:}
35652 @r{ @: j ' @:formula @: 27 @:calc-enter-selection@:}
35653 @r{ @: j ` @:editing @: 27,30 @:calc-edit-selection@:}
35654 @r{ @: j " @: @: 7,27 @:calc-sel-expand-formula@:}
35657 @r{ @: j + @:formula @: 27 @:calc-sel-add-both-sides@:}
35658 @r{ @: j - @:formula @: 27 @:calc-sel-sub-both-sides@:}
35659 @r{ @: j * @:formula @: 27 @:calc-sel-mul-both-sides@:}
35660 @r{ @: j / @:formula @: 27 @:calc-sel-div-both-sides@:}
35661 @r{ @: j & @: @: 27 @:calc-sel-invert@:}
35664 @r{ @: j a @: @: 27 @:calc-select-additional@:}
35665 @r{ @: j b @: @: 12 @:calc-break-selections@:}
35666 @r{ @: j c @: @: @:calc-clear-selections@:}
35667 @r{ @: j d @: @: 12,50 @:calc-show-selections@:}
35668 @r{ @: j e @: @: 12 @:calc-enable-selections@:}
35669 @r{ @: j l @: @: 4,27 @:calc-select-less@:}
35670 @r{ @: j m @: @: 4,27 @:calc-select-more@:}
35671 @r{ @: j n @: @: 4 @:calc-select-next@:}
35672 @r{ @: j o @: @: 4,27 @:calc-select-once@:}
35673 @r{ @: j p @: @: 4 @:calc-select-previous@:}
35674 @r{ @: j r @:rules @:4,8,27 @:calc-rewrite-selection@:}
35675 @r{ @: j s @: @: 4,27 @:calc-select-here@:}
35676 @r{ @: j u @: @: 27 @:calc-unselect@:}
35677 @r{ @: j v @: @: 7,27 @:calc-sel-evaluate@:}
35680 @r{ @: j C @: @: 27 @:calc-sel-commute@:}
35681 @r{ @: j D @: @: 4,27 @:calc-sel-distribute@:}
35682 @r{ @: j E @: @: 27 @:calc-sel-jump-equals@:}
35683 @r{ @: j I @: @: 27 @:calc-sel-isolate@:}
35684 @r{ @: H j I @: @: 27 @:calc-sel-isolate@: (full)}
35685 @r{ @: j L @: @: 4,27 @:calc-commute-left@:}
35686 @r{ @: j M @: @: 27 @:calc-sel-merge@:}
35687 @r{ @: j N @: @: 27 @:calc-sel-negate@:}
35688 @r{ @: j O @: @: 4,27 @:calc-select-once-maybe@:}
35689 @r{ @: j R @: @: 4,27 @:calc-commute-right@:}
35690 @r{ @: j S @: @: 4,27 @:calc-select-here-maybe@:}
35691 @r{ @: j U @: @: 27 @:calc-sel-unpack@:}
35694 @r{ @: k a @: @: @:calc-random-again@:}
35695 @r{ n@: k b @: @: 1 @:bern@:(n)}
35696 @r{ n x@: H k b @: @: 2 @:bern@:(n,x)}
35697 @r{ n m@: k c @: @: 2 @:choose@:(n,m)}
35698 @r{ n m@: H k c @: @: 2 @:perm@:(n,m)}
35699 @r{ n@: k d @: @: 1 @:dfact@:(n) n!!}
35700 @r{ n@: k e @: @: 1 @:euler@:(n)}
35701 @r{ n x@: H k e @: @: 2 @:euler@:(n,x)}
35702 @r{ n@: k f @: @: 4 @:prfac@:(n)}
35703 @r{ n m@: k g @: @: 2 @:gcd@:(n,m)}
35704 @r{ m n@: k h @: @: 14 @:shuffle@:(n,m)}
35705 @r{ n m@: k l @: @: 2 @:lcm@:(n,m)}
35706 @r{ n@: k m @: @: 1 @:moebius@:(n)}
35707 @r{ n@: k n @: @: 4 @:nextprime@:(n)}
35708 @r{ n@: I k n @: @: 4 @:prevprime@:(n)}
35709 @r{ n@: k p @: @: 4,28 @:calc-prime-test@:}
35710 @r{ m@: k r @: @: 14 @:random@:(m)}
35711 @r{ n m@: k s @: @: 2 @:stir1@:(n,m)}
35712 @r{ n m@: H k s @: @: 2 @:stir2@:(n,m)}
35713 @r{ n@: k t @: @: 1 @:totient@:(n)}
35716 @r{ n p x@: k B @: @: @:utpb@:(x,n,p)}
35717 @r{ n p x@: I k B @: @: @:ltpb@:(x,n,p)}
35718 @r{ v x@: k C @: @: @:utpc@:(x,v)}
35719 @r{ v x@: I k C @: @: @:ltpc@:(x,v)}
35720 @r{ n m@: k E @: @: @:egcd@:(n,m)}
35721 @r{v1 v2 x@: k F @: @: @:utpf@:(x,v1,v2)}
35722 @r{v1 v2 x@: I k F @: @: @:ltpf@:(x,v1,v2)}
35723 @r{ m s x@: k N @: @: @:utpn@:(x,m,s)}
35724 @r{ m s x@: I k N @: @: @:ltpn@:(x,m,s)}
35725 @r{ m x@: k P @: @: @:utpp@:(x,m)}
35726 @r{ m x@: I k P @: @: @:ltpp@:(x,m)}
35727 @r{ v x@: k T @: @: @:utpt@:(x,v)}
35728 @r{ v x@: I k T @: @: @:ltpt@:(x,v)}
35731 @r{ @: m a @: @: 12,13 @:calc-algebraic-mode@:}
35732 @r{ @: m d @: @: @:calc-degrees-mode@:}
35733 @r{ @: m e @: @: @:calc-embedded-preserve-modes@:}
35734 @r{ @: m f @: @: 12 @:calc-frac-mode@:}
35735 @r{ @: m g @: @: 52 @:calc-get-modes@:}
35736 @r{ @: m h @: @: @:calc-hms-mode@:}
35737 @r{ @: m i @: @: 12,13 @:calc-infinite-mode@:}
35738 @r{ @: m m @: @: @:calc-save-modes@:}
35739 @r{ @: m p @: @: 12 @:calc-polar-mode@:}
35740 @r{ @: m r @: @: @:calc-radians-mode@:}
35741 @r{ @: m s @: @: 12 @:calc-symbolic-mode@:}
35742 @r{ @: m t @: @: 12 @:calc-total-algebraic-mode@:}
35743 @r{ @: m v @: @: 12,13 @:calc-matrix-mode@:}
35744 @r{ @: m w @: @: 13 @:calc-working@:}
35745 @r{ @: m x @: @: @:calc-always-load-extensions@:}
35748 @r{ @: m A @: @: 12 @:calc-alg-simplify-mode@:}
35749 @r{ @: m B @: @: 12 @:calc-bin-simplify-mode@:}
35750 @r{ @: m C @: @: 12 @:calc-auto-recompute@:}
35751 @r{ @: m D @: @: @:calc-default-simplify-mode@:}
35752 @r{ @: m E @: @: 12 @:calc-ext-simplify-mode@:}
35753 @r{ @: m F @:filename @: 13 @:calc-settings-file-name@:}
35754 @r{ @: m N @: @: 12 @:calc-num-simplify-mode@:}
35755 @r{ @: m O @: @: 12 @:calc-no-simplify-mode@:}
35756 @r{ @: m R @: @: 12,13 @:calc-mode-record-mode@:}
35757 @r{ @: m S @: @: 12 @:calc-shift-prefix@:}
35758 @r{ @: m U @: @: 12 @:calc-units-simplify-mode@:}
35761 @r{ @: s c @:var1, var2 @: 29 @:calc-copy-variable@:}
35762 @r{ @: s d @:var, decl @: @:calc-declare-variable@:}
35763 @r{ @: s e @:var, editing @: 29,30 @:calc-edit-variable@:}
35764 @r{ @: s i @:buffer @: @:calc-insert-variables@:}
35765 @r{ @: s k @:const, var @: 29 @:calc-copy-special-constant@:}
35766 @r{ a b@: s l @:var @: 29 @:@:a (letting var=b)}
35767 @r{ a ...@: s m @:op, var @: 22,29 @:calc-store-map@:}
35768 @r{ @: s n @:var @: 29,47 @:calc-store-neg@: (v/-1)}
35769 @r{ @: s p @:var @: 29 @:calc-permanent-variable@:}
35770 @r{ @: s r @:var @: 29 @:@:v (recalled value)}
35771 @r{ @: r 0-9 @: @: @:calc-recall-quick@:}
35772 @r{ a@: s s @:var @: 28,29 @:calc-store@:}
35773 @r{ a@: s 0-9 @: @: @:calc-store-quick@:}
35774 @r{ a@: s t @:var @: 29 @:calc-store-into@:}
35775 @r{ a@: t 0-9 @: @: @:calc-store-into-quick@:}
35776 @r{ @: s u @:var @: 29 @:calc-unstore@:}
35777 @r{ a@: s x @:var @: 29 @:calc-store-exchange@:}
35780 @r{ @: s A @:editing @: 30 @:calc-edit-AlgSimpRules@:}
35781 @r{ @: s D @:editing @: 30 @:calc-edit-Decls@:}
35782 @r{ @: s E @:editing @: 30 @:calc-edit-EvalRules@:}
35783 @r{ @: s F @:editing @: 30 @:calc-edit-FitRules@:}
35784 @r{ @: s G @:editing @: 30 @:calc-edit-GenCount@:}
35785 @r{ @: s H @:editing @: 30 @:calc-edit-Holidays@:}
35786 @r{ @: s I @:editing @: 30 @:calc-edit-IntegLimit@:}
35787 @r{ @: s L @:editing @: 30 @:calc-edit-LineStyles@:}
35788 @r{ @: s P @:editing @: 30 @:calc-edit-PointStyles@:}
35789 @r{ @: s R @:editing @: 30 @:calc-edit-PlotRejects@:}
35790 @r{ @: s T @:editing @: 30 @:calc-edit-TimeZone@:}
35791 @r{ @: s U @:editing @: 30 @:calc-edit-Units@:}
35792 @r{ @: s X @:editing @: 30 @:calc-edit-ExtSimpRules@:}
35795 @r{ a@: s + @:var @: 29,47 @:calc-store-plus@: (v+a)}
35796 @r{ a@: s - @:var @: 29,47 @:calc-store-minus@: (v-a)}
35797 @r{ a@: s * @:var @: 29,47 @:calc-store-times@: (v*a)}
35798 @r{ a@: s / @:var @: 29,47 @:calc-store-div@: (v/a)}
35799 @r{ a@: s ^ @:var @: 29,47 @:calc-store-power@: (v^a)}
35800 @r{ a@: s | @:var @: 29,47 @:calc-store-concat@: (v|a)}
35801 @r{ @: s & @:var @: 29,47 @:calc-store-inv@: (v^-1)}
35802 @r{ @: s [ @:var @: 29,47 @:calc-store-decr@: (v-1)}
35803 @r{ @: s ] @:var @: 29,47 @:calc-store-incr@: (v-(-1))}
35804 @r{ a b@: s : @: @: 2 @:assign@:(a,b) a @tfn{:=} b}
35805 @r{ a@: s = @: @: 1 @:evalto@:(a,b) a @tfn{=>}}
35808 @r{ @: t [ @: @: 4 @:calc-trail-first@:}
35809 @r{ @: t ] @: @: 4 @:calc-trail-last@:}
35810 @r{ @: t < @: @: 4 @:calc-trail-scroll-left@:}
35811 @r{ @: t > @: @: 4 @:calc-trail-scroll-right@:}
35812 @r{ @: t . @: @: 12 @:calc-full-trail-vectors@:}
35815 @r{ @: t b @: @: 4 @:calc-trail-backward@:}
35816 @r{ @: t d @: @: 12,50 @:calc-trail-display@:}
35817 @r{ @: t f @: @: 4 @:calc-trail-forward@:}
35818 @r{ @: t h @: @: @:calc-trail-here@:}
35819 @r{ @: t i @: @: @:calc-trail-in@:}
35820 @r{ @: t k @: @: 4 @:calc-trail-kill@:}
35821 @r{ @: t m @:string @: @:calc-trail-marker@:}
35822 @r{ @: t n @: @: 4 @:calc-trail-next@:}
35823 @r{ @: t o @: @: @:calc-trail-out@:}
35824 @r{ @: t p @: @: 4 @:calc-trail-previous@:}
35825 @r{ @: t r @:string @: @:calc-trail-isearch-backward@:}
35826 @r{ @: t s @:string @: @:calc-trail-isearch-forward@:}
35827 @r{ @: t y @: @: 4 @:calc-trail-yank@:}
35830 @r{ d@: t C @:oz, nz @: @:tzconv@:(d,oz,nz)}
35831 @r{d oz nz@: t C @:$ @: @:tzconv@:(d,oz,nz)}
35832 @r{ d@: t D @: @: 15 @:date@:(d)}
35833 @r{ d@: t I @: @: 4 @:incmonth@:(d,n)}
35834 @r{ d@: t J @: @: 16 @:julian@:(d,z)}
35835 @r{ d@: t M @: @: 17 @:newmonth@:(d,n)}
35836 @r{ @: t N @: @: 16 @:now@:(z)}
35837 @r{ d@: t P @:1 @: 31 @:year@:(d)}
35838 @r{ d@: t P @:2 @: 31 @:month@:(d)}
35839 @r{ d@: t P @:3 @: 31 @:day@:(d)}
35840 @r{ d@: t P @:4 @: 31 @:hour@:(d)}
35841 @r{ d@: t P @:5 @: 31 @:minute@:(d)}
35842 @r{ d@: t P @:6 @: 31 @:second@:(d)}
35843 @r{ d@: t P @:7 @: 31 @:weekday@:(d)}
35844 @r{ d@: t P @:8 @: 31 @:yearday@:(d)}
35845 @r{ d@: t P @:9 @: 31 @:time@:(d)}
35846 @r{ d@: t U @: @: 16 @:unixtime@:(d,z)}
35847 @r{ d@: t W @: @: 17 @:newweek@:(d,w)}
35848 @r{ d@: t Y @: @: 17 @:newyear@:(d,n)}
35851 @r{ a b@: t + @: @: 2 @:badd@:(a,b)}
35852 @r{ a b@: t - @: @: 2 @:bsub@:(a,b)}
35855 @r{ @: u a @: @: 12 @:calc-autorange-units@:}
35856 @r{ a@: u b @: @: @:calc-base-units@:}
35857 @r{ a@: u c @:units @: 18 @:calc-convert-units@:}
35858 @r{ defn@: u d @:unit, descr @: @:calc-define-unit@:}
35859 @r{ @: u e @: @: @:calc-explain-units@:}
35860 @r{ @: u g @:unit @: @:calc-get-unit-definition@:}
35861 @r{ @: u p @: @: @:calc-permanent-units@:}
35862 @r{ a@: u r @: @: @:calc-remove-units@:}
35863 @r{ a@: u s @: @: @:usimplify@:(a)}
35864 @r{ a@: u t @:units @: 18 @:calc-convert-temperature@:}
35865 @r{ @: u u @:unit @: @:calc-undefine-unit@:}
35866 @r{ @: u v @: @: @:calc-enter-units-table@:}
35867 @r{ a@: u x @: @: @:calc-extract-units@:}
35868 @r{ a@: u 0-9 @: @: @:calc-quick-units@:}
35871 @r{ v1 v2@: u C @: @: 20 @:vcov@:(v1,v2)}
35872 @r{ v1 v2@: I u C @: @: 20 @:vpcov@:(v1,v2)}
35873 @r{ v1 v2@: H u C @: @: 20 @:vcorr@:(v1,v2)}
35874 @r{ v@: u G @: @: 19 @:vgmean@:(v)}
35875 @r{ a b@: H u G @: @: 2 @:agmean@:(a,b)}
35876 @r{ v@: u M @: @: 19 @:vmean@:(v)}
35877 @r{ v@: I u M @: @: 19 @:vmeane@:(v)}
35878 @r{ v@: H u M @: @: 19 @:vmedian@:(v)}
35879 @r{ v@: I H u M @: @: 19 @:vhmean@:(v)}
35880 @r{ v@: u N @: @: 19 @:vmin@:(v)}
35881 @r{ v@: u S @: @: 19 @:vsdev@:(v)}
35882 @r{ v@: I u S @: @: 19 @:vpsdev@:(v)}
35883 @r{ v@: H u S @: @: 19 @:vvar@:(v)}
35884 @r{ v@: I H u S @: @: 19 @:vpvar@:(v)}
35885 @r{ @: u V @: @: @:calc-view-units-table@:}
35886 @r{ v@: u X @: @: 19 @:vmax@:(v)}
35889 @r{ v@: u + @: @: 19 @:vsum@:(v)}
35890 @r{ v@: u * @: @: 19 @:vprod@:(v)}
35891 @r{ v@: u # @: @: 19 @:vcount@:(v)}
35894 @r{ @: V ( @: @: 50 @:calc-vector-parens@:}
35895 @r{ @: V @{ @: @: 50 @:calc-vector-braces@:}
35896 @r{ @: V [ @: @: 50 @:calc-vector-brackets@:}
35897 @r{ @: V ] @:ROCP @: 50 @:calc-matrix-brackets@:}
35898 @r{ @: V , @: @: 50 @:calc-vector-commas@:}
35899 @r{ @: V < @: @: 50 @:calc-matrix-left-justify@:}
35900 @r{ @: V = @: @: 50 @:calc-matrix-center-justify@:}
35901 @r{ @: V > @: @: 50 @:calc-matrix-right-justify@:}
35902 @r{ @: V / @: @: 12,50 @:calc-break-vectors@:}
35903 @r{ @: V . @: @: 12,50 @:calc-full-vectors@:}
35906 @r{ s t@: V ^ @: @: 2 @:vint@:(s,t)}
35907 @r{ s t@: V - @: @: 2 @:vdiff@:(s,t)}
35908 @r{ s@: V ~ @: @: 1 @:vcompl@:(s)}
35909 @r{ s@: V # @: @: 1 @:vcard@:(s)}
35910 @r{ s@: V : @: @: 1 @:vspan@:(s)}
35911 @r{ s@: V + @: @: 1 @:rdup@:(s)}
35914 @r{ m@: V & @: @: 1 @:inv@:(m) 1/m}
35917 @r{ v@: v a @:n @: @:arrange@:(v,n)}
35918 @r{ a@: v b @:n @: @:cvec@:(a,n)}
35919 @r{ v@: v c @:n >0 @: 21,31 @:mcol@:(v,n)}
35920 @r{ v@: v c @:n <0 @: 31 @:mrcol@:(v,-n)}
35921 @r{ m@: v c @:0 @: 31 @:getdiag@:(m)}
35922 @r{ v@: v d @: @: 25 @:diag@:(v,n)}
35923 @r{ v m@: v e @: @: 2 @:vexp@:(v,m)}
35924 @r{ v m f@: H v e @: @: 2 @:vexp@:(v,m,f)}
35925 @r{ v a@: v f @: @: 26 @:find@:(v,a,n)}
35926 @r{ v@: v h @: @: 1 @:head@:(v)}
35927 @r{ v@: I v h @: @: 1 @:tail@:(v)}
35928 @r{ v@: H v h @: @: 1 @:rhead@:(v)}
35929 @r{ v@: I H v h @: @: 1 @:rtail@:(v)}
35930 @r{ @: v i @:n @: 31 @:idn@:(1,n)}
35931 @r{ @: v i @:0 @: 31 @:idn@:(1)}
35932 @r{ h t@: v k @: @: 2 @:cons@:(h,t)}
35933 @r{ h t@: H v k @: @: 2 @:rcons@:(h,t)}
35934 @r{ v@: v l @: @: 1 @:vlen@:(v)}
35935 @r{ v@: H v l @: @: 1 @:mdims@:(v)}
35936 @r{ v m@: v m @: @: 2 @:vmask@:(v,m)}
35937 @r{ v@: v n @: @: 1 @:rnorm@:(v)}
35938 @r{ a b c@: v p @: @: 24 @:calc-pack@:}
35939 @r{ v@: v r @:n >0 @: 21,31 @:mrow@:(v,n)}
35940 @r{ v@: v r @:n <0 @: 31 @:mrrow@:(v,-n)}
35941 @r{ m@: v r @:0 @: 31 @:getdiag@:(m)}
35942 @r{ v i j@: v s @: @: @:subvec@:(v,i,j)}
35943 @r{ v i j@: I v s @: @: @:rsubvec@:(v,i,j)}
35944 @r{ m@: v t @: @: 1 @:trn@:(m)}
35945 @r{ v@: v u @: @: 24 @:calc-unpack@:}
35946 @r{ v@: v v @: @: 1 @:rev@:(v)}
35947 @r{ @: v x @:n @: 31 @:index@:(n)}
35948 @r{ n s i@: C-u v x @: @: @:index@:(n,s,i)}
35951 @r{ v@: V A @:op @: 22 @:apply@:(op,v)}
35952 @r{ v1 v2@: V C @: @: 2 @:cross@:(v1,v2)}
35953 @r{ m@: V D @: @: 1 @:det@:(m)}
35954 @r{ s@: V E @: @: 1 @:venum@:(s)}
35955 @r{ s@: V F @: @: 1 @:vfloor@:(s)}
35956 @r{ v@: V G @: @: @:grade@:(v)}
35957 @r{ v@: I V G @: @: @:rgrade@:(v)}
35958 @r{ v@: V H @:n @: 31 @:histogram@:(v,n)}
35959 @r{ v w@: H V H @:n @: 31 @:histogram@:(v,w,n)}
35960 @r{ v1 v2@: V I @:mop aop @: 22 @:inner@:(mop,aop,v1,v2)}
35961 @r{ m@: V J @: @: 1 @:ctrn@:(m)}
35962 @r{ m@: V L @: @: 1 @:lud@:(m)}
35963 @r{ v@: V M @:op @: 22,23 @:map@:(op,v)}
35964 @r{ v@: V N @: @: 1 @:cnorm@:(v)}
35965 @r{ v1 v2@: V O @:op @: 22 @:outer@:(op,v1,v2)}
35966 @r{ v@: V R @:op @: 22,23 @:reduce@:(op,v)}
35967 @r{ v@: I V R @:op @: 22,23 @:rreduce@:(op,v)}
35968 @r{ a n@: H V R @:op @: 22 @:nest@:(op,a,n)}
35969 @r{ a@: I H V R @:op @: 22 @:fixp@:(op,a)}
35970 @r{ v@: V S @: @: @:sort@:(v)}
35971 @r{ v@: I V S @: @: @:rsort@:(v)}
35972 @r{ m@: V T @: @: 1 @:tr@:(m)}
35973 @r{ v@: V U @:op @: 22 @:accum@:(op,v)}
35974 @r{ v@: I V U @:op @: 22 @:raccum@:(op,v)}
35975 @r{ a n@: H V U @:op @: 22 @:anest@:(op,a,n)}
35976 @r{ a@: I H V U @:op @: 22 @:afixp@:(op,a)}
35977 @r{ s t@: V V @: @: 2 @:vunion@:(s,t)}
35978 @r{ s t@: V X @: @: 2 @:vxor@:(s,t)}
35981 @r{ @: Y @: @: @:@:user commands}
35984 @r{ @: z @: @: @:@:user commands}
35987 @r{ c@: Z [ @: @: 45 @:calc-kbd-if@:}
35988 @r{ c@: Z | @: @: 45 @:calc-kbd-else-if@:}
35989 @r{ @: Z : @: @: @:calc-kbd-else@:}
35990 @r{ @: Z ] @: @: @:calc-kbd-end-if@:}
35993 @r{ @: Z @{ @: @: 4 @:calc-kbd-loop@:}
35994 @r{ c@: Z / @: @: 45 @:calc-kbd-break@:}
35995 @r{ @: Z @} @: @: @:calc-kbd-end-loop@:}
35996 @r{ n@: Z < @: @: @:calc-kbd-repeat@:}
35997 @r{ @: Z > @: @: @:calc-kbd-end-repeat@:}
35998 @r{ n m@: Z ( @: @: @:calc-kbd-for@:}
35999 @r{ s@: Z ) @: @: @:calc-kbd-end-for@:}
36002 @r{ @: Z C-g @: @: @:@:cancel if/loop command}
36005 @r{ @: Z ` @: @: @:calc-kbd-push@:}
36006 @r{ @: Z ' @: @: @:calc-kbd-pop@:}
36007 @r{ @: Z # @: @: @:calc-kbd-query@:}
36010 @r{ comp@: Z C @:func, args @: 50 @:calc-user-define-composition@:}
36011 @r{ @: Z D @:key, command @: @:calc-user-define@:}
36012 @r{ @: Z E @:key, editing @: 30 @:calc-user-define-edit@:}
36013 @r{ defn@: Z F @:k, c, f, a, n@: 28 @:calc-user-define-formula@:}
36014 @r{ @: Z G @:key @: @:calc-get-user-defn@:}
36015 @r{ @: Z I @: @: @:calc-user-define-invocation@:}
36016 @r{ @: Z K @:key, command @: @:calc-user-define-kbd-macro@:}
36017 @r{ @: Z P @:key @: @:calc-user-define-permanent@:}
36018 @r{ @: Z S @: @: 30 @:calc-edit-user-syntax@:}
36019 @r{ @: Z T @: @: 12 @:calc-timing@:}
36020 @r{ @: Z U @:key @: @:calc-user-undefine@:}
36030 Positive prefix arguments apply to @expr{n} stack entries.
36031 Negative prefix arguments apply to the @expr{-n}th stack entry.
36032 A prefix of zero applies to the entire stack. (For @key{LFD} and
36033 @kbd{M-@key{DEL}}, the meaning of the sign is reversed.)
36037 Positive prefix arguments apply to @expr{n} stack entries.
36038 Negative prefix arguments apply to the top stack entry
36039 and the next @expr{-n} stack entries.
36043 Positive prefix arguments rotate top @expr{n} stack entries by one.
36044 Negative prefix arguments rotate the entire stack by @expr{-n}.
36045 A prefix of zero reverses the entire stack.
36049 Prefix argument specifies a repeat count or distance.
36053 Positive prefix arguments specify a precision @expr{p}.
36054 Negative prefix arguments reduce the current precision by @expr{-p}.
36058 A prefix argument is interpreted as an additional step-size parameter.
36059 A plain @kbd{C-u} prefix means to prompt for the step size.
36063 A prefix argument specifies simplification level and depth.
36064 1=Default, 2=like @kbd{a s}, 3=like @kbd{a e}.
36068 A negative prefix operates only on the top level of the input formula.
36072 Positive prefix arguments specify a word size of @expr{w} bits, unsigned.
36073 Negative prefix arguments specify a word size of @expr{w} bits, signed.
36077 Prefix arguments specify the shift amount @expr{n}. The @expr{w} argument
36078 cannot be specified in the keyboard version of this command.
36082 From the keyboard, @expr{d} is omitted and defaults to zero.
36086 Mode is toggled; a positive prefix always sets the mode, and a negative
36087 prefix always clears the mode.
36091 Some prefix argument values provide special variations of the mode.
36095 A prefix argument, if any, is used for @expr{m} instead of taking
36096 @expr{m} from the stack. @expr{M} may take any of these values:
36098 {@advance@tableindent10pt
36102 Random integer in the interval @expr{[0 .. m)}.
36104 Random floating-point number in the interval @expr{[0 .. m)}.
36106 Gaussian with mean 1 and standard deviation 0.
36108 Gaussian with specified mean and standard deviation.
36110 Random integer or floating-point number in that interval.
36112 Random element from the vector.
36120 A prefix argument from 1 to 6 specifies number of date components
36121 to remove from the stack. @xref{Date Conversions}.
36125 A prefix argument specifies a time zone; @kbd{C-u} says to take the
36126 time zone number or name from the top of the stack. @xref{Time Zones}.
36130 A prefix argument specifies a day number (0-6, 0-31, or 0-366).
36134 If the input has no units, you will be prompted for both the old and
36139 With a prefix argument, collect that many stack entries to form the
36140 input data set. Each entry may be a single value or a vector of values.
36144 With a prefix argument of 1, take a single
36145 @texline @var{n}@math{\times2}
36146 @infoline @mathit{@var{N}x2}
36147 matrix from the stack instead of two separate data vectors.
36151 The row or column number @expr{n} may be given as a numeric prefix
36152 argument instead. A plain @kbd{C-u} prefix says to take @expr{n}
36153 from the top of the stack. If @expr{n} is a vector or interval,
36154 a subvector/submatrix of the input is created.
36158 The @expr{op} prompt can be answered with the key sequence for the
36159 desired function, or with @kbd{x} or @kbd{z} followed by a function name,
36160 or with @kbd{$} to take a formula from the top of the stack, or with
36161 @kbd{'} and a typed formula. In the last two cases, the formula may
36162 be a nameless function like @samp{<#1+#2>} or @samp{<x, y : x+y>}, or it
36163 may include @kbd{$}, @kbd{$$}, etc. (where @kbd{$} will correspond to the
36164 last argument of the created function), or otherwise you will be
36165 prompted for an argument list. The number of vectors popped from the
36166 stack by @kbd{V M} depends on the number of arguments of the function.
36170 One of the mapping direction keys @kbd{_} (horizontal, i.e., map
36171 by rows or reduce across), @kbd{:} (vertical, i.e., map by columns or
36172 reduce down), or @kbd{=} (map or reduce by rows) may be used before
36173 entering @expr{op}; these modify the function name by adding the letter
36174 @code{r} for ``rows,'' @code{c} for ``columns,'' @code{a} for ``across,''
36175 or @code{d} for ``down.''
36179 The prefix argument specifies a packing mode. A nonnegative mode
36180 is the number of items (for @kbd{v p}) or the number of levels
36181 (for @kbd{v u}). A negative mode is as described below. With no
36182 prefix argument, the mode is taken from the top of the stack and
36183 may be an integer or a vector of integers.
36185 {@advance@tableindent-20pt
36189 (@var{2}) Rectangular complex number.
36191 (@var{2}) Polar complex number.
36193 (@var{3}) HMS form.
36195 (@var{2}) Error form.
36197 (@var{2}) Modulo form.
36199 (@var{2}) Closed interval.
36201 (@var{2}) Closed .. open interval.
36203 (@var{2}) Open .. closed interval.
36205 (@var{2}) Open interval.
36207 (@var{2}) Fraction.
36209 (@var{2}) Float with integer mantissa.
36211 (@var{2}) Float with mantissa in @expr{[1 .. 10)}.
36213 (@var{1}) Date form (using date numbers).
36215 (@var{3}) Date form (using year, month, day).
36217 (@var{6}) Date form (using year, month, day, hour, minute, second).
36225 A prefix argument specifies the size @expr{n} of the matrix. With no
36226 prefix argument, @expr{n} is omitted and the size is inferred from
36231 The prefix argument specifies the starting position @expr{n} (default 1).
36235 Cursor position within stack buffer affects this command.
36239 Arguments are not actually removed from the stack by this command.
36243 Variable name may be a single digit or a full name.
36247 Editing occurs in a separate buffer. Press @kbd{C-c C-c} (or
36248 @key{LFD}, or in some cases @key{RET}) to finish the edit, or kill the
36249 buffer with @kbd{C-x k} to cancel the edit. The @key{LFD} key prevents evaluation
36250 of the result of the edit.
36254 The number prompted for can also be provided as a prefix argument.
36258 Press this key a second time to cancel the prefix.
36262 With a negative prefix, deactivate all formulas. With a positive
36263 prefix, deactivate and then reactivate from scratch.
36267 Default is to scan for nearest formula delimiter symbols. With a
36268 prefix of zero, formula is delimited by mark and point. With a
36269 non-zero prefix, formula is delimited by scanning forward or
36270 backward by that many lines.
36274 Parse the region between point and mark as a vector. A nonzero prefix
36275 parses @var{n} lines before or after point as a vector. A zero prefix
36276 parses the current line as a vector. A @kbd{C-u} prefix parses the
36277 region between point and mark as a single formula.
36281 Parse the rectangle defined by point and mark as a matrix. A positive
36282 prefix @var{n} divides the rectangle into columns of width @var{n}.
36283 A zero or @kbd{C-u} prefix parses each line as one formula. A negative
36284 prefix suppresses special treatment of bracketed portions of a line.
36288 A numeric prefix causes the current language mode to be ignored.
36292 Responding to a prompt with a blank line answers that and all
36293 later prompts by popping additional stack entries.
36297 Answer for @expr{v} may also be of the form @expr{v = v_0} or
36302 With a positive prefix argument, stack contains many @expr{y}'s and one
36303 common @expr{x}. With a zero prefix, stack contains a vector of
36304 @expr{y}s and a common @expr{x}. With a negative prefix, stack
36305 contains many @expr{[x,y]} vectors. (For 3D plots, substitute
36306 @expr{z} for @expr{y} and @expr{x,y} for @expr{x}.)
36310 With any prefix argument, all curves in the graph are deleted.
36314 With a positive prefix, refines an existing plot with more data points.
36315 With a negative prefix, forces recomputation of the plot data.
36319 With any prefix argument, set the default value instead of the
36320 value for this graph.
36324 With a negative prefix argument, set the value for the printer.
36328 Condition is considered ``true'' if it is a nonzero real or complex
36329 number, or a formula whose value is known to be nonzero; it is ``false''
36334 Several formulas separated by commas are pushed as multiple stack
36335 entries. Trailing @kbd{)}, @kbd{]}, @kbd{@}}, @kbd{>}, and @kbd{"}
36336 delimiters may be omitted. The notation @kbd{$$$} refers to the value
36337 in stack level three, and causes the formula to replace the top three
36338 stack levels. The notation @kbd{$3} refers to stack level three without
36339 causing that value to be removed from the stack. Use @key{LFD} in place
36340 of @key{RET} to prevent evaluation; use @kbd{M-=} in place of @key{RET}
36341 to evaluate variables.
36345 The variable is replaced by the formula shown on the right. The
36346 Inverse flag reverses the order of the operands, e.g., @kbd{I s - x}
36348 @texline @math{x \coloneq a-x}.
36349 @infoline @expr{x := a-x}.
36353 Press @kbd{?} repeatedly to see how to choose a model. Answer the
36354 variables prompt with @expr{iv} or @expr{iv;pv} to specify
36355 independent and parameter variables. A positive prefix argument
36356 takes @mathit{@var{n}+1} vectors from the stack; a zero prefix takes a matrix
36357 and a vector from the stack.
36361 With a plain @kbd{C-u} prefix, replace the current region of the
36362 destination buffer with the yanked text instead of inserting.
36366 All stack entries are reformatted; the @kbd{H} prefix inhibits this.
36367 The @kbd{I} prefix sets the mode temporarily, redraws the top stack
36368 entry, then restores the original setting of the mode.
36372 A negative prefix sets the default 3D resolution instead of the
36373 default 2D resolution.
36377 This grabs a vector of the form [@var{prec}, @var{wsize}, @var{ssize},
36378 @var{radix}, @var{flfmt}, @var{ang}, @var{frac}, @var{symb}, @var{polar},
36379 @var{matrix}, @var{simp}, @var{inf}]. A prefix argument from 1 to 12
36380 grabs the @var{n}th mode value only.
36384 (Space is provided below for you to keep your own written notes.)
36392 @node Key Index, Command Index, Summary, Top
36393 @unnumbered Index of Key Sequences
36397 @node Command Index, Function Index, Key Index, Top
36398 @unnumbered Index of Calculator Commands
36400 Since all Calculator commands begin with the prefix @samp{calc-}, the
36401 @kbd{x} key has been provided as a variant of @kbd{M-x} which automatically
36402 types @samp{calc-} for you. Thus, @kbd{x last-args} is short for
36403 @kbd{M-x calc-last-args}.
36407 @node Function Index, Concept Index, Command Index, Top
36408 @unnumbered Index of Algebraic Functions
36410 This is a list of built-in functions and operators usable in algebraic
36411 expressions. Their full Lisp names are derived by adding the prefix
36412 @samp{calcFunc-}, as in @code{calcFunc-sqrt}.
36414 All functions except those noted with ``*'' have corresponding
36415 Calc keystrokes and can also be found in the Calc Summary.
36420 @node Concept Index, Variable Index, Function Index, Top
36421 @unnumbered Concept Index
36425 @node Variable Index, Lisp Function Index, Concept Index, Top
36426 @unnumbered Index of Variables
36428 The variables in this list that do not contain dashes are accessible
36429 as Calc variables. Add a @samp{var-} prefix to get the name of the
36430 corresponding Lisp variable.
36432 The remaining variables are Lisp variables suitable for @code{setq}ing
36433 in your Calc init file or @file{.emacs} file.
36437 @node Lisp Function Index, , Variable Index, Top
36438 @unnumbered Index of Lisp Math Functions
36440 The following functions are meant to be used with @code{defmath}, not
36441 @code{defun} definitions. For names that do not start with @samp{calc-},
36442 the corresponding full Lisp name is derived by adding a prefix of
36456 arch-tag: 77a71809-fa4d-40be-b2cc-da3e8fb137c0